diff options
Diffstat (limited to 'host/lib/deps/rpclib/include/rpc/msgpack/adaptor')
45 files changed, 26640 insertions, 0 deletions
diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/adaptor_base.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/adaptor_base.hpp new file mode 100644 index 000000000..70f19b0c4 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/adaptor_base.hpp @@ -0,0 +1,92 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2015 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_ADAPTOR_BASE_HPP +#define MSGPACK_ADAPTOR_BASE_HPP + +#include "rpc/msgpack/object_fwd.hpp" + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +template <typename Stream> +class packer; + +namespace adaptor { + +// Adaptor functors + +template <typename T, typename Enabler = void> +struct convert { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, T& v) const; +}; + +template <typename T, typename Enabler = void> +struct pack { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, T const& v) const; +}; + +template <typename T, typename Enabler = void> +struct object { + void operator()(clmdep_msgpack::object& o, T const& v) const; +}; + +template <typename T, typename Enabler = void> +struct object_with_zone { + void operator()(clmdep_msgpack::object::with_zone& o, T const& v) const; +}; + +} // namespace adaptor + +// operators + +template <typename T> +inline +clmdep_msgpack::object const& operator>> (clmdep_msgpack::object const& o, T& v) { + return adaptor::convert<T>()(o, v); +} + +template <typename Stream, typename T> +inline +clmdep_msgpack::packer<Stream>& operator<< (clmdep_msgpack::packer<Stream>& o, T const& v) { + return adaptor::pack<T>()(o, v); +} + +template <typename T> +inline +void operator<< (clmdep_msgpack::object& o, T const& v) { + adaptor::object<T>()(o, v); +} + +template <typename T> +inline +void operator<< (clmdep_msgpack::object::with_zone& o, T const& v) { + adaptor::object_with_zone<T>()(o, v); +} + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + + +#endif // MSGPACK_ADAPTOR_BASE_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/array_ref.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/array_ref.hpp new file mode 100644 index 000000000..393fc906e --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/array_ref.hpp @@ -0,0 +1,182 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2009 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_ARRAY_REF_HPP +#define MSGPACK_TYPE_ARRAY_REF_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" +#include "rpc/msgpack/adaptor/check_container_size.hpp" +#include <cstring> +#include <string> + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace type { + +template <typename T> +struct array_ref { + array_ref() : data(nullptr) {} + array_ref(T& t) : data(&t) {} + + T* data; + + template <typename U> + bool operator==(array_ref<U> const& t) const { + return *data == *t.data; + } + template <typename U> + bool operator!=(array_ref<U> const& t) const { + return !(*data == *t.data); + } + template <typename U> + bool operator< (array_ref<U> const& t) const + { + return *data < *t.data; + } + template <typename U> + bool operator> (array_ref<U> const& t) const + { + return *t.data < *data; + } + template <typename U> + bool operator<= (array_ref<U> const& t) const + { + return !(*t.data < *data); + } + template <typename U> + bool operator>= (array_ref<U> const& t) const + { + return !(*data < *t.data); + } +}; + +template <typename T> +inline array_ref<T const> make_array_ref(T const& t) { + return array_ref<T const>(t); +} + +template <typename T> +inline array_ref<T> make_array_ref(T& t) { + return array_ref<T>(t); +} + + +} // namespace type + +namespace adaptor { + +template <typename T> +struct convert<clmdep_msgpack::type::array_ref<T> > { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, clmdep_msgpack::type::array_ref<T>& v) const { + if (!v.data) { throw clmdep_msgpack::type_error(); } + if (o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if (v.data->size() < o.via.bin.size) { throw clmdep_msgpack::type_error(); } + if (o.via.array.size > 0) { + clmdep_msgpack::object* p = o.via.array.ptr; + clmdep_msgpack::object* const pend = o.via.array.ptr + o.via.array.size; + typename T::iterator it = v.data->begin(); + do { + p->convert(*it); + ++p; + ++it; + } while(p < pend); + } + return o; + } +}; + +template <typename T> +struct convert<clmdep_msgpack::type::array_ref<std::vector<T> > > { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, clmdep_msgpack::type::array_ref<std::vector<T> >& v) const { + if (!v.data) { throw clmdep_msgpack::type_error(); } + if (o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + v.data->resize(o.via.bin.size); + if (o.via.array.size > 0) { + clmdep_msgpack::object* p = o.via.array.ptr; + clmdep_msgpack::object* const pend = o.via.array.ptr + o.via.array.size; + typename std::vector<T>::iterator it = v.data->begin(); + do { + p->convert(*it); + ++p; + ++it; + } while(p < pend); + } + return o; + } +}; + +template <typename T> +struct pack<clmdep_msgpack::type::array_ref<T> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const clmdep_msgpack::type::array_ref<T>& v) const { + if (!v.data) { throw clmdep_msgpack::type_error(); } + uint32_t size = checked_get_container_size(v.data->size()); + o.pack_array(size); + for (typename T::const_iterator it(v.data->begin()), it_end(v.data->end()); + it != it_end; ++it) { + o.pack(*it); + } + return o; + } +}; + +template <typename T> +struct object_with_zone<clmdep_msgpack::type::array_ref<T> > { + void operator()(clmdep_msgpack::object::with_zone& o, const clmdep_msgpack::type::array_ref<T>& v) const { + if (!v.data) { throw clmdep_msgpack::type_error(); } + o.type = clmdep_msgpack::type::ARRAY; + if (v.data->empty()) { + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } + else { + uint32_t size = checked_get_container_size(v.data->size()); + clmdep_msgpack::object* p = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*size)); + clmdep_msgpack::object* const pend = p + size; + o.via.array.ptr = p; + o.via.array.size = size; + typename T::const_iterator it(v.data->begin()); + do { +#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wmaybe-uninitialized" +#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__) + *p = clmdep_msgpack::object(*it, o.zone); +#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__) + ++p; + ++it; + } while(p < pend); + } + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif // MSGPACK_TYPE_ARRAY_REF_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/bool.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/bool.hpp new file mode 100644 index 000000000..f5867ca3f --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/bool.hpp @@ -0,0 +1,74 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2009 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_BOOL_HPP +#define MSGPACK_TYPE_BOOL_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace adaptor { + +template <> +struct convert<bool> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, bool& v) const { + if(o.type != clmdep_msgpack::type::BOOLEAN) { throw clmdep_msgpack::type_error(); } + v = o.via.boolean; + return o; + } +}; + +template <> +struct pack<bool> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const bool& v) const { + if(v) { o.pack_true(); } + else { o.pack_false(); } + return o; + } +}; + +template <> +struct object<bool> { + void operator()(clmdep_msgpack::object& o, bool v) const { + o.type = clmdep_msgpack::type::BOOLEAN; + o.via.boolean = v; + } +}; + +template <> +struct object_with_zone<bool> { + void operator()(clmdep_msgpack::object::with_zone& o, bool v) const { + static_cast<clmdep_msgpack::object&>(o) << v; + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif // MSGPACK_TYPE_BOOL_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/boost/fusion.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/boost/fusion.hpp new file mode 100644 index 000000000..98085f2ba --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/boost/fusion.hpp @@ -0,0 +1,168 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2015 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_BOOST_FUSION_HPP +#define MSGPACK_TYPE_BOOST_FUSION_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" +#include "rpc/msgpack/adaptor/check_container_size.hpp" +#include "rpc/msgpack/meta.hpp" + +#if !defined (MSGPACK_USE_CPP03) +#include "rpc/msgpack/adaptor/cpp11/tuple.hpp" +#endif // #if !defined (MSGPACK_USE_CPP03) + +#include <boost/fusion/support/is_sequence.hpp> +#include <boost/fusion/sequence/intrinsic/size.hpp> +#include <boost/fusion/algorithm/iteration/for_each.hpp> +#include <boost/fusion/sequence/intrinsic/at.hpp> +#include <boost/fusion/include/mpl.hpp> +#include <boost/mpl/size.hpp> + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace adaptor { + +#if !defined (MSGPACK_USE_CPP03) + +template <typename T> +struct as< + T, + typename clmdep_msgpack::enable_if< + boost::fusion::traits::is_sequence<T>::value && + boost::mpl::fold< + T, + boost::mpl::bool_<true>, + boost::mpl::if_ < + boost::mpl::and_< + boost::mpl::_1, + clmdep_msgpack::has_as<boost::mpl::_2> + >, + boost::mpl::bool_<true>, + boost::mpl::bool_<false> + > + >::type::value + >::type +> { + T operator()(clmdep_msgpack::object const& o) const { + if (o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if (o.via.array.size != checked_get_container_size(boost::mpl::size<T>::value)) { + throw clmdep_msgpack::type_error(); + } + using tuple_t = decltype(to_tuple(std::declval<T>(), gen_seq<boost::mpl::size<T>::value>())); + return to_t( + o.as<tuple_t>(), + clmdep_msgpack::gen_seq<boost::mpl::size<T>::value>()); + } + template<std::size_t... Is, typename U> + static std::tuple< + typename std::remove_reference< + typename boost::fusion::result_of::at_c<T, Is>::type + >::type...> + to_tuple(U const& u, seq<Is...>) { + return std::make_tuple(boost::fusion::at_c<Is>(u)...); + } + template<std::size_t... Is, typename U> + static T to_t(U const& u, seq<Is...>) { + return T(std::get<Is>(u)...); + } +}; + +#endif // !defined (MSGPACK_USE_CPP03) + +template <typename T> +struct convert<T, typename clmdep_msgpack::enable_if<boost::fusion::traits::is_sequence<T>::value>::type > { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, T& v) const { + if (o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if (o.via.array.size != checked_get_container_size(boost::fusion::size(v))) { + throw clmdep_msgpack::type_error(); + } + uint32_t index = 0; + boost::fusion::for_each(v, convert_imp(o, index)); + return o; + } +private: + struct convert_imp { + convert_imp(clmdep_msgpack::object const& obj, uint32_t& index):obj_(obj), index_(index) {} + template <typename U> + void operator()(U& v) const { + clmdep_msgpack::adaptor::convert<U>()(obj_.via.array.ptr[index_++], v); + } + private: + clmdep_msgpack::object const& obj_; + uint32_t& index_; + }; +}; + +template <typename T> +struct pack<T, typename clmdep_msgpack::enable_if<boost::fusion::traits::is_sequence<T>::value>::type > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const T& v) const { + uint32_t size = checked_get_container_size(boost::fusion::size(v)); + o.pack_array(size); + boost::fusion::for_each(v, pack_imp<Stream>(o)); + return o; + } +private: + template <typename Stream> + struct pack_imp { + pack_imp(clmdep_msgpack::packer<Stream>& stream):stream_(stream) {} + template <typename U> + void operator()(U const& v) const { + stream_.pack(v); + } + private: + clmdep_msgpack::packer<Stream>& stream_; + }; +}; + +template <typename T> +struct object_with_zone<T, typename clmdep_msgpack::enable_if<boost::fusion::traits::is_sequence<T>::value>::type > { + void operator()(clmdep_msgpack::object::with_zone& o, const T& v) const { + uint32_t size = checked_get_container_size(boost::fusion::size(v)); + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*size)); + o.via.array.size = size; + uint32_t count = 0; + boost::fusion::for_each(v, with_zone_imp(o, count)); + } +private: + struct with_zone_imp { + with_zone_imp(clmdep_msgpack::object::with_zone const& obj, uint32_t& count):obj_(obj), count_(count) {} + template <typename U> + void operator()(U const& v) const { + obj_.via.array.ptr[count_++] = clmdep_msgpack::object(v, obj_.zone); + } + clmdep_msgpack::object::with_zone const& obj_; + uint32_t& count_; + }; +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif // MSGPACK_TYPE_BOOST_FUSION_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/boost/msgpack_variant.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/boost/msgpack_variant.hpp new file mode 100644 index 000000000..7dbd2bec4 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/boost/msgpack_variant.hpp @@ -0,0 +1,438 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2015 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_HPP +#define MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_HPP + +#if defined(MSGPACK_USE_BOOST) + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" +#include "rpc/msgpack/adaptor/check_container_size.hpp" +#include "rpc/msgpack/adaptor/boost/string_ref.hpp" + +#include "rpc/msgpack/adaptor/nil.hpp" +#include "rpc/msgpack/adaptor/bool.hpp" +#include "rpc/msgpack/adaptor/int.hpp" +#include "rpc/msgpack/adaptor/float.hpp" +#include "rpc/msgpack/adaptor/string.hpp" +#include "rpc/msgpack/adaptor/vector_char.hpp" +#include "rpc/msgpack/adaptor/raw.hpp" +#include "rpc/msgpack/adaptor/ext.hpp" +#include "rpc/msgpack/adaptor/vector.hpp" +#include "rpc/msgpack/adaptor/map.hpp" + +#include <boost/variant.hpp> +#include <boost/operators.hpp> + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace type { + + +template <typename STR, typename BIN, typename EXT> +struct basic_variant : + boost::variant< + nil, // NIL + bool, // BOOL + int64_t, // NEGATIVE_INTEGER + uint64_t, // POSITIVE_INTEGER + double, // FLOAT + std::string, // STR +#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + boost::string_ref, // STR +#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + std::vector<char>, // BIN + clmdep_msgpack::type::raw_ref, // BIN + ext, // EXT + ext_ref, // EXT + boost::recursive_wrapper<std::vector<basic_variant<STR, BIN, EXT> > >, // ARRAY + boost::recursive_wrapper<std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >, // MAP + boost::recursive_wrapper<std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >// MAP + >, + private boost::totally_ordered<basic_variant<STR, BIN, EXT> > { + typedef boost::variant< + nil, // NIL + bool, // BOOL + int64_t, // NEGATIVE_INTEGER + uint64_t, // POSITIVE_INTEGER + double, // FLOAT + std::string, // STR +#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + boost::string_ref, // STR +#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + std::vector<char>, // BIN + clmdep_msgpack::type::raw_ref, // BIN + ext, // EXT + ext_ref, // EXT + boost::recursive_wrapper<std::vector<basic_variant<STR, BIN, EXT> > >, // ARRAY + boost::recursive_wrapper<std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >, // MAP + boost::recursive_wrapper<std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >// MAP + > base; + basic_variant() {} + template <typename T> + basic_variant(T const& t):base(t) {} + basic_variant(char const* p):base(std::string(p)) {} + basic_variant(char v) { + int_init(v); + } + basic_variant(signed char v) { + int_init(v); + } + basic_variant(unsigned char v):base(uint64_t(v)) {} + basic_variant(signed int v) { + int_init(v); + } + basic_variant(unsigned int v):base(uint64_t(v)) {} + basic_variant(signed long v) { + int_init(v); + } + basic_variant(unsigned long v):base(uint64_t(v)) {} + basic_variant(signed long long v) { + int_init(v); + } + basic_variant(unsigned long long v):base(uint64_t(v)) {} + + bool is_nil() const { + return boost::get<nil>(this); + } + bool is_bool() const { + return boost::get<bool>(this); + } + bool is_int64_t() const { + return boost::get<int64_t>(this); + } + bool is_uint64_t() const { + return boost::get<uint64_t>(this); + } + bool is_double() const { + return boost::get<double>(this); + } + bool is_string() const { + return boost::get<std::string>(this); + } +#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + bool is_boost_string_ref() const { + return boost::get<boost::string_ref>(this); + } +#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + bool is_vector_char() const { + return boost::get<std::vector<char> >(this); + } + bool is_vector_char() { + return boost::get<std::vector<char> >(this); + } + bool is_raw_ref() const { + return boost::get<raw_ref>(this); + } + bool is_ext() const { + return boost::get<ext>(this); + } + bool is_ext_ref() const { + return boost::get<ext_ref>(this); + } + bool is_vector() const { + return boost::get<std::vector<basic_variant<STR, BIN, EXT> > >(this); + } + bool is_map() const { + return boost::get<std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >(this); + } + bool is_multimap() const { + return boost::get<std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >(this); + } + + bool as_bool() const { + return boost::get<bool>(*this); + } + int64_t as_int64_t() const { + return boost::get<int64_t>(*this); + } + int64_t& as_int64_t() { + return boost::get<int64_t>(*this); + } + uint64_t as_uint64_t() const { + return boost::get<uint64_t>(*this); + } + uint64_t& as_uint64_t() { + return boost::get<uint64_t>(*this); + } + double as_double() const { + return boost::get<double>(*this); + } + double& as_double() { + return boost::get<double>(*this); + } + std::string const& as_string() const { + return boost::get<std::string>(*this); + } + std::string& as_string() { + return boost::get<std::string>(*this); + } +#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + boost::string_ref const& as_boost_string_ref() const { + return boost::get<boost::string_ref>(*this); + } + boost::string_ref& as_boost_string_ref() { + return boost::get<boost::string_ref>(*this); + } +#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + std::vector<char> const& as_vector_char() const { + return boost::get<std::vector<char> >(*this); + } + std::vector<char>& as_vector_char() { + return boost::get<std::vector<char> >(*this); + } + raw_ref const& as_raw_ref() const { + return boost::get<raw_ref>(*this); + } + ext const& as_ext() const { + return boost::get<ext>(*this); + } + ext& as_ext() { + return boost::get<ext>(*this); + } + ext_ref const& as_ext_ref() const { + return boost::get<ext_ref>(*this); + } + std::vector<basic_variant<STR, BIN, EXT> > const& as_vector() const { + return boost::get<std::vector<basic_variant<STR, BIN, EXT> > >(*this); + } + std::vector<basic_variant<STR, BIN, EXT> >& as_vector() { + return boost::get<std::vector<basic_variant<STR, BIN, EXT> > >(*this); + } + std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > const& as_map() const { + return boost::get<std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >(*this); + } + std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> >& as_map() { + return boost::get<std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >(*this); + } + std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > const& as_multimap() const { + return boost::get<std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >(*this); + } + std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> >& as_multimap() { + return boost::get<std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >(*this); + } +private: + template <typename T> + void int_init(T v) { + if (v < 0) { + static_cast<base&>(*this) = int64_t(v); + } + else { + static_cast<base&>(*this) = uint64_t(v); + } + } +}; + +template <typename STR, typename BIN, typename EXT> +inline bool operator<(basic_variant<STR, BIN, EXT> const& lhs, basic_variant<STR, BIN, EXT> const& rhs) { + return + static_cast<typename basic_variant<STR, BIN, EXT>::base const&>(lhs) < + static_cast<typename basic_variant<STR, BIN, EXT>::base const&>(rhs); +} + +template <typename STR, typename BIN, typename EXT> +inline bool operator==(basic_variant<STR, BIN, EXT> const& lhs, basic_variant<STR, BIN, EXT> const& rhs) { + return + static_cast<typename basic_variant<STR, BIN, EXT>::base const&>(lhs) == + static_cast<typename basic_variant<STR, BIN, EXT>::base const&>(rhs); +} + +typedef basic_variant<std::string, std::vector<char>, ext> variant; +typedef basic_variant< +#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + boost::string_ref, +#else // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + std::string, +#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + raw_ref, ext_ref> variant_ref; + +} // namespace type + +namespace adaptor { + +#if !defined (MSGPACK_USE_CPP03) + +template <typename STR, typename BIN, typename EXT> +struct as<clmdep_msgpack::type::basic_variant<STR, BIN, EXT> > { + clmdep_msgpack::type::basic_variant<STR, BIN, EXT> operator()(clmdep_msgpack::object const& o) const { + switch(o.type) { + case type::NIL: + return o.as<clmdep_msgpack::type::nil>(); + case type::BOOLEAN: + return o.as<bool>(); + case type::POSITIVE_INTEGER: + return o.as<uint64_t>(); + case type::NEGATIVE_INTEGER: + return o.as<int64_t>(); + case type::FLOAT: + return o.as<double>(); + case type::STR: + return o.as<STR>(); + case type::BIN: + return o.as<BIN>(); + case type::EXT: + return o.as<EXT>(); + case type::ARRAY: + return o.as<std::vector<clmdep_msgpack::type::basic_variant<STR, BIN, EXT> > >(); + case type::MAP: + return o.as<std::multimap<clmdep_msgpack::type::basic_variant<STR, BIN, EXT>, clmdep_msgpack::type::basic_variant<STR, BIN, EXT> > >(); + default: + break; + } + return clmdep_msgpack::type::basic_variant<STR, BIN, EXT>(); + } +}; + +#endif // !defined (MSGPACK_USE_CPP03) + + +template <typename STR, typename BIN, typename EXT> +struct convert<clmdep_msgpack::type::basic_variant<STR, BIN, EXT> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + clmdep_msgpack::type::basic_variant<STR, BIN, EXT>& v) const { + switch(o.type) { + case type::NIL: + v = o.as<clmdep_msgpack::type::nil>(); + break; + case type::BOOLEAN: + v = o.as<bool>(); + break; + case type::POSITIVE_INTEGER: + v = o.as<uint64_t>(); + break; + case type::NEGATIVE_INTEGER: + v = o.as<int64_t>(); + break; + case type::FLOAT: + v = o.as<double>(); + break; + case type::STR: + v = o.as<STR>(); + break; + case type::BIN: + v = o.as<BIN>(); + break; + case type::EXT: + v = o.as<EXT>(); + break; + case type::ARRAY: + v = o.as<std::vector<clmdep_msgpack::type::basic_variant<STR, BIN, EXT> > >(); + break; + case type::MAP: + v = o.as<std::multimap<clmdep_msgpack::type::basic_variant<STR, BIN, EXT>, clmdep_msgpack::type::basic_variant<STR, BIN, EXT> > >(); + break; + default: + break; + } + return o; + } +}; + +namespace detail { + +template <typename Stream> +struct pack_imp : boost::static_visitor<void> { + template <typename T> + void operator()(T const& value) const { + pack<T>()(o_, value); + } + pack_imp(packer<Stream>& o):o_(o) {} + packer<Stream>& o_; +}; + +} // namespace detail + +template <typename STR, typename BIN, typename EXT> +struct pack<clmdep_msgpack::type::basic_variant<STR, BIN, EXT> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const clmdep_msgpack::type::basic_variant<STR, BIN, EXT>& v) const { + boost::apply_visitor(detail::pack_imp<Stream>(o), v); + return o; + } +}; + +namespace detail { + +struct object_imp : boost::static_visitor<void> { + void operator()(clmdep_msgpack::type::nil const& v) const { + object<clmdep_msgpack::type::nil>()(o_, v); + } + void operator()(bool const& v) const { + object<bool>()(o_, v); + } + void operator()(uint64_t const& v) const { + object<uint64_t>()(o_, v); + } + void operator()(int64_t const& v) const { + object<int64_t>()(o_, v); + } + void operator()(double const& v) const { + object<double>()(o_, v); + } + template <typename T> + void operator()(T const&) const { + throw clmdep_msgpack::type_error(); + } + object_imp(clmdep_msgpack::object& o):o_(o) {} + clmdep_msgpack::object& o_; +}; + +} // namespace detail + +template <typename STR, typename BIN, typename EXT> +struct object<clmdep_msgpack::type::basic_variant<STR, BIN, EXT> > { + void operator()(clmdep_msgpack::object& o, const clmdep_msgpack::type::basic_variant<STR, BIN, EXT>& v) const { + boost::apply_visitor(detail::object_imp(o), v); + } +}; + +namespace detail { + +struct object_with_zone_imp : boost::static_visitor<void> { + template <typename T> + void operator()(T const& v) const { + object_with_zone<T>()(o_, v); + } + object_with_zone_imp(clmdep_msgpack::object::with_zone& o):o_(o) {} + clmdep_msgpack::object::with_zone& o_; +}; + +} // namespace detail + +template <typename STR, typename BIN, typename EXT> +struct object_with_zone<clmdep_msgpack::type::basic_variant<STR, BIN, EXT> > { + void operator()(clmdep_msgpack::object::with_zone& o, const clmdep_msgpack::type::basic_variant<STR, BIN, EXT>& v) const { + boost::apply_visitor(detail::object_with_zone_imp(o), v); + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif // MSGPACK_USE_BOOST +#endif // MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/boost/optional.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/boost/optional.hpp new file mode 100644 index 000000000..74f7908e0 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/boost/optional.hpp @@ -0,0 +1,104 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2015 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_BOOST_OPTIONAL_HPP +#define MSGPACK_TYPE_BOOST_OPTIONAL_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" +#include "rpc/msgpack/adaptor/check_container_size.hpp" + +// To supress warning on Boost.1.58.0 +#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-parameter" +#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__) + +#include <boost/optional.hpp> + +#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__) +#pragma GCC diagnostic pop +#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__) + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace adaptor { + +#if !defined (MSGPACK_USE_CPP03) + +template <typename T> +struct as<boost::optional<T>, typename std::enable_if<clmdep_msgpack::has_as<T>::value>::type> { + boost::optional<T> operator()(clmdep_msgpack::object const& o) const { + if(o.is_nil()) return boost::none; + return o.as<T>(); + } +}; + +#endif // !defined (MSGPACK_USE_CPP03) + +template <typename T> +struct convert<boost::optional<T> > { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, boost::optional<T>& v) const { + if(o.is_nil()) v = boost::none; + else { + T t; + clmdep_msgpack::adaptor::convert<T>()(o, t); + v = t; + } + return o; + } +}; + +template <typename T> +struct pack<boost::optional<T> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const boost::optional<T>& v) const { + if (v) o.pack(*v); + else o.pack_nil(); + return o; + } +}; + +template <typename T> +struct object<boost::optional<T> > { + void operator()(clmdep_msgpack::object& o, const boost::optional<T>& v) const { + if (v) clmdep_msgpack::adaptor::object<T>()(o, *v); + else o.type = clmdep_msgpack::type::NIL; + } +}; + +template <typename T> +struct object_with_zone<boost::optional<T> > { + void operator()(clmdep_msgpack::object::with_zone& o, const boost::optional<T>& v) const { + if (v) clmdep_msgpack::adaptor::object_with_zone<T>()(o, *v); + else o.type = clmdep_msgpack::type::NIL; + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif // MSGPACK_TYPE_BOOST_OPTIONAL_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/boost/string_ref.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/boost/string_ref.hpp new file mode 100644 index 000000000..6dea3da5f --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/boost/string_ref.hpp @@ -0,0 +1,95 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2015 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_BOOST_STRING_REF_HPP +#define MSGPACK_TYPE_BOOST_STRING_REF_HPP + +#include <boost/version.hpp> +#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" +#include "rpc/msgpack/adaptor/check_container_size.hpp" + +#include <boost/utility/string_ref.hpp> + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace adaptor { + +template <> +struct convert<boost::string_ref> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, boost::string_ref& v) const { + switch (o.type) { + case clmdep_msgpack::type::BIN: + v = boost::string_ref(o.via.bin.ptr, o.via.bin.size); + break; + case clmdep_msgpack::type::STR: + v = boost::string_ref(o.via.str.ptr, o.via.str.size); + break; + default: + throw clmdep_msgpack::type_error(); + break; + } + return o; + } +}; + +template <> +struct pack<boost::string_ref> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const boost::string_ref& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.pack_str(size); + o.pack_str_body(v.data(), size); + return o; + } +}; + +template <> +struct object<boost::string_ref> { + void operator()(clmdep_msgpack::object& o, const boost::string_ref& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.type = clmdep_msgpack::type::STR; + o.via.str.ptr = v.data(); + o.via.str.size = size; + } +}; + +template <> +struct object_with_zone<boost::string_ref> { + void operator()(clmdep_msgpack::object::with_zone& o, const boost::string_ref& v) const { + static_cast<clmdep_msgpack::object&>(o) << v; + } +}; + + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + +#endif // MSGPACK_TYPE_BOOST_STRING_REF_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/char_ptr.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/char_ptr.hpp new file mode 100644 index 000000000..0743524a2 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/char_ptr.hpp @@ -0,0 +1,165 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2014-2015 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_CHAR_PTR_HPP +#define MSGPACK_TYPE_CHAR_PTR_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/object_fwd.hpp" +#include "rpc/msgpack/adaptor/check_container_size.hpp" + +#include <cstring> + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace adaptor { + +template <> +struct pack<const char*> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const char* v) const { + uint32_t size = checked_get_container_size(std::strlen(v)); + o.pack_str(size); + o.pack_str_body(v, size); + return o; + } +}; + +template <> +struct object_with_zone<const char*> { + void operator()(clmdep_msgpack::object::with_zone& o, const char* v) const { + uint32_t size = checked_get_container_size(std::strlen(v)); + o.type = clmdep_msgpack::type::STR; + char* ptr = static_cast<char*>(o.zone.allocate_align(size)); + o.via.str.ptr = ptr; + o.via.str.size = size; + std::memcpy(ptr, v, size); + } +}; + +template <> +struct object<const char*> { + void operator()(clmdep_msgpack::object& o, const char* v) const { + uint32_t size = checked_get_container_size(std::strlen(v)); + o.type = clmdep_msgpack::type::STR; + o.via.str.ptr = v; + o.via.str.size = size; + } +}; + + +template <> +struct pack<char*> { + template <typename Stream> + packer<Stream>& operator()(packer<Stream>& o, char* v) const { + return o << static_cast<const char*>(v); + } +}; + +template <> +struct object_with_zone<char*> { + void operator()(clmdep_msgpack::object::with_zone& o, char* v) const { + o << static_cast<const char*>(v); + } +}; + +template <> +struct object<char*> { + void operator()(clmdep_msgpack::object& o, char* v) const { + o << static_cast<const char*>(v); + } +}; + +template <std::size_t N> +struct pack<char[N]> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const char* v) const { + uint32_t size = checked_get_container_size(std::strlen(v)); + o.pack_str(size); + o.pack_str_body(v, size); + return o; + } +}; + +template <std::size_t N> +struct object_with_zone<char[N]> { + void operator()(clmdep_msgpack::object::with_zone& o, const char* v) const { + uint32_t size = checked_get_container_size(std::strlen(v)); + o.type = clmdep_msgpack::type::STR; + char* ptr = static_cast<char*>(o.zone.allocate_align(size)); + o.via.str.ptr = ptr; + o.via.str.size = size; + std::memcpy(ptr, v, size); + } +}; + +template <std::size_t N> +struct object<char[N]> { + void operator()(clmdep_msgpack::object& o, const char* v) const { + uint32_t size = checked_get_container_size(std::strlen(v)); + o.type = clmdep_msgpack::type::STR; + o.via.str.ptr = v; + o.via.str.size = size; + } +}; + +template <std::size_t N> +struct pack<const char[N]> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const char* v) const { + uint32_t size = checked_get_container_size(std::strlen(v)); + o.pack_str(size); + o.pack_str_body(v, size); + return o; + } +}; + +template <std::size_t N> +struct object_with_zone<const char[N]> { + void operator()(clmdep_msgpack::object::with_zone& o, const char* v) const { + uint32_t size = checked_get_container_size(std::strlen(v)); + o.type = clmdep_msgpack::type::STR; + char* ptr = static_cast<char*>(o.zone.allocate_align(size)); + o.via.str.ptr = ptr; + o.via.str.size = size; + std::memcpy(ptr, v, size); + } +}; + +template <std::size_t N> +struct object<const char[N]> { + void operator()(clmdep_msgpack::object& o, const char* v) const { + uint32_t size = checked_get_container_size(std::strlen(v)); + o.type = clmdep_msgpack::type::STR; + o.via.str.ptr = v; + o.via.str.size = size; + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif // MSGPACK_TYPE_CHAR_PTR_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/check_container_size.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/check_container_size.hpp new file mode 100644 index 000000000..a5b4531b3 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/check_container_size.hpp @@ -0,0 +1,75 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2015 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_CHECK_CONTAINER_SIZE_HPP +#define MSGPACK_CHECK_CONTAINER_SIZE_HPP + +#include "rpc/msgpack/versioning.hpp" +#include <stdexcept> + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +struct container_size_overflow : public std::runtime_error { + explicit container_size_overflow(const std::string& msg) + :std::runtime_error(msg) {} +#if !defined(MSGPACK_USE_CPP03) + explicit container_size_overflow(const char* msg): + std::runtime_error(msg) {} +#endif // !defined(MSGPACK_USE_CPP03) +}; + +namespace detail { + +template <std::size_t N> +inline void check_container_size(std::size_t size) { + if (size > 0xffffffff) throw container_size_overflow("container size overflow"); +} + +template <> +inline void check_container_size<4>(std::size_t /*size*/) { +} + +template <std::size_t N> +inline void check_container_size_for_ext(std::size_t size) { + if (size > 0xffffffff) throw container_size_overflow("container size overflow"); +} + +template <> +inline void check_container_size_for_ext<4>(std::size_t size) { + if (size > 0xfffffffe) throw container_size_overflow("container size overflow"); +} + +} // namespace detail + +template <typename T> +inline uint32_t checked_get_container_size(T size) { + detail::check_container_size<sizeof(T)>(size); + return static_cast<uint32_t>(size); +} + + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif // MSGPACK_CHECK_CONTAINER_SIZE_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/cpp11/array.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/cpp11/array.hpp new file mode 100644 index 000000000..0a234a1be --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/cpp11/array.hpp @@ -0,0 +1,146 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2014-2015 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#ifndef MSGPACK_CPP11_ARRAY_HPP +#define MSGPACK_CPP11_ARRAY_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" +#include "rpc/msgpack/adaptor/check_container_size.hpp" +#include "rpc/msgpack/meta.hpp" + +#include <array> + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace adaptor { + +namespace detail { + +namespace array { + +template<typename T, std::size_t N1, std::size_t... I1, std::size_t N2, std::size_t... I2> +inline std::array<T, N1+N2> concat( + std::array<T, N1>&& a1, + std::array<T, N2>&& a2, + clmdep_msgpack::seq<I1...>, + clmdep_msgpack::seq<I2...>) { + return {{ std::move(a1[I1])..., std::move(a2[I2])... }}; +} + +template<typename T, std::size_t N1, std::size_t N2> +inline std::array<T, N1+N2> concat(std::array<T, N1>&& a1, std::array<T, N2>&& a2) { + return concat(std::move(a1), std::move(a2), clmdep_msgpack::gen_seq<N1>(), clmdep_msgpack::gen_seq<N2>()); +} + +template <typename T, std::size_t N> +struct as_impl { + static std::array<T, N> as(clmdep_msgpack::object const& o) { + clmdep_msgpack::object* p = o.via.array.ptr + N - 1; + return concat(as_impl<T, N-1>::as(o), std::array<T, 1>{{p->as<T>()}}); + } +}; + +template <typename T> +struct as_impl<T, 1> { + static std::array<T, 1> as(clmdep_msgpack::object const& o) { + clmdep_msgpack::object* p = o.via.array.ptr; + return std::array<T, 1>{{p->as<T>()}}; + } +}; + +template <typename T> +struct as_impl<T, 0> { + static std::array<T, 0> as(clmdep_msgpack::object const&) { + return std::array<T, 0>(); + } +}; + +} // namespace array + +} // namespace detail + +template <typename T, std::size_t N> +struct as<std::array<T, N>, typename std::enable_if<clmdep_msgpack::has_as<T>::value>::type> { + std::array<T, N> operator()(clmdep_msgpack::object const& o) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size != N) { throw clmdep_msgpack::type_error(); } + return detail::array::as_impl<T, N>::as(o); + } +}; + +template <typename T, std::size_t N> +struct convert<std::array<T, N>> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, std::array<T, N>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size != N) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size > 0) { + clmdep_msgpack::object* p = o.via.array.ptr; + clmdep_msgpack::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 o; + } +}; + +template <typename T, std::size_t N> +struct pack<std::array<T, N>> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const std::array<T, N>& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.pack_array(size); + for(auto const& e : v) o.pack(e); + return o; + } +}; + +template <typename T, std::size_t N> +struct object_with_zone<std::array<T, N>> { + void operator()(clmdep_msgpack::object::with_zone& o, const std::array<T, N>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + if(v.empty()) { + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } else { + uint32_t size = checked_get_container_size(v.size()); + clmdep_msgpack::object* p = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*size)); + o.via.array.size = size; + o.via.array.ptr = p; + for (auto const& e : v) *p++ = clmdep_msgpack::object(e, o.zone); + } + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif // MSGPACK_CPP11_ARRAY_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/cpp11/array_char.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/cpp11/array_char.hpp new file mode 100644 index 000000000..e2a5dcf41 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/cpp11/array_char.hpp @@ -0,0 +1,97 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2014-2015 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_ARRAY_CHAR_HPP +#define MSGPACK_TYPE_ARRAY_CHAR_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" +#include "rpc/msgpack/adaptor/check_container_size.hpp" + +#include <array> + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace adaptor { + +template <std::size_t N> +struct convert<std::array<char, N>> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, std::array<char, N>& v) const { + switch (o.type) { + case clmdep_msgpack::type::BIN: + if(o.via.bin.size != N) { throw clmdep_msgpack::type_error(); } + std::memcpy(v.data(), o.via.bin.ptr, o.via.bin.size); + break; + case clmdep_msgpack::type::STR: + if(o.via.str.size != N) { throw clmdep_msgpack::type_error(); } + std::memcpy(v.data(), o.via.str.ptr, N); + break; + default: + throw clmdep_msgpack::type_error(); + break; + } + return o; + } +}; + +template <std::size_t N> +struct pack<std::array<char, N>> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const std::array<char, N>& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.pack_bin(size); + o.pack_bin_body(v.data(), size); + + return o; + } +}; + +template <std::size_t N> +struct object<std::array<char, N>> { + void operator()(clmdep_msgpack::object& o, const std::array<char, N>& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.type = clmdep_msgpack::type::BIN; + o.via.bin.ptr = v.data(); + o.via.bin.size = size; + } +}; + +template <std::size_t N> +struct object_with_zone<std::array<char, N>> { + void operator()(clmdep_msgpack::object::with_zone& o, const std::array<char, N>& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.type = clmdep_msgpack::type::BIN; + char* ptr = static_cast<char*>(o.zone.allocate_align(size)); + o.via.bin.ptr = ptr; + o.via.bin.size = size; + std::memcpy(ptr, v.data(), size); + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif // MSGPACK_TYPE_ARRAY_CHAR_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/cpp11/array_unsigned_char.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/cpp11/array_unsigned_char.hpp new file mode 100644 index 000000000..35b1df63e --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/cpp11/array_unsigned_char.hpp @@ -0,0 +1,97 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2014-2015 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_ARRAY_UNSIGNED_CHAR_HPP +#define MSGPACK_TYPE_ARRAY_UNSIGNED_CHAR_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" +#include "rpc/msgpack/adaptor/check_container_size.hpp" + +#include <array> + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace adaptor { + +template <std::size_t N> +struct convert<std::array<unsigned char, N>> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, std::array<unsigned char, N>& v) const { + switch (o.type) { + case clmdep_msgpack::type::BIN: + if(o.via.bin.size != N) { throw clmdep_msgpack::type_error(); } + std::memcpy(v.data(), o.via.bin.ptr, o.via.bin.size); + break; + case clmdep_msgpack::type::STR: + if(o.via.str.size != N) { throw clmdep_msgpack::type_error(); } + std::memcpy(v.data(), o.via.str.ptr, N); + break; + default: + throw clmdep_msgpack::type_error(); + break; + } + return o; + } +}; + +template <std::size_t N> +struct pack<std::array<unsigned char, N>> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const std::array<unsigned char, N>& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.pack_bin(size); + o.pack_bin_body(reinterpret_cast<char const*>(v.data()), size); + + return o; + } +}; + +template <std::size_t N> +struct object<std::array<unsigned char, N>> { + void operator()(clmdep_msgpack::object& o, const std::array<unsigned char, N>& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.type = clmdep_msgpack::type::BIN; + o.via.bin.ptr = reinterpret_cast<char const*>(v.data()); + o.via.bin.size = size; + } +}; + +template <std::size_t N> +struct object_with_zone<std::array<unsigned char, N>> { + void operator()(clmdep_msgpack::object::with_zone& o, const std::array<unsigned char, N>& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.type = clmdep_msgpack::type::BIN; + char* ptr = static_cast<char*>(o.zone.allocate_align(size)); + o.via.bin.ptr = ptr; + o.via.bin.size = size; + std::memcpy(ptr, v.data(), size); + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif // MSGPACK_TYPE_ARRAY_UNSIGNED_CHAR_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/cpp11/forward_list.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/cpp11/forward_list.hpp new file mode 100644 index 000000000..b12007609 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/cpp11/forward_list.hpp @@ -0,0 +1,102 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2014 KONDO-2015 Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#ifndef MSGPACK_CPP11_FORWARD_LIST_HPP +#define MSGPACK_CPP11_FORWARD_LIST_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" +#include "rpc/msgpack/adaptor/check_container_size.hpp" + +#include <forward_list> + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace adaptor { + +template <typename T, typename Alloc> + struct as<std::forward_list<T, Alloc>, typename std::enable_if<clmdep_msgpack::has_as<T>::value>::type> { + std::forward_list<T, Alloc> operator()(clmdep_msgpack::object const& o) const { + if (o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + std::forward_list<T, Alloc> v; + clmdep_msgpack::object* p = o.via.array.ptr + o.via.array.size; + clmdep_msgpack::object* const pend = o.via.array.ptr; + while (p != pend) { + --p; + v.push_front(p->as<T>()); + } + return v; + } +}; + +template <typename T, typename Alloc> +struct convert<std::forward_list<T, Alloc>> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, std::forward_list<T, Alloc>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + v.resize(o.via.array.size); + clmdep_msgpack::object* p = o.via.array.ptr; + for (auto &e : v) { + p->convert(e); + ++p; + } + return o; + } +}; + +template <typename T, typename Alloc> +struct pack<std::forward_list<T, Alloc>> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const std::forward_list<T, Alloc>& v) const { + uint32_t size = checked_get_container_size(std::distance(v.begin(), v.end())); + o.pack_array(size); + for(auto const& e : v) o.pack(e); + return o; + } +}; + +template <typename T, typename Alloc> +struct object_with_zone<std::forward_list<T, Alloc>> { + void operator()(clmdep_msgpack::object::with_zone& o, const std::forward_list<T, Alloc>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + if(v.empty()) { + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } else { + uint32_t size = checked_get_container_size(std::distance(v.begin(), v.end())); + o.via.array.size = size; + clmdep_msgpack::object* p = static_cast<clmdep_msgpack::object*>( + o.zone.allocate_align(sizeof(clmdep_msgpack::object)*size)); + o.via.array.ptr = p; + for(auto const& e : v) *p++ = clmdep_msgpack::object(e, o.zone); + } + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif // MSGPACK_CPP11_FORWARD_LIST_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/cpp11/shared_ptr.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/cpp11/shared_ptr.hpp new file mode 100644 index 000000000..9054c7810 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/cpp11/shared_ptr.hpp @@ -0,0 +1,90 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2015 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#ifndef MSGPACK_CPP11_SHARED_PTR_HPP +#define MSGPACK_CPP11_SHARED_PTR_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" +#include "rpc/msgpack/adaptor/check_container_size.hpp" + +#include <memory> + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace adaptor { + +template <typename T> +struct as<std::shared_ptr<T>, typename std::enable_if<clmdep_msgpack::has_as<T>::value>::type> { + std::shared_ptr<T> operator()(clmdep_msgpack::object const& o) const { + if(o.is_nil()) return nullptr; + return std::make_shared<T>(o.as<T>()); + } +}; + +template <typename T> +struct convert<std::shared_ptr<T>> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, std::shared_ptr<T>& v) const { + if(o.is_nil()) v.reset(); + else { + v = std::make_shared<T>(); + clmdep_msgpack::adaptor::convert<T>()(o, *v); + } + return o; + } +}; + +template <typename T> +struct pack<std::shared_ptr<T>> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const std::shared_ptr<T>& v) const { + if (v) o.pack(*v); + else o.pack_nil(); + return o; + } +}; + +template <typename T> +struct object<std::shared_ptr<T> > { + void operator()(clmdep_msgpack::object& o, const std::shared_ptr<T>& v) const { + if (v) clmdep_msgpack::adaptor::object<T>()(o, *v); + else o.type = clmdep_msgpack::type::NIL; + } +}; + +template <typename T> +struct object_with_zone<std::shared_ptr<T>> { + void operator()(clmdep_msgpack::object::with_zone& o, const std::shared_ptr<T>& v) const { + if (v) clmdep_msgpack::adaptor::object_with_zone<T>()(o, *v); + else o.type = clmdep_msgpack::type::NIL; + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif // MSGPACK_CPP11_SHARED_PTR_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/cpp11/tuple.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/cpp11/tuple.hpp new file mode 100644 index 000000000..35be7b12d --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/cpp11/tuple.hpp @@ -0,0 +1,184 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_CPP11_TUPLE_HPP +#define MSGPACK_CPP11_TUPLE_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" +#include "rpc/msgpack/adaptor/check_container_size.hpp" +#include "rpc/msgpack/meta.hpp" + +#include <tuple> + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +// --- Pack from tuple to packer stream --- +template <typename Stream, typename Tuple, std::size_t N> +struct StdTuplePacker { + static void pack( + clmdep_msgpack::packer<Stream>& o, + const Tuple& v) { + StdTuplePacker<Stream, Tuple, N-1>::pack(o, v); + o.pack(std::get<N-1>(v)); + } +}; + +template <typename Stream, typename Tuple> +struct StdTuplePacker<Stream, Tuple, 0> { + static void pack ( + clmdep_msgpack::packer<Stream>&, + const Tuple&) { + } +}; + +namespace adaptor { + +template <typename... Args> +struct pack<std::tuple<Args...>> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const std::tuple<Args...>& v) const { + uint32_t size = checked_get_container_size(sizeof...(Args)); + o.pack_array(size); + StdTuplePacker<Stream, decltype(v), sizeof...(Args)>::pack(o, v); + return o; + } +}; + +} // namespace adaptor + +// --- Convert from tuple to object --- + +template <typename... Args> +struct StdTupleAs; + +template <typename T, typename... Args> +struct StdTupleAsImpl { + static std::tuple<T, Args...> as(clmdep_msgpack::object const& o) { + return std::tuple_cat( + std::make_tuple(o.via.array.ptr[o.via.array.size - sizeof...(Args) - 1].as<T>()), + StdTupleAs<Args...>::as(o)); + } +}; + +template <typename... Args> +struct StdTupleAs { + static std::tuple<Args...> as(clmdep_msgpack::object const& o) { + return StdTupleAsImpl<Args...>::as(o); + } +}; + +template <> +struct StdTupleAs<> { + static std::tuple<> as (clmdep_msgpack::object const&) { + return std::tuple<>(); + } +}; + +template <typename Tuple, std::size_t N> +struct StdTupleConverter { + static void convert( + clmdep_msgpack::object const& o, + Tuple& v) { + StdTupleConverter<Tuple, N-1>::convert(o, v); + o.via.array.ptr[N-1].convert<typename std::remove_reference<decltype(std::get<N-1>(v))>::type>(std::get<N-1>(v)); + } +}; + +template <typename Tuple> +struct StdTupleConverter<Tuple, 0> { + static void convert ( + clmdep_msgpack::object const&, + Tuple&) { + } +}; + +namespace adaptor { + +template <typename... Args> +struct as<std::tuple<Args...>, typename std::enable_if<clmdep_msgpack::all_of<clmdep_msgpack::has_as, Args...>::value>::type> { + std::tuple<Args...> operator()( + clmdep_msgpack::object const& o) const { + if (o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if (o.via.array.size < sizeof...(Args)) { throw clmdep_msgpack::type_error(); } + return StdTupleAs<Args...>::as(o); + } +}; + +template <typename... Args> +struct convert<std::tuple<Args...>> { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + std::tuple<Args...>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < sizeof...(Args)) { throw clmdep_msgpack::type_error(); } + StdTupleConverter<decltype(v), sizeof...(Args)>::convert(o, v); + return o; + } +}; + +} // namespace adaptor + +// --- Convert from tuple to object with zone --- +template <typename Tuple, std::size_t N> +struct StdTupleToObjectWithZone { + static void convert( + clmdep_msgpack::object::with_zone& o, + const Tuple& v) { + StdTupleToObjectWithZone<Tuple, N-1>::convert(o, v); + o.via.array.ptr[N-1] = clmdep_msgpack::object(std::get<N-1>(v), o.zone); + } +}; + +template <typename Tuple> +struct StdTupleToObjectWithZone<Tuple, 0> { + static void convert ( + clmdep_msgpack::object::with_zone&, + const Tuple&) { + } +}; + +namespace adaptor { + +template <typename... Args> +struct object_with_zone<std::tuple<Args...>> { + void operator()( + clmdep_msgpack::object::with_zone& o, + std::tuple<Args...> const& v) const { + uint32_t size = checked_get_container_size(sizeof...(Args)); + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*size)); + o.via.array.size = size; + StdTupleToObjectWithZone<decltype(v), sizeof...(Args)>::convert(o, v); + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif // MSGPACK_CPP11_TUPLE_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/cpp11/unique_ptr.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/cpp11/unique_ptr.hpp new file mode 100644 index 000000000..49792b069 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/cpp11/unique_ptr.hpp @@ -0,0 +1,90 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2015 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#ifndef MSGPACK_CPP11_UNIQUE_PTR_HPP +#define MSGPACK_CPP11_UNIQUE_PTR_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" +#include "rpc/msgpack/adaptor/check_container_size.hpp" + +#include <memory> + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace adaptor { + +template <typename T> +struct as<std::unique_ptr<T>, typename std::enable_if<clmdep_msgpack::has_as<T>::value>::type> { + std::unique_ptr<T> operator()(clmdep_msgpack::object const& o) const { + if(o.is_nil()) return nullptr; + return std::unique_ptr<T>(new T(o.as<T>())); + } +}; + +template <typename T> +struct convert<std::unique_ptr<T>> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, std::unique_ptr<T>& v) const { + if(o.is_nil()) v.reset(); + else { + v.reset(new T); + clmdep_msgpack::adaptor::convert<T>()(o, *v); + } + return o; + } +}; + +template <typename T> +struct pack<std::unique_ptr<T>> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const std::unique_ptr<T>& v) const { + if (v) o.pack(*v); + else o.pack_nil(); + return o; + } +}; + +template <typename T> +struct object<std::unique_ptr<T> > { + void operator()(clmdep_msgpack::object& o, const std::unique_ptr<T>& v) const { + if (v) clmdep_msgpack::adaptor::object<T>()(o, *v); + else o.type = clmdep_msgpack::type::NIL; + } +}; + +template <typename T> +struct object_with_zone<std::unique_ptr<T>> { + void operator()(clmdep_msgpack::object::with_zone& o, const std::unique_ptr<T>& v) const { + if (v) clmdep_msgpack::adaptor::object_with_zone<T>()(o, *v); + else o.type = clmdep_msgpack::type::NIL; + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif // MSGPACK_CPP11_UNIQUE_PTR_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/cpp11/unordered_map.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/cpp11/unordered_map.hpp new file mode 100644 index 000000000..428c987de --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/cpp11/unordered_map.hpp @@ -0,0 +1,190 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2014-2015 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_UNORDERED_MAP_HPP +#define MSGPACK_TYPE_UNORDERED_MAP_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" +#include "rpc/msgpack/adaptor/check_container_size.hpp" + +#include <unordered_map> + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace adaptor { + +template <typename K, typename V, typename Hash, typename Compare, typename Alloc> +struct as< + std::unordered_map<K, V, Hash, Compare, Alloc>, + typename std::enable_if<clmdep_msgpack::has_as<K>::value && clmdep_msgpack::has_as<V>::value>::type> { + std::unordered_map<K, V, Hash, Compare, Alloc> operator()(clmdep_msgpack::object const& o) const { + if (o.type != clmdep_msgpack::type::MAP) { throw clmdep_msgpack::type_error(); } + clmdep_msgpack::object_kv* p(o.via.map.ptr); + clmdep_msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size); + std::unordered_map<K, V, Hash, Compare, Alloc> v; + for (; p != pend; ++p) { + v.emplace(p->key.as<K>(), p->val.as<V>()); + } + return v; + } +}; + +template <typename K, typename V, typename Hash, typename Compare, typename Alloc> +struct convert<std::unordered_map<K, V, Hash, Compare, Alloc>> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, std::unordered_map<K, V, Hash, Compare, Alloc>& v) const { + if(o.type != clmdep_msgpack::type::MAP) { throw clmdep_msgpack::type_error(); } + clmdep_msgpack::object_kv* p(o.via.map.ptr); + clmdep_msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size); + std::unordered_map<K, V, Hash, Compare, Alloc> tmp; + for(; p != pend; ++p) { + K key; + p->key.convert(key); + p->val.convert(tmp[std::move(key)]); + } + v = std::move(tmp); + return o; + } +}; + +template <typename K, typename V, typename Hash, typename Compare, typename Alloc> +struct pack<std::unordered_map<K, V, Hash, Compare, Alloc>> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const std::unordered_map<K, V, Hash, Compare, Alloc>& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.pack_map(size); + for(typename std::unordered_map<K, V, Hash, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(it->first); + o.pack(it->second); + } + return o; + } +}; + +template <typename K, typename V, typename Hash, typename Compare, typename Alloc> +struct object_with_zone<std::unordered_map<K, V, Hash, Compare, Alloc>> { + void operator()(clmdep_msgpack::object::with_zone& o, const std::unordered_map<K, V, Hash, Compare, Alloc>& v) const { + o.type = clmdep_msgpack::type::MAP; + if(v.empty()) { + o.via.map.ptr = nullptr; + o.via.map.size = 0; + } else { + uint32_t size = checked_get_container_size(v.size()); + clmdep_msgpack::object_kv* p = static_cast<clmdep_msgpack::object_kv*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object_kv)*size)); + clmdep_msgpack::object_kv* const pend = p + size; + o.via.map.ptr = p; + o.via.map.size = size; + typename std::unordered_map<K, V, Hash, Compare, Alloc>::const_iterator it(v.begin()); + do { + p->key = clmdep_msgpack::object(it->first, o.zone); + p->val = clmdep_msgpack::object(it->second, o.zone); + ++p; + ++it; + } while(p < pend); + } + } +}; + + +template <typename K, typename V, typename Hash, typename Compare, typename Alloc> +struct as< + std::unordered_multimap<K, V, Hash, Compare, Alloc>, + typename std::enable_if<clmdep_msgpack::has_as<K>::value && clmdep_msgpack::has_as<V>::value>::type> { + std::unordered_multimap<K, V, Hash, Compare, Alloc> operator()(clmdep_msgpack::object const& o) const { + if (o.type != clmdep_msgpack::type::MAP) { throw clmdep_msgpack::type_error(); } + clmdep_msgpack::object_kv* p(o.via.map.ptr); + clmdep_msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size); + std::unordered_multimap<K, V, Hash, Compare, Alloc> v; + for (; p != pend; ++p) { + v.emplace(p->key.as<K>(), p->val.as<V>()); + } + return v; + } +}; + +template <typename K, typename V, typename Hash, typename Compare, typename Alloc> +struct convert<std::unordered_multimap<K, V, Hash, Compare, Alloc>> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, std::unordered_multimap<K, V, Hash, Compare, Alloc>& v) const { + if(o.type != clmdep_msgpack::type::MAP) { throw clmdep_msgpack::type_error(); } + clmdep_msgpack::object_kv* p(o.via.map.ptr); + clmdep_msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size); + std::unordered_multimap<K, V, Hash, Compare, Alloc> tmp; + for(; p != pend; ++p) { + std::pair<K, V> value; + p->key.convert(value.first); + p->val.convert(value.second); + tmp.insert(std::move(value)); + } + v = std::move(tmp); + return o; + } +}; + +template <typename K, typename V, typename Hash, typename Compare, typename Alloc> +struct pack<std::unordered_multimap<K, V, Hash, Compare, Alloc>> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const std::unordered_multimap<K, V, Hash, Compare, Alloc>& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.pack_map(size); + for(typename std::unordered_multimap<K, V, Hash, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(it->first); + o.pack(it->second); + } + return o; + } +}; + +template <typename K, typename V, typename Hash, typename Compare, typename Alloc> +struct object_with_zone<std::unordered_multimap<K, V, Hash, Compare, Alloc>> { + void operator()(clmdep_msgpack::object::with_zone& o, const std::unordered_multimap<K, V, Hash, Compare, Alloc>& v) const { + o.type = clmdep_msgpack::type::MAP; + if(v.empty()) { + o.via.map.ptr = nullptr; + o.via.map.size = 0; + } else { + uint32_t size = checked_get_container_size(v.size()); + clmdep_msgpack::object_kv* p = static_cast<clmdep_msgpack::object_kv*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object_kv)*size)); + clmdep_msgpack::object_kv* const pend = p + size; + o.via.map.ptr = p; + o.via.map.size = size; + typename std::unordered_multimap<K, V, Hash, Compare, Alloc>::const_iterator it(v.begin()); + do { + p->key = clmdep_msgpack::object(it->first, o.zone); + p->val = clmdep_msgpack::object(it->second, o.zone); + ++p; + ++it; + } while(p < pend); + } + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + + +#endif // MSGPACK_TYPE_UNORDERED_MAP_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/cpp11/unordered_set.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/cpp11/unordered_set.hpp new file mode 100644 index 000000000..2e5eeef11 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/cpp11/unordered_set.hpp @@ -0,0 +1,180 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2014-2015 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_UNORDERED_SET_HPP +#define MSGPACK_TYPE_UNORDERED_SET_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" +#include "rpc/msgpack/adaptor/check_container_size.hpp" + +#include <unordered_set> + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace adaptor { + +template <typename Key, typename Hash, typename Compare, typename Alloc> +struct as<std::unordered_set<Key, Hash, Compare, Alloc>, typename std::enable_if<clmdep_msgpack::has_as<Key>::value>::type> { + std::unordered_set<Key, Hash, Compare, Alloc> operator()(clmdep_msgpack::object const& o) const { + if (o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + clmdep_msgpack::object* p = o.via.array.ptr + o.via.array.size; + clmdep_msgpack::object* const pbegin = o.via.array.ptr; + std::unordered_set<Key, Hash, Compare, Alloc> v; + while (p > pbegin) { + --p; + v.insert(p->as<Key>()); + } + return v; + } +}; + +template <typename Key, typename Hash, typename Compare, typename Alloc> +struct convert<std::unordered_set<Key, Hash, Compare, Alloc>> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, std::unordered_set<Key, Hash, Compare, Alloc>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + clmdep_msgpack::object* p = o.via.array.ptr + o.via.array.size; + clmdep_msgpack::object* const pbegin = o.via.array.ptr; + std::unordered_set<Key, Hash, Compare, Alloc> tmp; + while(p > pbegin) { + --p; + tmp.insert(p->as<Key>()); + } + v = std::move(tmp); + return o; + } +}; + +template <typename Key, typename Hash, typename Compare, typename Alloc> +struct pack<std::unordered_set<Key, Hash, Compare, Alloc>> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const std::unordered_set<Key, Hash, Compare, Alloc>& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.pack_array(size); + for(typename std::unordered_set<Key, Hash, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(*it); + } + return o; + } +}; + +template <typename Key, typename Hash, typename Compare, typename Alloc> +struct object_with_zone<std::unordered_set<Key, Hash, Compare, Alloc>> { + void operator()(clmdep_msgpack::object::with_zone& o, const std::unordered_set<Key, Hash, Compare, Alloc>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + if(v.empty()) { + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } else { + uint32_t size = checked_get_container_size(v.size()); + clmdep_msgpack::object* p = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*size)); + clmdep_msgpack::object* const pend = p + size; + o.via.array.ptr = p; + o.via.array.size = size; + typename std::unordered_set<Key, Hash, Compare, Alloc>::const_iterator it(v.begin()); + do { + *p = clmdep_msgpack::object(*it, o.zone); + ++p; + ++it; + } while(p < pend); + } + } +}; + + +template <typename Key, typename Hash, typename Compare, typename Alloc> +struct as<std::unordered_multiset<Key, Hash, Compare, Alloc>, typename std::enable_if<clmdep_msgpack::has_as<Key>::value>::type> { + std::unordered_multiset<Key, Hash, Compare, Alloc> operator()(clmdep_msgpack::object const& o) const { + if (o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + clmdep_msgpack::object* p = o.via.array.ptr + o.via.array.size; + clmdep_msgpack::object* const pbegin = o.via.array.ptr; + std::unordered_multiset<Key, Hash, Compare, Alloc> v; + while (p > pbegin) { + --p; + v.insert(p->as<Key>()); + } + return v; + } +}; + +template <typename Key, typename Hash, typename Compare, typename Alloc> +struct convert<std::unordered_multiset<Key, Hash, Compare, Alloc>> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, std::unordered_multiset<Key, Hash, Compare, Alloc>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + clmdep_msgpack::object* p = o.via.array.ptr + o.via.array.size; + clmdep_msgpack::object* const pbegin = o.via.array.ptr; + std::unordered_multiset<Key, Hash, Compare, Alloc> tmp; + while(p > pbegin) { + --p; + tmp.insert(p->as<Key>()); + } + v = std::move(tmp); + return o; + } +}; + +template <typename Key, typename Hash, typename Compare, typename Alloc> +struct pack<std::unordered_multiset<Key, Hash, Compare, Alloc>> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const std::unordered_multiset<Key, Hash, Compare, Alloc>& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.pack_array(size); + for(typename std::unordered_multiset<Key, Hash, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(*it); + } + return o; + } +}; + +template <typename Key, typename Hash, typename Compare, typename Alloc> +struct object_with_zone<std::unordered_multiset<Key, Hash, Compare, Alloc>> { + void operator()(clmdep_msgpack::object::with_zone& o, const std::unordered_multiset<Key, Hash, Compare, Alloc>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + if(v.empty()) { + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } else { + uint32_t size = checked_get_container_size(v.size()); + clmdep_msgpack::object* p = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*size)); + clmdep_msgpack::object* const pend = p + size; + o.via.array.ptr = p; + o.via.array.size = size; + typename std::unordered_multiset<Key, Hash, Compare, Alloc>::const_iterator it(v.begin()); + do { + *p = clmdep_msgpack::object(*it, o.zone); + ++p; + ++it; + } while(p < pend); + } + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif // MSGPACK_TYPE_UNORDERED_SET_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/define.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/define.hpp new file mode 100644 index 000000000..dce5f53c9 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/define.hpp @@ -0,0 +1,39 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_DEFINE_HPP +#define MSGPACK_DEFINE_HPP + +#include "rpc/msgpack/cpp_config.hpp" + +#if defined(MSGPACK_USE_CPP03) +#include "detail/cpp03_define_array.hpp" +#include "detail/cpp03_define_map.hpp" +#else // MSGPACK_USE_CPP03 +#include "detail/cpp11_define_array.hpp" +#include "detail/cpp11_define_map.hpp" +#endif // MSGPACK_USE_CPP03 + +#if defined(MSGPACK_USE_DEFINE_MAP) +#define MSGPACK_DEFINE MSGPACK_DEFINE_MAP +#define MSGPACK_BASE MSGPACK_BASE_MAP +#else // defined(MSGPACK_USE_DEFINE_MAP) +#define MSGPACK_DEFINE MSGPACK_DEFINE_ARRAY +#define MSGPACK_BASE MSGPACK_BASE_ARRAY +#endif // defined(MSGPACK_USE_DEFINE_MAP) + +#endif // MSGPACK_DEFINE_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/deque.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/deque.hpp new file mode 100644 index 000000000..e2e5b8530 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/deque.hpp @@ -0,0 +1,116 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2015 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_DEQUE_HPP +#define MSGPACK_TYPE_DEQUE_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" +#include "rpc/msgpack/adaptor/check_container_size.hpp" + +#include <deque> + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace adaptor { + +#if !defined(MSGPACK_USE_CPP03) + +template <typename T, typename Alloc> +struct as<std::deque<T, Alloc>, typename std::enable_if<clmdep_msgpack::has_as<T>::value>::type> { + std::deque<T, Alloc> operator()(const clmdep_msgpack::object& o) const { + if (o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + std::deque<T, Alloc> v; + if (o.via.array.size > 0) { + clmdep_msgpack::object* p = o.via.array.ptr; + clmdep_msgpack::object* const pend = o.via.array.ptr + o.via.array.size; + do { + v.push_back(p->as<T>()); + ++p; + } while (p < pend); + } + return v; + } +}; + +#endif // !defined(MSGPACK_USE_CPP03) + +template <typename T, typename Alloc> +struct convert<std::deque<T, Alloc> > { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, std::deque<T, Alloc>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + v.resize(o.via.array.size); + clmdep_msgpack::object* p = o.via.array.ptr; + clmdep_msgpack::object* const pend = o.via.array.ptr + o.via.array.size; + typename std::deque<T, Alloc>::iterator it = v.begin(); + for(; p < pend; ++p, ++it) { + p->convert(*it); + } + return o; + } +}; + +template <typename T, typename Alloc> +struct pack<std::deque<T, Alloc> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const std::deque<T, Alloc>& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.pack_array(size); + for(typename std::deque<T, Alloc>::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(*it); + } + return o; + } +}; + +template <typename T, typename Alloc> +struct object_with_zone<std::deque<T, Alloc> > { + void operator()(clmdep_msgpack::object::with_zone& o, const std::deque<T, Alloc>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + if(v.empty()) { + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } else { + uint32_t size = checked_get_container_size(v.size()); + clmdep_msgpack::object* p = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*size)); + clmdep_msgpack::object* const pend = p + size; + o.via.array.ptr = p; + o.via.array.size = size; + typename std::deque<T, Alloc>::const_iterator it(v.begin()); + do { + *p = clmdep_msgpack::object(*it, o.zone); + ++p; + ++it; + } while(p < pend); + } + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif /* msgpack/type/deque.hpp */ diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/detail/cpp03_define_array.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/detail/cpp03_define_array.hpp new file mode 100644 index 000000000..b93dc7062 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/detail/cpp03_define_array.hpp @@ -0,0 +1,3498 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2009 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_CPP03_DEFINE_ARRAY_HPP +#define MSGPACK_CPP03_DEFINE_ARRAY_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/msgpack_tuple.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" +#include "rpc/msgpack/object_fwd.hpp" + +#define MSGPACK_DEFINE_ARRAY(...) \ + template <typename Packer> \ + void msgpack_pack(Packer& pk) const \ + { \ + clmdep_msgpack::type::make_define_array(__VA_ARGS__).msgpack_pack(pk); \ + } \ + void msgpack_unpack(clmdep_msgpack::object const& o) \ + { \ + clmdep_msgpack::type::make_define_array(__VA_ARGS__).msgpack_unpack(o); \ + }\ + template <typename MSGPACK_OBJECT> \ + void msgpack_object(MSGPACK_OBJECT* o, clmdep_msgpack::zone& z) const \ + { \ + clmdep_msgpack::type::make_define_array(__VA_ARGS__).msgpack_object(o, z); \ + } + +#define MSGPACK_BASE_ARRAY(base) (*const_cast<base *>(static_cast<base const*>(this))) + +// MSGPACK_ADD_ENUM must be used in the global namespace. +#define MSGPACK_ADD_ENUM(enum_name) \ + namespace clmdep_msgpack { \ + /** @cond */ \ + MSGPACK_API_VERSION_NAMESPACE(v1) { \ + /** @endcond */ \ + namespace adaptor { \ + template<> \ + struct convert<enum_name> { \ + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, enum_name& v) const {\ + int tmp; \ + o >> tmp; \ + v = static_cast<enum_name>(tmp); \ + return o; \ + } \ + }; \ + template<> \ + struct object<enum_name> { \ + void operator()(clmdep_msgpack::object& o, const enum_name& v) const {\ + o << static_cast<int>(v); \ + } \ + }; \ + template<> \ + struct object_with_zone<enum_name> { \ + void operator()(clmdep_msgpack::object::with_zone& o, const enum_name& v) const { \ + o << static_cast<int>(v); \ + } \ + }; \ + template<> \ + struct pack<enum_name> { \ + template <typename Stream> \ + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const enum_name& v) const { \ + return o << static_cast<int>(v); \ + } \ + }; \ + } \ + /** @cond */ \ + } \ + /** @endcond */ \ + } + +namespace clmdep_msgpack { +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond +namespace type { + +/// @cond + +template <typename A0 = void, typename A1 = void, typename A2 = void, typename A3 = void, typename A4 = void, typename A5 = void, typename A6 = void, typename A7 = void, typename A8 = void, typename A9 = void, typename A10 = void, typename A11 = void, typename A12 = void, typename A13 = void, typename A14 = void, typename A15 = void, typename A16 = void, typename A17 = void, typename A18 = void, typename A19 = void, typename A20 = void, typename A21 = void, typename A22 = void, typename A23 = void, typename A24 = void, typename A25 = void, typename A26 = void, typename A27 = void, typename A28 = void, typename A29 = void, typename A30 = void, typename A31 = void, typename A32 = void> +struct define_array; +/// @endcond + +template <> +struct define_array<> { + typedef define_array<> value_type; + typedef tuple<> tuple_type; + template <typename Packer> + void msgpack_pack(Packer& pk) const + { + pk.pack_array(0); + } + void msgpack_unpack(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + } + void msgpack_object(clmdep_msgpack::object* o, clmdep_msgpack::zone&) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = nullptr; + o->via.array.size = 0; + } +}; + +/// @cond + +template <typename A0> +struct define_array<A0> { + typedef define_array<A0> value_type; + typedef tuple<A0> tuple_type; + define_array(A0& _a0) : + a0(_a0) {} + template <typename Packer> + void msgpack_pack(Packer& pk) const + { + pk.pack_array(1); + + pk.pack(a0); + } + void msgpack_unpack(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*1)); + o->via.array.size = 1; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + } + + A0& a0; +}; + +template <typename A0, typename A1> +struct define_array<A0, A1> { + typedef define_array<A0, A1> value_type; + typedef tuple<A0, A1> tuple_type; + define_array(A0& _a0, A1& _a1) : + a0(_a0), a1(_a1) {} + template <typename Packer> + void msgpack_pack(Packer& pk) const + { + pk.pack_array(2); + + pk.pack(a0); + pk.pack(a1); + } + void msgpack_unpack(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*2)); + o->via.array.size = 2; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + o->via.array.ptr[1] = clmdep_msgpack::object(a1, z); + } + + A0& a0; + A1& a1; +}; + +template <typename A0, typename A1, typename A2> +struct define_array<A0, A1, A2> { + typedef define_array<A0, A1, A2> value_type; + typedef tuple<A0, A1, A2> tuple_type; + define_array(A0& _a0, A1& _a1, A2& _a2) : + a0(_a0), a1(_a1), a2(_a2) {} + template <typename Packer> + void msgpack_pack(Packer& pk) const + { + pk.pack_array(3); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + } + void msgpack_unpack(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*3)); + o->via.array.size = 3; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + o->via.array.ptr[1] = clmdep_msgpack::object(a1, z); + o->via.array.ptr[2] = clmdep_msgpack::object(a2, z); + } + + A0& a0; + A1& a1; + A2& a2; +}; + +template <typename A0, typename A1, typename A2, typename A3> +struct define_array<A0, A1, A2, A3> { + typedef define_array<A0, A1, A2, A3> value_type; + typedef tuple<A0, A1, A2, A3> tuple_type; + define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3) {} + template <typename Packer> + 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(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*4)); + o->via.array.size = 4; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + o->via.array.ptr[1] = clmdep_msgpack::object(a1, z); + o->via.array.ptr[2] = clmdep_msgpack::object(a2, z); + o->via.array.ptr[3] = clmdep_msgpack::object(a3, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4> +struct define_array<A0, A1, A2, A3, A4> { + typedef define_array<A0, A1, A2, A3, A4> value_type; + typedef tuple<A0, A1, A2, A3, A4> tuple_type; + define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4) {} + template <typename Packer> + 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(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*5)); + o->via.array.size = 5; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + o->via.array.ptr[1] = clmdep_msgpack::object(a1, z); + o->via.array.ptr[2] = clmdep_msgpack::object(a2, z); + o->via.array.ptr[3] = clmdep_msgpack::object(a3, z); + o->via.array.ptr[4] = clmdep_msgpack::object(a4, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5> +struct define_array<A0, A1, A2, A3, A4, A5> { + typedef define_array<A0, A1, A2, A3, A4, A5> value_type; + typedef tuple<A0, A1, A2, A3, A4, A5> tuple_type; + define_array(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 <typename Packer> + 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(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*6)); + o->via.array.size = 6; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + o->via.array.ptr[1] = clmdep_msgpack::object(a1, z); + o->via.array.ptr[2] = clmdep_msgpack::object(a2, z); + o->via.array.ptr[3] = clmdep_msgpack::object(a3, z); + o->via.array.ptr[4] = clmdep_msgpack::object(a4, z); + o->via.array.ptr[5] = clmdep_msgpack::object(a5, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6> +struct define_array<A0, A1, A2, A3, A4, A5, A6> { + typedef define_array<A0, A1, A2, A3, A4, A5, A6> value_type; + typedef tuple<A0, A1, A2, A3, A4, A5, A6> tuple_type; + define_array(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 <typename Packer> + 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(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*7)); + o->via.array.size = 7; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + o->via.array.ptr[1] = clmdep_msgpack::object(a1, z); + o->via.array.ptr[2] = clmdep_msgpack::object(a2, z); + o->via.array.ptr[3] = clmdep_msgpack::object(a3, z); + o->via.array.ptr[4] = clmdep_msgpack::object(a4, z); + o->via.array.ptr[5] = clmdep_msgpack::object(a5, z); + o->via.array.ptr[6] = clmdep_msgpack::object(a6, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> +struct define_array<A0, A1, A2, A3, A4, A5, A6, A7> { + typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7> value_type; + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7> tuple_type; + define_array(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 <typename Packer> + 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(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*8)); + o->via.array.size = 8; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + o->via.array.ptr[1] = clmdep_msgpack::object(a1, z); + o->via.array.ptr[2] = clmdep_msgpack::object(a2, z); + o->via.array.ptr[3] = clmdep_msgpack::object(a3, z); + o->via.array.ptr[4] = clmdep_msgpack::object(a4, z); + o->via.array.ptr[5] = clmdep_msgpack::object(a5, z); + o->via.array.ptr[6] = clmdep_msgpack::object(a6, z); + o->via.array.ptr[7] = clmdep_msgpack::object(a7, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> +struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8> { + typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8> value_type; + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8> tuple_type; + define_array(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 <typename Packer> + 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(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*9)); + o->via.array.size = 9; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + o->via.array.ptr[1] = clmdep_msgpack::object(a1, z); + o->via.array.ptr[2] = clmdep_msgpack::object(a2, z); + o->via.array.ptr[3] = clmdep_msgpack::object(a3, z); + o->via.array.ptr[4] = clmdep_msgpack::object(a4, z); + o->via.array.ptr[5] = clmdep_msgpack::object(a5, z); + o->via.array.ptr[6] = clmdep_msgpack::object(a6, z); + o->via.array.ptr[7] = clmdep_msgpack::object(a7, z); + o->via.array.ptr[8] = clmdep_msgpack::object(a8, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> +struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> { + typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> value_type; + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> tuple_type; + define_array(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 <typename Packer> + 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(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*10)); + o->via.array.size = 10; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + o->via.array.ptr[1] = clmdep_msgpack::object(a1, z); + o->via.array.ptr[2] = clmdep_msgpack::object(a2, z); + o->via.array.ptr[3] = clmdep_msgpack::object(a3, z); + o->via.array.ptr[4] = clmdep_msgpack::object(a4, z); + o->via.array.ptr[5] = clmdep_msgpack::object(a5, z); + o->via.array.ptr[6] = clmdep_msgpack::object(a6, z); + o->via.array.ptr[7] = clmdep_msgpack::object(a7, z); + o->via.array.ptr[8] = clmdep_msgpack::object(a8, z); + o->via.array.ptr[9] = clmdep_msgpack::object(a9, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> { + typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> value_type; + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> tuple_type; + define_array(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 <typename Packer> + 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(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*11)); + o->via.array.size = 11; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + o->via.array.ptr[1] = clmdep_msgpack::object(a1, z); + o->via.array.ptr[2] = clmdep_msgpack::object(a2, z); + o->via.array.ptr[3] = clmdep_msgpack::object(a3, z); + o->via.array.ptr[4] = clmdep_msgpack::object(a4, z); + o->via.array.ptr[5] = clmdep_msgpack::object(a5, z); + o->via.array.ptr[6] = clmdep_msgpack::object(a6, z); + o->via.array.ptr[7] = clmdep_msgpack::object(a7, z); + o->via.array.ptr[8] = clmdep_msgpack::object(a8, z); + o->via.array.ptr[9] = clmdep_msgpack::object(a9, z); + o->via.array.ptr[10] = clmdep_msgpack::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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> { + typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> value_type; + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> tuple_type; + define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11) : + 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 <typename Packer> + 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(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*12)); + o->via.array.size = 12; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + o->via.array.ptr[1] = clmdep_msgpack::object(a1, z); + o->via.array.ptr[2] = clmdep_msgpack::object(a2, z); + o->via.array.ptr[3] = clmdep_msgpack::object(a3, z); + o->via.array.ptr[4] = clmdep_msgpack::object(a4, z); + o->via.array.ptr[5] = clmdep_msgpack::object(a5, z); + o->via.array.ptr[6] = clmdep_msgpack::object(a6, z); + o->via.array.ptr[7] = clmdep_msgpack::object(a7, z); + o->via.array.ptr[8] = clmdep_msgpack::object(a8, z); + o->via.array.ptr[9] = clmdep_msgpack::object(a9, z); + o->via.array.ptr[10] = clmdep_msgpack::object(a10, z); + o->via.array.ptr[11] = clmdep_msgpack::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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> { + typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> value_type; + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> tuple_type; + define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12) : + a0(_a0), 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 <typename Packer> + 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(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*13)); + o->via.array.size = 13; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + o->via.array.ptr[1] = clmdep_msgpack::object(a1, z); + o->via.array.ptr[2] = clmdep_msgpack::object(a2, z); + o->via.array.ptr[3] = clmdep_msgpack::object(a3, z); + o->via.array.ptr[4] = clmdep_msgpack::object(a4, z); + o->via.array.ptr[5] = clmdep_msgpack::object(a5, z); + o->via.array.ptr[6] = clmdep_msgpack::object(a6, z); + o->via.array.ptr[7] = clmdep_msgpack::object(a7, z); + o->via.array.ptr[8] = clmdep_msgpack::object(a8, z); + o->via.array.ptr[9] = clmdep_msgpack::object(a9, z); + o->via.array.ptr[10] = clmdep_msgpack::object(a10, z); + o->via.array.ptr[11] = clmdep_msgpack::object(a11, z); + o->via.array.ptr[12] = clmdep_msgpack::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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> { + typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> value_type; + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> tuple_type; + define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13) : + a0(_a0), a1(_a1), 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 <typename Packer> + 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(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*14)); + o->via.array.size = 14; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + o->via.array.ptr[1] = clmdep_msgpack::object(a1, z); + o->via.array.ptr[2] = clmdep_msgpack::object(a2, z); + o->via.array.ptr[3] = clmdep_msgpack::object(a3, z); + o->via.array.ptr[4] = clmdep_msgpack::object(a4, z); + o->via.array.ptr[5] = clmdep_msgpack::object(a5, z); + o->via.array.ptr[6] = clmdep_msgpack::object(a6, z); + o->via.array.ptr[7] = clmdep_msgpack::object(a7, z); + o->via.array.ptr[8] = clmdep_msgpack::object(a8, z); + o->via.array.ptr[9] = clmdep_msgpack::object(a9, z); + o->via.array.ptr[10] = clmdep_msgpack::object(a10, z); + o->via.array.ptr[11] = clmdep_msgpack::object(a11, z); + o->via.array.ptr[12] = clmdep_msgpack::object(a12, z); + o->via.array.ptr[13] = clmdep_msgpack::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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> { + typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> value_type; + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> tuple_type; + define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14) : + a0(_a0), a1(_a1), a2(_a2), 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 <typename Packer> + 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(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*15)); + o->via.array.size = 15; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + o->via.array.ptr[1] = clmdep_msgpack::object(a1, z); + o->via.array.ptr[2] = clmdep_msgpack::object(a2, z); + o->via.array.ptr[3] = clmdep_msgpack::object(a3, z); + o->via.array.ptr[4] = clmdep_msgpack::object(a4, z); + o->via.array.ptr[5] = clmdep_msgpack::object(a5, z); + o->via.array.ptr[6] = clmdep_msgpack::object(a6, z); + o->via.array.ptr[7] = clmdep_msgpack::object(a7, z); + o->via.array.ptr[8] = clmdep_msgpack::object(a8, z); + o->via.array.ptr[9] = clmdep_msgpack::object(a9, z); + o->via.array.ptr[10] = clmdep_msgpack::object(a10, z); + o->via.array.ptr[11] = clmdep_msgpack::object(a11, z); + o->via.array.ptr[12] = clmdep_msgpack::object(a12, z); + o->via.array.ptr[13] = clmdep_msgpack::object(a13, z); + o->via.array.ptr[14] = clmdep_msgpack::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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> { + typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> value_type; + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> tuple_type; + define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), 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 <typename Packer> + 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(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*16)); + o->via.array.size = 16; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + o->via.array.ptr[1] = clmdep_msgpack::object(a1, z); + o->via.array.ptr[2] = clmdep_msgpack::object(a2, z); + o->via.array.ptr[3] = clmdep_msgpack::object(a3, z); + o->via.array.ptr[4] = clmdep_msgpack::object(a4, z); + o->via.array.ptr[5] = clmdep_msgpack::object(a5, z); + o->via.array.ptr[6] = clmdep_msgpack::object(a6, z); + o->via.array.ptr[7] = clmdep_msgpack::object(a7, z); + o->via.array.ptr[8] = clmdep_msgpack::object(a8, z); + o->via.array.ptr[9] = clmdep_msgpack::object(a9, z); + o->via.array.ptr[10] = clmdep_msgpack::object(a10, z); + o->via.array.ptr[11] = clmdep_msgpack::object(a11, z); + o->via.array.ptr[12] = clmdep_msgpack::object(a12, z); + o->via.array.ptr[13] = clmdep_msgpack::object(a13, z); + o->via.array.ptr[14] = clmdep_msgpack::object(a14, z); + o->via.array.ptr[15] = clmdep_msgpack::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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> { + typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> value_type; + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> tuple_type; + define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), 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 <typename Packer> + 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(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*17)); + o->via.array.size = 17; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + o->via.array.ptr[1] = clmdep_msgpack::object(a1, z); + o->via.array.ptr[2] = clmdep_msgpack::object(a2, z); + o->via.array.ptr[3] = clmdep_msgpack::object(a3, z); + o->via.array.ptr[4] = clmdep_msgpack::object(a4, z); + o->via.array.ptr[5] = clmdep_msgpack::object(a5, z); + o->via.array.ptr[6] = clmdep_msgpack::object(a6, z); + o->via.array.ptr[7] = clmdep_msgpack::object(a7, z); + o->via.array.ptr[8] = clmdep_msgpack::object(a8, z); + o->via.array.ptr[9] = clmdep_msgpack::object(a9, z); + o->via.array.ptr[10] = clmdep_msgpack::object(a10, z); + o->via.array.ptr[11] = clmdep_msgpack::object(a11, z); + o->via.array.ptr[12] = clmdep_msgpack::object(a12, z); + o->via.array.ptr[13] = clmdep_msgpack::object(a13, z); + o->via.array.ptr[14] = clmdep_msgpack::object(a14, z); + o->via.array.ptr[15] = clmdep_msgpack::object(a15, z); + o->via.array.ptr[16] = clmdep_msgpack::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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> { + typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> value_type; + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> tuple_type; + define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), 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 <typename Packer> + 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(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*18)); + o->via.array.size = 18; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + o->via.array.ptr[1] = clmdep_msgpack::object(a1, z); + o->via.array.ptr[2] = clmdep_msgpack::object(a2, z); + o->via.array.ptr[3] = clmdep_msgpack::object(a3, z); + o->via.array.ptr[4] = clmdep_msgpack::object(a4, z); + o->via.array.ptr[5] = clmdep_msgpack::object(a5, z); + o->via.array.ptr[6] = clmdep_msgpack::object(a6, z); + o->via.array.ptr[7] = clmdep_msgpack::object(a7, z); + o->via.array.ptr[8] = clmdep_msgpack::object(a8, z); + o->via.array.ptr[9] = clmdep_msgpack::object(a9, z); + o->via.array.ptr[10] = clmdep_msgpack::object(a10, z); + o->via.array.ptr[11] = clmdep_msgpack::object(a11, z); + o->via.array.ptr[12] = clmdep_msgpack::object(a12, z); + o->via.array.ptr[13] = clmdep_msgpack::object(a13, z); + o->via.array.ptr[14] = clmdep_msgpack::object(a14, z); + o->via.array.ptr[15] = clmdep_msgpack::object(a15, z); + o->via.array.ptr[16] = clmdep_msgpack::object(a16, z); + o->via.array.ptr[17] = clmdep_msgpack::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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> { + typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> value_type; + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> tuple_type; + define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), 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 <typename Packer> + 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(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*19)); + o->via.array.size = 19; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + o->via.array.ptr[1] = clmdep_msgpack::object(a1, z); + o->via.array.ptr[2] = clmdep_msgpack::object(a2, z); + o->via.array.ptr[3] = clmdep_msgpack::object(a3, z); + o->via.array.ptr[4] = clmdep_msgpack::object(a4, z); + o->via.array.ptr[5] = clmdep_msgpack::object(a5, z); + o->via.array.ptr[6] = clmdep_msgpack::object(a6, z); + o->via.array.ptr[7] = clmdep_msgpack::object(a7, z); + o->via.array.ptr[8] = clmdep_msgpack::object(a8, z); + o->via.array.ptr[9] = clmdep_msgpack::object(a9, z); + o->via.array.ptr[10] = clmdep_msgpack::object(a10, z); + o->via.array.ptr[11] = clmdep_msgpack::object(a11, z); + o->via.array.ptr[12] = clmdep_msgpack::object(a12, z); + o->via.array.ptr[13] = clmdep_msgpack::object(a13, z); + o->via.array.ptr[14] = clmdep_msgpack::object(a14, z); + o->via.array.ptr[15] = clmdep_msgpack::object(a15, z); + o->via.array.ptr[16] = clmdep_msgpack::object(a16, z); + o->via.array.ptr[17] = clmdep_msgpack::object(a17, z); + o->via.array.ptr[18] = clmdep_msgpack::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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> { + typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> value_type; + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> tuple_type; + define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), 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 <typename Packer> + 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(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*20)); + o->via.array.size = 20; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + o->via.array.ptr[1] = clmdep_msgpack::object(a1, z); + o->via.array.ptr[2] = clmdep_msgpack::object(a2, z); + o->via.array.ptr[3] = clmdep_msgpack::object(a3, z); + o->via.array.ptr[4] = clmdep_msgpack::object(a4, z); + o->via.array.ptr[5] = clmdep_msgpack::object(a5, z); + o->via.array.ptr[6] = clmdep_msgpack::object(a6, z); + o->via.array.ptr[7] = clmdep_msgpack::object(a7, z); + o->via.array.ptr[8] = clmdep_msgpack::object(a8, z); + o->via.array.ptr[9] = clmdep_msgpack::object(a9, z); + o->via.array.ptr[10] = clmdep_msgpack::object(a10, z); + o->via.array.ptr[11] = clmdep_msgpack::object(a11, z); + o->via.array.ptr[12] = clmdep_msgpack::object(a12, z); + o->via.array.ptr[13] = clmdep_msgpack::object(a13, z); + o->via.array.ptr[14] = clmdep_msgpack::object(a14, z); + o->via.array.ptr[15] = clmdep_msgpack::object(a15, z); + o->via.array.ptr[16] = clmdep_msgpack::object(a16, z); + o->via.array.ptr[17] = clmdep_msgpack::object(a17, z); + o->via.array.ptr[18] = clmdep_msgpack::object(a18, z); + o->via.array.ptr[19] = clmdep_msgpack::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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20> { + typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20> value_type; + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20> tuple_type; + define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), 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 <typename Packer> + 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(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*21)); + o->via.array.size = 21; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + o->via.array.ptr[1] = clmdep_msgpack::object(a1, z); + o->via.array.ptr[2] = clmdep_msgpack::object(a2, z); + o->via.array.ptr[3] = clmdep_msgpack::object(a3, z); + o->via.array.ptr[4] = clmdep_msgpack::object(a4, z); + o->via.array.ptr[5] = clmdep_msgpack::object(a5, z); + o->via.array.ptr[6] = clmdep_msgpack::object(a6, z); + o->via.array.ptr[7] = clmdep_msgpack::object(a7, z); + o->via.array.ptr[8] = clmdep_msgpack::object(a8, z); + o->via.array.ptr[9] = clmdep_msgpack::object(a9, z); + o->via.array.ptr[10] = clmdep_msgpack::object(a10, z); + o->via.array.ptr[11] = clmdep_msgpack::object(a11, z); + o->via.array.ptr[12] = clmdep_msgpack::object(a12, z); + o->via.array.ptr[13] = clmdep_msgpack::object(a13, z); + o->via.array.ptr[14] = clmdep_msgpack::object(a14, z); + o->via.array.ptr[15] = clmdep_msgpack::object(a15, z); + o->via.array.ptr[16] = clmdep_msgpack::object(a16, z); + o->via.array.ptr[17] = clmdep_msgpack::object(a17, z); + o->via.array.ptr[18] = clmdep_msgpack::object(a18, z); + o->via.array.ptr[19] = clmdep_msgpack::object(a19, z); + o->via.array.ptr[20] = clmdep_msgpack::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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> { + typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> value_type; + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> tuple_type; + define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), 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 <typename Packer> + 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(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*22)); + o->via.array.size = 22; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + o->via.array.ptr[1] = clmdep_msgpack::object(a1, z); + o->via.array.ptr[2] = clmdep_msgpack::object(a2, z); + o->via.array.ptr[3] = clmdep_msgpack::object(a3, z); + o->via.array.ptr[4] = clmdep_msgpack::object(a4, z); + o->via.array.ptr[5] = clmdep_msgpack::object(a5, z); + o->via.array.ptr[6] = clmdep_msgpack::object(a6, z); + o->via.array.ptr[7] = clmdep_msgpack::object(a7, z); + o->via.array.ptr[8] = clmdep_msgpack::object(a8, z); + o->via.array.ptr[9] = clmdep_msgpack::object(a9, z); + o->via.array.ptr[10] = clmdep_msgpack::object(a10, z); + o->via.array.ptr[11] = clmdep_msgpack::object(a11, z); + o->via.array.ptr[12] = clmdep_msgpack::object(a12, z); + o->via.array.ptr[13] = clmdep_msgpack::object(a13, z); + o->via.array.ptr[14] = clmdep_msgpack::object(a14, z); + o->via.array.ptr[15] = clmdep_msgpack::object(a15, z); + o->via.array.ptr[16] = clmdep_msgpack::object(a16, z); + o->via.array.ptr[17] = clmdep_msgpack::object(a17, z); + o->via.array.ptr[18] = clmdep_msgpack::object(a18, z); + o->via.array.ptr[19] = clmdep_msgpack::object(a19, z); + o->via.array.ptr[20] = clmdep_msgpack::object(a20, z); + o->via.array.ptr[21] = clmdep_msgpack::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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22> { + typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22> value_type; + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22> tuple_type; + define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), 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 <typename Packer> + 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(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*23)); + o->via.array.size = 23; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + o->via.array.ptr[1] = clmdep_msgpack::object(a1, z); + o->via.array.ptr[2] = clmdep_msgpack::object(a2, z); + o->via.array.ptr[3] = clmdep_msgpack::object(a3, z); + o->via.array.ptr[4] = clmdep_msgpack::object(a4, z); + o->via.array.ptr[5] = clmdep_msgpack::object(a5, z); + o->via.array.ptr[6] = clmdep_msgpack::object(a6, z); + o->via.array.ptr[7] = clmdep_msgpack::object(a7, z); + o->via.array.ptr[8] = clmdep_msgpack::object(a8, z); + o->via.array.ptr[9] = clmdep_msgpack::object(a9, z); + o->via.array.ptr[10] = clmdep_msgpack::object(a10, z); + o->via.array.ptr[11] = clmdep_msgpack::object(a11, z); + o->via.array.ptr[12] = clmdep_msgpack::object(a12, z); + o->via.array.ptr[13] = clmdep_msgpack::object(a13, z); + o->via.array.ptr[14] = clmdep_msgpack::object(a14, z); + o->via.array.ptr[15] = clmdep_msgpack::object(a15, z); + o->via.array.ptr[16] = clmdep_msgpack::object(a16, z); + o->via.array.ptr[17] = clmdep_msgpack::object(a17, z); + o->via.array.ptr[18] = clmdep_msgpack::object(a18, z); + o->via.array.ptr[19] = clmdep_msgpack::object(a19, z); + o->via.array.ptr[20] = clmdep_msgpack::object(a20, z); + o->via.array.ptr[21] = clmdep_msgpack::object(a21, z); + o->via.array.ptr[22] = clmdep_msgpack::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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23> { + typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23> value_type; + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23> tuple_type; + define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), 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 <typename Packer> + 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(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*24)); + o->via.array.size = 24; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + o->via.array.ptr[1] = clmdep_msgpack::object(a1, z); + o->via.array.ptr[2] = clmdep_msgpack::object(a2, z); + o->via.array.ptr[3] = clmdep_msgpack::object(a3, z); + o->via.array.ptr[4] = clmdep_msgpack::object(a4, z); + o->via.array.ptr[5] = clmdep_msgpack::object(a5, z); + o->via.array.ptr[6] = clmdep_msgpack::object(a6, z); + o->via.array.ptr[7] = clmdep_msgpack::object(a7, z); + o->via.array.ptr[8] = clmdep_msgpack::object(a8, z); + o->via.array.ptr[9] = clmdep_msgpack::object(a9, z); + o->via.array.ptr[10] = clmdep_msgpack::object(a10, z); + o->via.array.ptr[11] = clmdep_msgpack::object(a11, z); + o->via.array.ptr[12] = clmdep_msgpack::object(a12, z); + o->via.array.ptr[13] = clmdep_msgpack::object(a13, z); + o->via.array.ptr[14] = clmdep_msgpack::object(a14, z); + o->via.array.ptr[15] = clmdep_msgpack::object(a15, z); + o->via.array.ptr[16] = clmdep_msgpack::object(a16, z); + o->via.array.ptr[17] = clmdep_msgpack::object(a17, z); + o->via.array.ptr[18] = clmdep_msgpack::object(a18, z); + o->via.array.ptr[19] = clmdep_msgpack::object(a19, z); + o->via.array.ptr[20] = clmdep_msgpack::object(a20, z); + o->via.array.ptr[21] = clmdep_msgpack::object(a21, z); + o->via.array.ptr[22] = clmdep_msgpack::object(a22, z); + o->via.array.ptr[23] = clmdep_msgpack::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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24> { + typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24> value_type; + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24> tuple_type; + define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), 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 <typename Packer> + 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(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*25)); + o->via.array.size = 25; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + o->via.array.ptr[1] = clmdep_msgpack::object(a1, z); + o->via.array.ptr[2] = clmdep_msgpack::object(a2, z); + o->via.array.ptr[3] = clmdep_msgpack::object(a3, z); + o->via.array.ptr[4] = clmdep_msgpack::object(a4, z); + o->via.array.ptr[5] = clmdep_msgpack::object(a5, z); + o->via.array.ptr[6] = clmdep_msgpack::object(a6, z); + o->via.array.ptr[7] = clmdep_msgpack::object(a7, z); + o->via.array.ptr[8] = clmdep_msgpack::object(a8, z); + o->via.array.ptr[9] = clmdep_msgpack::object(a9, z); + o->via.array.ptr[10] = clmdep_msgpack::object(a10, z); + o->via.array.ptr[11] = clmdep_msgpack::object(a11, z); + o->via.array.ptr[12] = clmdep_msgpack::object(a12, z); + o->via.array.ptr[13] = clmdep_msgpack::object(a13, z); + o->via.array.ptr[14] = clmdep_msgpack::object(a14, z); + o->via.array.ptr[15] = clmdep_msgpack::object(a15, z); + o->via.array.ptr[16] = clmdep_msgpack::object(a16, z); + o->via.array.ptr[17] = clmdep_msgpack::object(a17, z); + o->via.array.ptr[18] = clmdep_msgpack::object(a18, z); + o->via.array.ptr[19] = clmdep_msgpack::object(a19, z); + o->via.array.ptr[20] = clmdep_msgpack::object(a20, z); + o->via.array.ptr[21] = clmdep_msgpack::object(a21, z); + o->via.array.ptr[22] = clmdep_msgpack::object(a22, z); + o->via.array.ptr[23] = clmdep_msgpack::object(a23, z); + o->via.array.ptr[24] = clmdep_msgpack::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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25> { + typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25> value_type; + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25> tuple_type; + define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), 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 <typename Packer> + 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(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*26)); + o->via.array.size = 26; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + o->via.array.ptr[1] = clmdep_msgpack::object(a1, z); + o->via.array.ptr[2] = clmdep_msgpack::object(a2, z); + o->via.array.ptr[3] = clmdep_msgpack::object(a3, z); + o->via.array.ptr[4] = clmdep_msgpack::object(a4, z); + o->via.array.ptr[5] = clmdep_msgpack::object(a5, z); + o->via.array.ptr[6] = clmdep_msgpack::object(a6, z); + o->via.array.ptr[7] = clmdep_msgpack::object(a7, z); + o->via.array.ptr[8] = clmdep_msgpack::object(a8, z); + o->via.array.ptr[9] = clmdep_msgpack::object(a9, z); + o->via.array.ptr[10] = clmdep_msgpack::object(a10, z); + o->via.array.ptr[11] = clmdep_msgpack::object(a11, z); + o->via.array.ptr[12] = clmdep_msgpack::object(a12, z); + o->via.array.ptr[13] = clmdep_msgpack::object(a13, z); + o->via.array.ptr[14] = clmdep_msgpack::object(a14, z); + o->via.array.ptr[15] = clmdep_msgpack::object(a15, z); + o->via.array.ptr[16] = clmdep_msgpack::object(a16, z); + o->via.array.ptr[17] = clmdep_msgpack::object(a17, z); + o->via.array.ptr[18] = clmdep_msgpack::object(a18, z); + o->via.array.ptr[19] = clmdep_msgpack::object(a19, z); + o->via.array.ptr[20] = clmdep_msgpack::object(a20, z); + o->via.array.ptr[21] = clmdep_msgpack::object(a21, z); + o->via.array.ptr[22] = clmdep_msgpack::object(a22, z); + o->via.array.ptr[23] = clmdep_msgpack::object(a23, z); + o->via.array.ptr[24] = clmdep_msgpack::object(a24, z); + o->via.array.ptr[25] = clmdep_msgpack::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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26> { + typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26> value_type; + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26> tuple_type; + define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), 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 <typename Packer> + 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(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*27)); + o->via.array.size = 27; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + o->via.array.ptr[1] = clmdep_msgpack::object(a1, z); + o->via.array.ptr[2] = clmdep_msgpack::object(a2, z); + o->via.array.ptr[3] = clmdep_msgpack::object(a3, z); + o->via.array.ptr[4] = clmdep_msgpack::object(a4, z); + o->via.array.ptr[5] = clmdep_msgpack::object(a5, z); + o->via.array.ptr[6] = clmdep_msgpack::object(a6, z); + o->via.array.ptr[7] = clmdep_msgpack::object(a7, z); + o->via.array.ptr[8] = clmdep_msgpack::object(a8, z); + o->via.array.ptr[9] = clmdep_msgpack::object(a9, z); + o->via.array.ptr[10] = clmdep_msgpack::object(a10, z); + o->via.array.ptr[11] = clmdep_msgpack::object(a11, z); + o->via.array.ptr[12] = clmdep_msgpack::object(a12, z); + o->via.array.ptr[13] = clmdep_msgpack::object(a13, z); + o->via.array.ptr[14] = clmdep_msgpack::object(a14, z); + o->via.array.ptr[15] = clmdep_msgpack::object(a15, z); + o->via.array.ptr[16] = clmdep_msgpack::object(a16, z); + o->via.array.ptr[17] = clmdep_msgpack::object(a17, z); + o->via.array.ptr[18] = clmdep_msgpack::object(a18, z); + o->via.array.ptr[19] = clmdep_msgpack::object(a19, z); + o->via.array.ptr[20] = clmdep_msgpack::object(a20, z); + o->via.array.ptr[21] = clmdep_msgpack::object(a21, z); + o->via.array.ptr[22] = clmdep_msgpack::object(a22, z); + o->via.array.ptr[23] = clmdep_msgpack::object(a23, z); + o->via.array.ptr[24] = clmdep_msgpack::object(a24, z); + o->via.array.ptr[25] = clmdep_msgpack::object(a25, z); + o->via.array.ptr[26] = clmdep_msgpack::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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27> { + typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27> value_type; + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27> tuple_type; + define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), 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 <typename Packer> + 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(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*28)); + o->via.array.size = 28; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + o->via.array.ptr[1] = clmdep_msgpack::object(a1, z); + o->via.array.ptr[2] = clmdep_msgpack::object(a2, z); + o->via.array.ptr[3] = clmdep_msgpack::object(a3, z); + o->via.array.ptr[4] = clmdep_msgpack::object(a4, z); + o->via.array.ptr[5] = clmdep_msgpack::object(a5, z); + o->via.array.ptr[6] = clmdep_msgpack::object(a6, z); + o->via.array.ptr[7] = clmdep_msgpack::object(a7, z); + o->via.array.ptr[8] = clmdep_msgpack::object(a8, z); + o->via.array.ptr[9] = clmdep_msgpack::object(a9, z); + o->via.array.ptr[10] = clmdep_msgpack::object(a10, z); + o->via.array.ptr[11] = clmdep_msgpack::object(a11, z); + o->via.array.ptr[12] = clmdep_msgpack::object(a12, z); + o->via.array.ptr[13] = clmdep_msgpack::object(a13, z); + o->via.array.ptr[14] = clmdep_msgpack::object(a14, z); + o->via.array.ptr[15] = clmdep_msgpack::object(a15, z); + o->via.array.ptr[16] = clmdep_msgpack::object(a16, z); + o->via.array.ptr[17] = clmdep_msgpack::object(a17, z); + o->via.array.ptr[18] = clmdep_msgpack::object(a18, z); + o->via.array.ptr[19] = clmdep_msgpack::object(a19, z); + o->via.array.ptr[20] = clmdep_msgpack::object(a20, z); + o->via.array.ptr[21] = clmdep_msgpack::object(a21, z); + o->via.array.ptr[22] = clmdep_msgpack::object(a22, z); + o->via.array.ptr[23] = clmdep_msgpack::object(a23, z); + o->via.array.ptr[24] = clmdep_msgpack::object(a24, z); + o->via.array.ptr[25] = clmdep_msgpack::object(a25, z); + o->via.array.ptr[26] = clmdep_msgpack::object(a26, z); + o->via.array.ptr[27] = clmdep_msgpack::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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28> { + typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28> value_type; + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28> tuple_type; + define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27, A28& _a28) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), 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 <typename Packer> + 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(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*29)); + o->via.array.size = 29; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + o->via.array.ptr[1] = clmdep_msgpack::object(a1, z); + o->via.array.ptr[2] = clmdep_msgpack::object(a2, z); + o->via.array.ptr[3] = clmdep_msgpack::object(a3, z); + o->via.array.ptr[4] = clmdep_msgpack::object(a4, z); + o->via.array.ptr[5] = clmdep_msgpack::object(a5, z); + o->via.array.ptr[6] = clmdep_msgpack::object(a6, z); + o->via.array.ptr[7] = clmdep_msgpack::object(a7, z); + o->via.array.ptr[8] = clmdep_msgpack::object(a8, z); + o->via.array.ptr[9] = clmdep_msgpack::object(a9, z); + o->via.array.ptr[10] = clmdep_msgpack::object(a10, z); + o->via.array.ptr[11] = clmdep_msgpack::object(a11, z); + o->via.array.ptr[12] = clmdep_msgpack::object(a12, z); + o->via.array.ptr[13] = clmdep_msgpack::object(a13, z); + o->via.array.ptr[14] = clmdep_msgpack::object(a14, z); + o->via.array.ptr[15] = clmdep_msgpack::object(a15, z); + o->via.array.ptr[16] = clmdep_msgpack::object(a16, z); + o->via.array.ptr[17] = clmdep_msgpack::object(a17, z); + o->via.array.ptr[18] = clmdep_msgpack::object(a18, z); + o->via.array.ptr[19] = clmdep_msgpack::object(a19, z); + o->via.array.ptr[20] = clmdep_msgpack::object(a20, z); + o->via.array.ptr[21] = clmdep_msgpack::object(a21, z); + o->via.array.ptr[22] = clmdep_msgpack::object(a22, z); + o->via.array.ptr[23] = clmdep_msgpack::object(a23, z); + o->via.array.ptr[24] = clmdep_msgpack::object(a24, z); + o->via.array.ptr[25] = clmdep_msgpack::object(a25, z); + o->via.array.ptr[26] = clmdep_msgpack::object(a26, z); + o->via.array.ptr[27] = clmdep_msgpack::object(a27, z); + o->via.array.ptr[28] = clmdep_msgpack::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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29> { + typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29> value_type; + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29> tuple_type; + define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27, A28& _a28, A29& _a29) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), 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 <typename Packer> + 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(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*30)); + o->via.array.size = 30; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + o->via.array.ptr[1] = clmdep_msgpack::object(a1, z); + o->via.array.ptr[2] = clmdep_msgpack::object(a2, z); + o->via.array.ptr[3] = clmdep_msgpack::object(a3, z); + o->via.array.ptr[4] = clmdep_msgpack::object(a4, z); + o->via.array.ptr[5] = clmdep_msgpack::object(a5, z); + o->via.array.ptr[6] = clmdep_msgpack::object(a6, z); + o->via.array.ptr[7] = clmdep_msgpack::object(a7, z); + o->via.array.ptr[8] = clmdep_msgpack::object(a8, z); + o->via.array.ptr[9] = clmdep_msgpack::object(a9, z); + o->via.array.ptr[10] = clmdep_msgpack::object(a10, z); + o->via.array.ptr[11] = clmdep_msgpack::object(a11, z); + o->via.array.ptr[12] = clmdep_msgpack::object(a12, z); + o->via.array.ptr[13] = clmdep_msgpack::object(a13, z); + o->via.array.ptr[14] = clmdep_msgpack::object(a14, z); + o->via.array.ptr[15] = clmdep_msgpack::object(a15, z); + o->via.array.ptr[16] = clmdep_msgpack::object(a16, z); + o->via.array.ptr[17] = clmdep_msgpack::object(a17, z); + o->via.array.ptr[18] = clmdep_msgpack::object(a18, z); + o->via.array.ptr[19] = clmdep_msgpack::object(a19, z); + o->via.array.ptr[20] = clmdep_msgpack::object(a20, z); + o->via.array.ptr[21] = clmdep_msgpack::object(a21, z); + o->via.array.ptr[22] = clmdep_msgpack::object(a22, z); + o->via.array.ptr[23] = clmdep_msgpack::object(a23, z); + o->via.array.ptr[24] = clmdep_msgpack::object(a24, z); + o->via.array.ptr[25] = clmdep_msgpack::object(a25, z); + o->via.array.ptr[26] = clmdep_msgpack::object(a26, z); + o->via.array.ptr[27] = clmdep_msgpack::object(a27, z); + o->via.array.ptr[28] = clmdep_msgpack::object(a28, z); + o->via.array.ptr[29] = clmdep_msgpack::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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30> { + typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30> value_type; + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30> tuple_type; + define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27, A28& _a28, A29& _a29, A30& _a30) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), 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 <typename Packer> + 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(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*31)); + o->via.array.size = 31; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + o->via.array.ptr[1] = clmdep_msgpack::object(a1, z); + o->via.array.ptr[2] = clmdep_msgpack::object(a2, z); + o->via.array.ptr[3] = clmdep_msgpack::object(a3, z); + o->via.array.ptr[4] = clmdep_msgpack::object(a4, z); + o->via.array.ptr[5] = clmdep_msgpack::object(a5, z); + o->via.array.ptr[6] = clmdep_msgpack::object(a6, z); + o->via.array.ptr[7] = clmdep_msgpack::object(a7, z); + o->via.array.ptr[8] = clmdep_msgpack::object(a8, z); + o->via.array.ptr[9] = clmdep_msgpack::object(a9, z); + o->via.array.ptr[10] = clmdep_msgpack::object(a10, z); + o->via.array.ptr[11] = clmdep_msgpack::object(a11, z); + o->via.array.ptr[12] = clmdep_msgpack::object(a12, z); + o->via.array.ptr[13] = clmdep_msgpack::object(a13, z); + o->via.array.ptr[14] = clmdep_msgpack::object(a14, z); + o->via.array.ptr[15] = clmdep_msgpack::object(a15, z); + o->via.array.ptr[16] = clmdep_msgpack::object(a16, z); + o->via.array.ptr[17] = clmdep_msgpack::object(a17, z); + o->via.array.ptr[18] = clmdep_msgpack::object(a18, z); + o->via.array.ptr[19] = clmdep_msgpack::object(a19, z); + o->via.array.ptr[20] = clmdep_msgpack::object(a20, z); + o->via.array.ptr[21] = clmdep_msgpack::object(a21, z); + o->via.array.ptr[22] = clmdep_msgpack::object(a22, z); + o->via.array.ptr[23] = clmdep_msgpack::object(a23, z); + o->via.array.ptr[24] = clmdep_msgpack::object(a24, z); + o->via.array.ptr[25] = clmdep_msgpack::object(a25, z); + o->via.array.ptr[26] = clmdep_msgpack::object(a26, z); + o->via.array.ptr[27] = clmdep_msgpack::object(a27, z); + o->via.array.ptr[28] = clmdep_msgpack::object(a28, z); + o->via.array.ptr[29] = clmdep_msgpack::object(a29, z); + o->via.array.ptr[30] = clmdep_msgpack::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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31> { + typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31> value_type; + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31> tuple_type; + define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27, A28& _a28, A29& _a29, A30& _a30, A31& _a31) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), 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 <typename Packer> + 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(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*32)); + o->via.array.size = 32; + + o->via.array.ptr[0] = clmdep_msgpack::object(a0, z); + o->via.array.ptr[1] = clmdep_msgpack::object(a1, z); + o->via.array.ptr[2] = clmdep_msgpack::object(a2, z); + o->via.array.ptr[3] = clmdep_msgpack::object(a3, z); + o->via.array.ptr[4] = clmdep_msgpack::object(a4, z); + o->via.array.ptr[5] = clmdep_msgpack::object(a5, z); + o->via.array.ptr[6] = clmdep_msgpack::object(a6, z); + o->via.array.ptr[7] = clmdep_msgpack::object(a7, z); + o->via.array.ptr[8] = clmdep_msgpack::object(a8, z); + o->via.array.ptr[9] = clmdep_msgpack::object(a9, z); + o->via.array.ptr[10] = clmdep_msgpack::object(a10, z); + o->via.array.ptr[11] = clmdep_msgpack::object(a11, z); + o->via.array.ptr[12] = clmdep_msgpack::object(a12, z); + o->via.array.ptr[13] = clmdep_msgpack::object(a13, z); + o->via.array.ptr[14] = clmdep_msgpack::object(a14, z); + o->via.array.ptr[15] = clmdep_msgpack::object(a15, z); + o->via.array.ptr[16] = clmdep_msgpack::object(a16, z); + o->via.array.ptr[17] = clmdep_msgpack::object(a17, z); + o->via.array.ptr[18] = clmdep_msgpack::object(a18, z); + o->via.array.ptr[19] = clmdep_msgpack::object(a19, z); + o->via.array.ptr[20] = clmdep_msgpack::object(a20, z); + o->via.array.ptr[21] = clmdep_msgpack::object(a21, z); + o->via.array.ptr[22] = clmdep_msgpack::object(a22, z); + o->via.array.ptr[23] = clmdep_msgpack::object(a23, z); + o->via.array.ptr[24] = clmdep_msgpack::object(a24, z); + o->via.array.ptr[25] = clmdep_msgpack::object(a25, z); + o->via.array.ptr[26] = clmdep_msgpack::object(a26, z); + o->via.array.ptr[27] = clmdep_msgpack::object(a27, z); + o->via.array.ptr[28] = clmdep_msgpack::object(a28, z); + o->via.array.ptr[29] = clmdep_msgpack::object(a29, z); + o->via.array.ptr[30] = clmdep_msgpack::object(a30, z); + o->via.array.ptr[31] = clmdep_msgpack::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; +}; + +/// @endcond + +inline define_array<> make_define_array() +{ + return define_array<>(); +} + +/// @cond + +template <typename A0> +inline define_array<A0> make_define_array(A0& a0) +{ + return define_array<A0>(a0); +} + +template <typename A0, typename A1> +inline define_array<A0, A1> make_define_array(A0& a0, A1& a1) +{ + return define_array<A0, A1>(a0, a1); +} + +template <typename A0, typename A1, typename A2> +inline define_array<A0, A1, A2> make_define_array(A0& a0, A1& a1, A2& a2) +{ + return define_array<A0, A1, A2>(a0, a1, a2); +} + +template <typename A0, typename A1, typename A2, typename A3> +inline define_array<A0, A1, A2, A3> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3) +{ + return define_array<A0, A1, A2, A3>(a0, a1, a2, a3); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4> +inline define_array<A0, A1, A2, A3, A4> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4) +{ + return define_array<A0, A1, A2, A3, A4>(a0, a1, a2, a3, a4); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5> +inline define_array<A0, A1, A2, A3, A4, A5> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) +{ + return define_array<A0, A1, A2, A3, A4, A5>(a0, a1, a2, a3, a4, a5); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6> +inline define_array<A0, A1, A2, A3, A4, A5, A6> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) +{ + return define_array<A0, A1, A2, A3, A4, A5, A6>(a0, a1, a2, a3, a4, a5, a6); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> +inline define_array<A0, A1, A2, A3, A4, A5, A6, A7> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) +{ + return define_array<A0, A1, A2, A3, A4, A5, A6, A7>(a0, a1, a2, a3, a4, a5, a6, a7); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> +inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) +{ + return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8>(a0, a1, a2, a3, a4, a5, a6, a7, a8); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> +inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) +{ + return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10) +{ + return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11) +{ + return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12) +{ + return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13) +{ + return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14) +{ + return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15) +{ + return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16) +{ + return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17) +{ + return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18) +{ + return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19) +{ + return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20) +{ + return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21) +{ + return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22) +{ + return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23) +{ + return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24) +{ + return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25) +{ + return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26) +{ + return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27) +{ + return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28) +{ + return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28, A29& a29) +{ + return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28, A29& a29, A30& a30) +{ + return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28, A29& a29, A30& a30, A31& a31) +{ + return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31); +} + +/// @endcond + +} // namespace type +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond +} // namespace clmdep_msgpack + + +#endif // MSGPACK_CPP03_DEFINE_ARRAY_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/detail/cpp03_define_map.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/detail/cpp03_define_map.hpp new file mode 100644 index 000000000..814240548 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/detail/cpp03_define_map.hpp @@ -0,0 +1,2799 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2015 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_CPP03_DEFINE_MAP_HPP +#define MSGPACK_CPP03_DEFINE_MAP_HPP + +// BOOST_PP_VARIADICS is defined in boost/preprocessor/config/config.hpp +// http://www.boost.org/libs/preprocessor/doc/ref/variadics.html +// However, supporting compiler detection is not complete. msgpack-c requires +// variadic macro arguments support. So BOOST_PP_VARIADICS is defined here explicitly. +#if !defined(MSGPACK_PP_VARIADICS) +#define MSGPACK_PP_VARIADICS +#endif + +#include <rpc/msgpack/preprocessor.hpp> + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/msgpack_tuple.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" +#include "rpc/msgpack/object_fwd.hpp" + +#define MSGPACK_DEFINE_MAP_EACH_PROC(r, data, elem) \ + MSGPACK_PP_IF( \ + MSGPACK_PP_IS_BEGIN_PARENS(elem), \ + elem, \ + (MSGPACK_PP_STRINGIZE(elem))(elem) \ + ) + +#define MSGPACK_DEFINE_MAP_IMPL(...) \ + MSGPACK_PP_SEQ_TO_TUPLE( \ + MSGPACK_PP_SEQ_FOR_EACH( \ + MSGPACK_DEFINE_MAP_EACH_PROC, \ + 0, \ + MSGPACK_PP_VARIADIC_TO_SEQ(__VA_ARGS__) \ + ) \ + ) + +#define MSGPACK_DEFINE_MAP(...) \ + template <typename Packer> \ + void msgpack_pack(Packer& pk) const \ + { \ + clmdep_msgpack::type::make_define_map \ + MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \ + .msgpack_pack(pk); \ + } \ + void msgpack_unpack(clmdep_msgpack::object const& o) \ + { \ + clmdep_msgpack::type::make_define_map \ + MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \ + .msgpack_unpack(o); \ + }\ + template <typename MSGPACK_OBJECT> \ + void msgpack_object(MSGPACK_OBJECT* o, clmdep_msgpack::zone& z) const \ + { \ + clmdep_msgpack::type::make_define_map \ + MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \ + .msgpack_object(o, z); \ + } + +#define MSGPACK_BASE_MAP(base) \ + (MSGPACK_PP_STRINGIZE(base))(*const_cast<base *>(static_cast<base const*>(this))) + +namespace clmdep_msgpack { +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond +namespace type { + +/// @cond + +template <typename A0 = void, typename A1 = void, typename A2 = void, typename A3 = void, typename A4 = void, typename A5 = void, typename A6 = void, typename A7 = void, typename A8 = void, typename A9 = void, typename A10 = void, typename A11 = void, typename A12 = void, typename A13 = void, typename A14 = void, typename A15 = void, typename A16 = void, typename A17 = void, typename A18 = void, typename A19 = void, typename A20 = void, typename A21 = void, typename A22 = void, typename A23 = void, typename A24 = void, typename A25 = void, typename A26 = void, typename A27 = void, typename A28 = void, typename A29 = void, typename A30 = void, typename A31 = void, typename A32 = void> +struct define_map; +/// @endcond + +template <> +struct define_map<> { + template <typename Packer> + void msgpack_pack(Packer& pk) const + { + pk.pack_map(0); + } + void msgpack_unpack(clmdep_msgpack::object const& o) const + { + if(o.type != clmdep_msgpack::type::MAP) { throw clmdep_msgpack::type_error(); } + } + void msgpack_object(clmdep_msgpack::object* o, clmdep_msgpack::zone&) const + { + o->type = clmdep_msgpack::type::MAP; + o->via.map.ptr = nullptr; + o->via.map.size = 0; + } +}; + +/// @cond + +template <typename A0, typename A1> +struct define_map<A0, A1> { + define_map(A0& _a0, A1& _a1) : + a0(_a0), a1(_a1) {} + template <typename Packer> + void msgpack_pack(Packer& pk) const + { + pk.pack_map(1); + + pk.pack(a0); + pk.pack(a1); + } + void msgpack_unpack(clmdep_msgpack::object const& o) const + { + if(o.type != clmdep_msgpack::type::MAP) { throw clmdep_msgpack::type_error(); } + std::map<std::string, clmdep_msgpack::object const*> kvmap; + for (uint32_t i = 0; i < o.via.map.size; ++i) { + kvmap.insert( + std::map<std::string, clmdep_msgpack::object const*>::value_type( + std::string( + o.via.map.ptr[i].key.via.str.ptr, + o.via.map.ptr[i].key.via.str.size), + &o.via.map.ptr[i].val + ) + ); + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a0); + if (it != kvmap.end()) { + it->second->convert(a1); + } + } + + } + void msgpack_object(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::MAP; + o->via.map.ptr = static_cast<clmdep_msgpack::object_kv*>(z.allocate_align(sizeof(clmdep_msgpack::object_kv)*1)); + o->via.map.size = 1; + + o->via.map.ptr[0].key = clmdep_msgpack::object(a0, z); + o->via.map.ptr[0].val = clmdep_msgpack::object(a1, z); + + } + + A0& a0; + A1& a1; +}; + +template <typename A0, typename A1, typename A2, typename A3> +struct define_map<A0, A1, A2, A3> { + define_map(A0& _a0, A1& _a1, A2& _a2, A3& _a3) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3) {} + template <typename Packer> + void msgpack_pack(Packer& pk) const + { + pk.pack_map(2); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + } + void msgpack_unpack(clmdep_msgpack::object const& o) const + { + if(o.type != clmdep_msgpack::type::MAP) { throw clmdep_msgpack::type_error(); } + std::map<std::string, clmdep_msgpack::object const*> kvmap; + for (uint32_t i = 0; i < o.via.map.size; ++i) { + kvmap.insert( + std::map<std::string, clmdep_msgpack::object const*>::value_type( + std::string( + o.via.map.ptr[i].key.via.str.ptr, + o.via.map.ptr[i].key.via.str.size), + &o.via.map.ptr[i].val + ) + ); + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a0); + if (it != kvmap.end()) { + it->second->convert(a1); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a2); + if (it != kvmap.end()) { + it->second->convert(a3); + } + } + + } + void msgpack_object(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::MAP; + o->via.map.ptr = static_cast<clmdep_msgpack::object_kv*>(z.allocate_align(sizeof(clmdep_msgpack::object_kv)*2)); + o->via.map.size = 2; + + o->via.map.ptr[0].key = clmdep_msgpack::object(a0, z); + o->via.map.ptr[0].val = clmdep_msgpack::object(a1, z); + + o->via.map.ptr[1].key = clmdep_msgpack::object(a2, z); + o->via.map.ptr[1].val = clmdep_msgpack::object(a3, z); + + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5> +struct define_map<A0, A1, A2, A3, A4, A5> { + define_map(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 <typename Packer> + void msgpack_pack(Packer& pk) const + { + pk.pack_map(3); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + } + void msgpack_unpack(clmdep_msgpack::object const& o) const + { + if(o.type != clmdep_msgpack::type::MAP) { throw clmdep_msgpack::type_error(); } + std::map<std::string, clmdep_msgpack::object const*> kvmap; + for (uint32_t i = 0; i < o.via.map.size; ++i) { + kvmap.insert( + std::map<std::string, clmdep_msgpack::object const*>::value_type( + std::string( + o.via.map.ptr[i].key.via.str.ptr, + o.via.map.ptr[i].key.via.str.size), + &o.via.map.ptr[i].val + ) + ); + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a0); + if (it != kvmap.end()) { + it->second->convert(a1); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a2); + if (it != kvmap.end()) { + it->second->convert(a3); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a4); + if (it != kvmap.end()) { + it->second->convert(a5); + } + } + + } + void msgpack_object(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::MAP; + o->via.map.ptr = static_cast<clmdep_msgpack::object_kv*>(z.allocate_align(sizeof(clmdep_msgpack::object_kv)*3)); + o->via.map.size = 3; + + o->via.map.ptr[0].key = clmdep_msgpack::object(a0, z); + o->via.map.ptr[0].val = clmdep_msgpack::object(a1, z); + + o->via.map.ptr[1].key = clmdep_msgpack::object(a2, z); + o->via.map.ptr[1].val = clmdep_msgpack::object(a3, z); + + o->via.map.ptr[2].key = clmdep_msgpack::object(a4, z); + o->via.map.ptr[2].val = clmdep_msgpack::object(a5, z); + + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> +struct define_map<A0, A1, A2, A3, A4, A5, A6, A7> { + define_map(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 <typename Packer> + void msgpack_pack(Packer& pk) const + { + pk.pack_map(4); + + 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(clmdep_msgpack::object const& o) const + { + if(o.type != clmdep_msgpack::type::MAP) { throw clmdep_msgpack::type_error(); } + std::map<std::string, clmdep_msgpack::object const*> kvmap; + for (uint32_t i = 0; i < o.via.map.size; ++i) { + kvmap.insert( + std::map<std::string, clmdep_msgpack::object const*>::value_type( + std::string( + o.via.map.ptr[i].key.via.str.ptr, + o.via.map.ptr[i].key.via.str.size), + &o.via.map.ptr[i].val + ) + ); + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a0); + if (it != kvmap.end()) { + it->second->convert(a1); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a2); + if (it != kvmap.end()) { + it->second->convert(a3); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a4); + if (it != kvmap.end()) { + it->second->convert(a5); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a6); + if (it != kvmap.end()) { + it->second->convert(a7); + } + } + + } + void msgpack_object(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::MAP; + o->via.map.ptr = static_cast<clmdep_msgpack::object_kv*>(z.allocate_align(sizeof(clmdep_msgpack::object_kv)*4)); + o->via.map.size = 4; + + o->via.map.ptr[0].key = clmdep_msgpack::object(a0, z); + o->via.map.ptr[0].val = clmdep_msgpack::object(a1, z); + + o->via.map.ptr[1].key = clmdep_msgpack::object(a2, z); + o->via.map.ptr[1].val = clmdep_msgpack::object(a3, z); + + o->via.map.ptr[2].key = clmdep_msgpack::object(a4, z); + o->via.map.ptr[2].val = clmdep_msgpack::object(a5, z); + + o->via.map.ptr[3].key = clmdep_msgpack::object(a6, z); + o->via.map.ptr[3].val = clmdep_msgpack::object(a7, z); + + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> +struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> { + define_map(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 <typename Packer> + void msgpack_pack(Packer& pk) const + { + pk.pack_map(5); + + 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(clmdep_msgpack::object const& o) const + { + if(o.type != clmdep_msgpack::type::MAP) { throw clmdep_msgpack::type_error(); } + std::map<std::string, clmdep_msgpack::object const*> kvmap; + for (uint32_t i = 0; i < o.via.map.size; ++i) { + kvmap.insert( + std::map<std::string, clmdep_msgpack::object const*>::value_type( + std::string( + o.via.map.ptr[i].key.via.str.ptr, + o.via.map.ptr[i].key.via.str.size), + &o.via.map.ptr[i].val + ) + ); + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a0); + if (it != kvmap.end()) { + it->second->convert(a1); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a2); + if (it != kvmap.end()) { + it->second->convert(a3); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a4); + if (it != kvmap.end()) { + it->second->convert(a5); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a6); + if (it != kvmap.end()) { + it->second->convert(a7); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a8); + if (it != kvmap.end()) { + it->second->convert(a9); + } + } + + } + void msgpack_object(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::MAP; + o->via.map.ptr = static_cast<clmdep_msgpack::object_kv*>(z.allocate_align(sizeof(clmdep_msgpack::object_kv)*5)); + o->via.map.size = 5; + + o->via.map.ptr[0].key = clmdep_msgpack::object(a0, z); + o->via.map.ptr[0].val = clmdep_msgpack::object(a1, z); + + o->via.map.ptr[1].key = clmdep_msgpack::object(a2, z); + o->via.map.ptr[1].val = clmdep_msgpack::object(a3, z); + + o->via.map.ptr[2].key = clmdep_msgpack::object(a4, z); + o->via.map.ptr[2].val = clmdep_msgpack::object(a5, z); + + o->via.map.ptr[3].key = clmdep_msgpack::object(a6, z); + o->via.map.ptr[3].val = clmdep_msgpack::object(a7, z); + + o->via.map.ptr[4].key = clmdep_msgpack::object(a8, z); + o->via.map.ptr[4].val = clmdep_msgpack::object(a9, z); + + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> { + define_map(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11) : + 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 <typename Packer> + void msgpack_pack(Packer& pk) const + { + pk.pack_map(6); + + 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(clmdep_msgpack::object const& o) const + { + if(o.type != clmdep_msgpack::type::MAP) { throw clmdep_msgpack::type_error(); } + std::map<std::string, clmdep_msgpack::object const*> kvmap; + for (uint32_t i = 0; i < o.via.map.size; ++i) { + kvmap.insert( + std::map<std::string, clmdep_msgpack::object const*>::value_type( + std::string( + o.via.map.ptr[i].key.via.str.ptr, + o.via.map.ptr[i].key.via.str.size), + &o.via.map.ptr[i].val + ) + ); + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a0); + if (it != kvmap.end()) { + it->second->convert(a1); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a2); + if (it != kvmap.end()) { + it->second->convert(a3); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a4); + if (it != kvmap.end()) { + it->second->convert(a5); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a6); + if (it != kvmap.end()) { + it->second->convert(a7); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a8); + if (it != kvmap.end()) { + it->second->convert(a9); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a10); + if (it != kvmap.end()) { + it->second->convert(a11); + } + } + + } + void msgpack_object(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::MAP; + o->via.map.ptr = static_cast<clmdep_msgpack::object_kv*>(z.allocate_align(sizeof(clmdep_msgpack::object_kv)*6)); + o->via.map.size = 6; + + o->via.map.ptr[0].key = clmdep_msgpack::object(a0, z); + o->via.map.ptr[0].val = clmdep_msgpack::object(a1, z); + + o->via.map.ptr[1].key = clmdep_msgpack::object(a2, z); + o->via.map.ptr[1].val = clmdep_msgpack::object(a3, z); + + o->via.map.ptr[2].key = clmdep_msgpack::object(a4, z); + o->via.map.ptr[2].val = clmdep_msgpack::object(a5, z); + + o->via.map.ptr[3].key = clmdep_msgpack::object(a6, z); + o->via.map.ptr[3].val = clmdep_msgpack::object(a7, z); + + o->via.map.ptr[4].key = clmdep_msgpack::object(a8, z); + o->via.map.ptr[4].val = clmdep_msgpack::object(a9, z); + + o->via.map.ptr[5].key = clmdep_msgpack::object(a10, z); + o->via.map.ptr[5].val = clmdep_msgpack::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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> { + define_map(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13) : + a0(_a0), a1(_a1), 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 <typename Packer> + void msgpack_pack(Packer& pk) const + { + pk.pack_map(7); + + 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(clmdep_msgpack::object const& o) const + { + if(o.type != clmdep_msgpack::type::MAP) { throw clmdep_msgpack::type_error(); } + std::map<std::string, clmdep_msgpack::object const*> kvmap; + for (uint32_t i = 0; i < o.via.map.size; ++i) { + kvmap.insert( + std::map<std::string, clmdep_msgpack::object const*>::value_type( + std::string( + o.via.map.ptr[i].key.via.str.ptr, + o.via.map.ptr[i].key.via.str.size), + &o.via.map.ptr[i].val + ) + ); + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a0); + if (it != kvmap.end()) { + it->second->convert(a1); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a2); + if (it != kvmap.end()) { + it->second->convert(a3); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a4); + if (it != kvmap.end()) { + it->second->convert(a5); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a6); + if (it != kvmap.end()) { + it->second->convert(a7); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a8); + if (it != kvmap.end()) { + it->second->convert(a9); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a10); + if (it != kvmap.end()) { + it->second->convert(a11); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a12); + if (it != kvmap.end()) { + it->second->convert(a13); + } + } + + } + void msgpack_object(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::MAP; + o->via.map.ptr = static_cast<clmdep_msgpack::object_kv*>(z.allocate_align(sizeof(clmdep_msgpack::object_kv)*7)); + o->via.map.size = 7; + + o->via.map.ptr[0].key = clmdep_msgpack::object(a0, z); + o->via.map.ptr[0].val = clmdep_msgpack::object(a1, z); + + o->via.map.ptr[1].key = clmdep_msgpack::object(a2, z); + o->via.map.ptr[1].val = clmdep_msgpack::object(a3, z); + + o->via.map.ptr[2].key = clmdep_msgpack::object(a4, z); + o->via.map.ptr[2].val = clmdep_msgpack::object(a5, z); + + o->via.map.ptr[3].key = clmdep_msgpack::object(a6, z); + o->via.map.ptr[3].val = clmdep_msgpack::object(a7, z); + + o->via.map.ptr[4].key = clmdep_msgpack::object(a8, z); + o->via.map.ptr[4].val = clmdep_msgpack::object(a9, z); + + o->via.map.ptr[5].key = clmdep_msgpack::object(a10, z); + o->via.map.ptr[5].val = clmdep_msgpack::object(a11, z); + + o->via.map.ptr[6].key = clmdep_msgpack::object(a12, z); + o->via.map.ptr[6].val = clmdep_msgpack::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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> { + define_map(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), 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 <typename Packer> + void msgpack_pack(Packer& pk) const + { + pk.pack_map(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); + 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(clmdep_msgpack::object const& o) const + { + if(o.type != clmdep_msgpack::type::MAP) { throw clmdep_msgpack::type_error(); } + std::map<std::string, clmdep_msgpack::object const*> kvmap; + for (uint32_t i = 0; i < o.via.map.size; ++i) { + kvmap.insert( + std::map<std::string, clmdep_msgpack::object const*>::value_type( + std::string( + o.via.map.ptr[i].key.via.str.ptr, + o.via.map.ptr[i].key.via.str.size), + &o.via.map.ptr[i].val + ) + ); + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a0); + if (it != kvmap.end()) { + it->second->convert(a1); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a2); + if (it != kvmap.end()) { + it->second->convert(a3); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a4); + if (it != kvmap.end()) { + it->second->convert(a5); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a6); + if (it != kvmap.end()) { + it->second->convert(a7); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a8); + if (it != kvmap.end()) { + it->second->convert(a9); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a10); + if (it != kvmap.end()) { + it->second->convert(a11); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a12); + if (it != kvmap.end()) { + it->second->convert(a13); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a14); + if (it != kvmap.end()) { + it->second->convert(a15); + } + } + + } + void msgpack_object(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::MAP; + o->via.map.ptr = static_cast<clmdep_msgpack::object_kv*>(z.allocate_align(sizeof(clmdep_msgpack::object_kv)*8)); + o->via.map.size = 8; + + o->via.map.ptr[0].key = clmdep_msgpack::object(a0, z); + o->via.map.ptr[0].val = clmdep_msgpack::object(a1, z); + + o->via.map.ptr[1].key = clmdep_msgpack::object(a2, z); + o->via.map.ptr[1].val = clmdep_msgpack::object(a3, z); + + o->via.map.ptr[2].key = clmdep_msgpack::object(a4, z); + o->via.map.ptr[2].val = clmdep_msgpack::object(a5, z); + + o->via.map.ptr[3].key = clmdep_msgpack::object(a6, z); + o->via.map.ptr[3].val = clmdep_msgpack::object(a7, z); + + o->via.map.ptr[4].key = clmdep_msgpack::object(a8, z); + o->via.map.ptr[4].val = clmdep_msgpack::object(a9, z); + + o->via.map.ptr[5].key = clmdep_msgpack::object(a10, z); + o->via.map.ptr[5].val = clmdep_msgpack::object(a11, z); + + o->via.map.ptr[6].key = clmdep_msgpack::object(a12, z); + o->via.map.ptr[6].val = clmdep_msgpack::object(a13, z); + + o->via.map.ptr[7].key = clmdep_msgpack::object(a14, z); + o->via.map.ptr[7].val = clmdep_msgpack::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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> { + define_map(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), 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 <typename Packer> + void msgpack_pack(Packer& pk) const + { + pk.pack_map(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); + 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(clmdep_msgpack::object const& o) const + { + if(o.type != clmdep_msgpack::type::MAP) { throw clmdep_msgpack::type_error(); } + std::map<std::string, clmdep_msgpack::object const*> kvmap; + for (uint32_t i = 0; i < o.via.map.size; ++i) { + kvmap.insert( + std::map<std::string, clmdep_msgpack::object const*>::value_type( + std::string( + o.via.map.ptr[i].key.via.str.ptr, + o.via.map.ptr[i].key.via.str.size), + &o.via.map.ptr[i].val + ) + ); + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a0); + if (it != kvmap.end()) { + it->second->convert(a1); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a2); + if (it != kvmap.end()) { + it->second->convert(a3); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a4); + if (it != kvmap.end()) { + it->second->convert(a5); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a6); + if (it != kvmap.end()) { + it->second->convert(a7); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a8); + if (it != kvmap.end()) { + it->second->convert(a9); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a10); + if (it != kvmap.end()) { + it->second->convert(a11); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a12); + if (it != kvmap.end()) { + it->second->convert(a13); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a14); + if (it != kvmap.end()) { + it->second->convert(a15); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a16); + if (it != kvmap.end()) { + it->second->convert(a17); + } + } + + } + void msgpack_object(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::MAP; + o->via.map.ptr = static_cast<clmdep_msgpack::object_kv*>(z.allocate_align(sizeof(clmdep_msgpack::object_kv)*9)); + o->via.map.size = 9; + + o->via.map.ptr[0].key = clmdep_msgpack::object(a0, z); + o->via.map.ptr[0].val = clmdep_msgpack::object(a1, z); + + o->via.map.ptr[1].key = clmdep_msgpack::object(a2, z); + o->via.map.ptr[1].val = clmdep_msgpack::object(a3, z); + + o->via.map.ptr[2].key = clmdep_msgpack::object(a4, z); + o->via.map.ptr[2].val = clmdep_msgpack::object(a5, z); + + o->via.map.ptr[3].key = clmdep_msgpack::object(a6, z); + o->via.map.ptr[3].val = clmdep_msgpack::object(a7, z); + + o->via.map.ptr[4].key = clmdep_msgpack::object(a8, z); + o->via.map.ptr[4].val = clmdep_msgpack::object(a9, z); + + o->via.map.ptr[5].key = clmdep_msgpack::object(a10, z); + o->via.map.ptr[5].val = clmdep_msgpack::object(a11, z); + + o->via.map.ptr[6].key = clmdep_msgpack::object(a12, z); + o->via.map.ptr[6].val = clmdep_msgpack::object(a13, z); + + o->via.map.ptr[7].key = clmdep_msgpack::object(a14, z); + o->via.map.ptr[7].val = clmdep_msgpack::object(a15, z); + + o->via.map.ptr[8].key = clmdep_msgpack::object(a16, z); + o->via.map.ptr[8].val = clmdep_msgpack::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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> { + define_map(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), 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 <typename Packer> + void msgpack_pack(Packer& pk) const + { + pk.pack_map(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); + 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(clmdep_msgpack::object const& o) const + { + if(o.type != clmdep_msgpack::type::MAP) { throw clmdep_msgpack::type_error(); } + std::map<std::string, clmdep_msgpack::object const*> kvmap; + for (uint32_t i = 0; i < o.via.map.size; ++i) { + kvmap.insert( + std::map<std::string, clmdep_msgpack::object const*>::value_type( + std::string( + o.via.map.ptr[i].key.via.str.ptr, + o.via.map.ptr[i].key.via.str.size), + &o.via.map.ptr[i].val + ) + ); + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a0); + if (it != kvmap.end()) { + it->second->convert(a1); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a2); + if (it != kvmap.end()) { + it->second->convert(a3); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a4); + if (it != kvmap.end()) { + it->second->convert(a5); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a6); + if (it != kvmap.end()) { + it->second->convert(a7); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a8); + if (it != kvmap.end()) { + it->second->convert(a9); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a10); + if (it != kvmap.end()) { + it->second->convert(a11); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a12); + if (it != kvmap.end()) { + it->second->convert(a13); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a14); + if (it != kvmap.end()) { + it->second->convert(a15); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a16); + if (it != kvmap.end()) { + it->second->convert(a17); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a18); + if (it != kvmap.end()) { + it->second->convert(a19); + } + } + + } + void msgpack_object(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::MAP; + o->via.map.ptr = static_cast<clmdep_msgpack::object_kv*>(z.allocate_align(sizeof(clmdep_msgpack::object_kv)*10)); + o->via.map.size = 10; + + o->via.map.ptr[0].key = clmdep_msgpack::object(a0, z); + o->via.map.ptr[0].val = clmdep_msgpack::object(a1, z); + + o->via.map.ptr[1].key = clmdep_msgpack::object(a2, z); + o->via.map.ptr[1].val = clmdep_msgpack::object(a3, z); + + o->via.map.ptr[2].key = clmdep_msgpack::object(a4, z); + o->via.map.ptr[2].val = clmdep_msgpack::object(a5, z); + + o->via.map.ptr[3].key = clmdep_msgpack::object(a6, z); + o->via.map.ptr[3].val = clmdep_msgpack::object(a7, z); + + o->via.map.ptr[4].key = clmdep_msgpack::object(a8, z); + o->via.map.ptr[4].val = clmdep_msgpack::object(a9, z); + + o->via.map.ptr[5].key = clmdep_msgpack::object(a10, z); + o->via.map.ptr[5].val = clmdep_msgpack::object(a11, z); + + o->via.map.ptr[6].key = clmdep_msgpack::object(a12, z); + o->via.map.ptr[6].val = clmdep_msgpack::object(a13, z); + + o->via.map.ptr[7].key = clmdep_msgpack::object(a14, z); + o->via.map.ptr[7].val = clmdep_msgpack::object(a15, z); + + o->via.map.ptr[8].key = clmdep_msgpack::object(a16, z); + o->via.map.ptr[8].val = clmdep_msgpack::object(a17, z); + + o->via.map.ptr[9].key = clmdep_msgpack::object(a18, z); + o->via.map.ptr[9].val = clmdep_msgpack::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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> { + define_map(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), 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 <typename Packer> + void msgpack_pack(Packer& pk) const + { + pk.pack_map(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); + 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(clmdep_msgpack::object const& o) const + { + if(o.type != clmdep_msgpack::type::MAP) { throw clmdep_msgpack::type_error(); } + std::map<std::string, clmdep_msgpack::object const*> kvmap; + for (uint32_t i = 0; i < o.via.map.size; ++i) { + kvmap.insert( + std::map<std::string, clmdep_msgpack::object const*>::value_type( + std::string( + o.via.map.ptr[i].key.via.str.ptr, + o.via.map.ptr[i].key.via.str.size), + &o.via.map.ptr[i].val + ) + ); + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a0); + if (it != kvmap.end()) { + it->second->convert(a1); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a2); + if (it != kvmap.end()) { + it->second->convert(a3); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a4); + if (it != kvmap.end()) { + it->second->convert(a5); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a6); + if (it != kvmap.end()) { + it->second->convert(a7); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a8); + if (it != kvmap.end()) { + it->second->convert(a9); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a10); + if (it != kvmap.end()) { + it->second->convert(a11); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a12); + if (it != kvmap.end()) { + it->second->convert(a13); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a14); + if (it != kvmap.end()) { + it->second->convert(a15); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a16); + if (it != kvmap.end()) { + it->second->convert(a17); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a18); + if (it != kvmap.end()) { + it->second->convert(a19); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a20); + if (it != kvmap.end()) { + it->second->convert(a21); + } + } + + } + void msgpack_object(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::MAP; + o->via.map.ptr = static_cast<clmdep_msgpack::object_kv*>(z.allocate_align(sizeof(clmdep_msgpack::object_kv)*11)); + o->via.map.size = 11; + + o->via.map.ptr[0].key = clmdep_msgpack::object(a0, z); + o->via.map.ptr[0].val = clmdep_msgpack::object(a1, z); + + o->via.map.ptr[1].key = clmdep_msgpack::object(a2, z); + o->via.map.ptr[1].val = clmdep_msgpack::object(a3, z); + + o->via.map.ptr[2].key = clmdep_msgpack::object(a4, z); + o->via.map.ptr[2].val = clmdep_msgpack::object(a5, z); + + o->via.map.ptr[3].key = clmdep_msgpack::object(a6, z); + o->via.map.ptr[3].val = clmdep_msgpack::object(a7, z); + + o->via.map.ptr[4].key = clmdep_msgpack::object(a8, z); + o->via.map.ptr[4].val = clmdep_msgpack::object(a9, z); + + o->via.map.ptr[5].key = clmdep_msgpack::object(a10, z); + o->via.map.ptr[5].val = clmdep_msgpack::object(a11, z); + + o->via.map.ptr[6].key = clmdep_msgpack::object(a12, z); + o->via.map.ptr[6].val = clmdep_msgpack::object(a13, z); + + o->via.map.ptr[7].key = clmdep_msgpack::object(a14, z); + o->via.map.ptr[7].val = clmdep_msgpack::object(a15, z); + + o->via.map.ptr[8].key = clmdep_msgpack::object(a16, z); + o->via.map.ptr[8].val = clmdep_msgpack::object(a17, z); + + o->via.map.ptr[9].key = clmdep_msgpack::object(a18, z); + o->via.map.ptr[9].val = clmdep_msgpack::object(a19, z); + + o->via.map.ptr[10].key = clmdep_msgpack::object(a20, z); + o->via.map.ptr[10].val = clmdep_msgpack::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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23> { + define_map(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), 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 <typename Packer> + void msgpack_pack(Packer& pk) const + { + pk.pack_map(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); + 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(clmdep_msgpack::object const& o) const + { + if(o.type != clmdep_msgpack::type::MAP) { throw clmdep_msgpack::type_error(); } + std::map<std::string, clmdep_msgpack::object const*> kvmap; + for (uint32_t i = 0; i < o.via.map.size; ++i) { + kvmap.insert( + std::map<std::string, clmdep_msgpack::object const*>::value_type( + std::string( + o.via.map.ptr[i].key.via.str.ptr, + o.via.map.ptr[i].key.via.str.size), + &o.via.map.ptr[i].val + ) + ); + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a0); + if (it != kvmap.end()) { + it->second->convert(a1); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a2); + if (it != kvmap.end()) { + it->second->convert(a3); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a4); + if (it != kvmap.end()) { + it->second->convert(a5); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a6); + if (it != kvmap.end()) { + it->second->convert(a7); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a8); + if (it != kvmap.end()) { + it->second->convert(a9); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a10); + if (it != kvmap.end()) { + it->second->convert(a11); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a12); + if (it != kvmap.end()) { + it->second->convert(a13); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a14); + if (it != kvmap.end()) { + it->second->convert(a15); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a16); + if (it != kvmap.end()) { + it->second->convert(a17); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a18); + if (it != kvmap.end()) { + it->second->convert(a19); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a20); + if (it != kvmap.end()) { + it->second->convert(a21); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a22); + if (it != kvmap.end()) { + it->second->convert(a23); + } + } + + } + void msgpack_object(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::MAP; + o->via.map.ptr = static_cast<clmdep_msgpack::object_kv*>(z.allocate_align(sizeof(clmdep_msgpack::object_kv)*12)); + o->via.map.size = 12; + + o->via.map.ptr[0].key = clmdep_msgpack::object(a0, z); + o->via.map.ptr[0].val = clmdep_msgpack::object(a1, z); + + o->via.map.ptr[1].key = clmdep_msgpack::object(a2, z); + o->via.map.ptr[1].val = clmdep_msgpack::object(a3, z); + + o->via.map.ptr[2].key = clmdep_msgpack::object(a4, z); + o->via.map.ptr[2].val = clmdep_msgpack::object(a5, z); + + o->via.map.ptr[3].key = clmdep_msgpack::object(a6, z); + o->via.map.ptr[3].val = clmdep_msgpack::object(a7, z); + + o->via.map.ptr[4].key = clmdep_msgpack::object(a8, z); + o->via.map.ptr[4].val = clmdep_msgpack::object(a9, z); + + o->via.map.ptr[5].key = clmdep_msgpack::object(a10, z); + o->via.map.ptr[5].val = clmdep_msgpack::object(a11, z); + + o->via.map.ptr[6].key = clmdep_msgpack::object(a12, z); + o->via.map.ptr[6].val = clmdep_msgpack::object(a13, z); + + o->via.map.ptr[7].key = clmdep_msgpack::object(a14, z); + o->via.map.ptr[7].val = clmdep_msgpack::object(a15, z); + + o->via.map.ptr[8].key = clmdep_msgpack::object(a16, z); + o->via.map.ptr[8].val = clmdep_msgpack::object(a17, z); + + o->via.map.ptr[9].key = clmdep_msgpack::object(a18, z); + o->via.map.ptr[9].val = clmdep_msgpack::object(a19, z); + + o->via.map.ptr[10].key = clmdep_msgpack::object(a20, z); + o->via.map.ptr[10].val = clmdep_msgpack::object(a21, z); + + o->via.map.ptr[11].key = clmdep_msgpack::object(a22, z); + o->via.map.ptr[11].val = clmdep_msgpack::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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25> { + define_map(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), 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 <typename Packer> + void msgpack_pack(Packer& pk) const + { + pk.pack_map(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); + 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(clmdep_msgpack::object const& o) const + { + if(o.type != clmdep_msgpack::type::MAP) { throw clmdep_msgpack::type_error(); } + std::map<std::string, clmdep_msgpack::object const*> kvmap; + for (uint32_t i = 0; i < o.via.map.size; ++i) { + kvmap.insert( + std::map<std::string, clmdep_msgpack::object const*>::value_type( + std::string( + o.via.map.ptr[i].key.via.str.ptr, + o.via.map.ptr[i].key.via.str.size), + &o.via.map.ptr[i].val + ) + ); + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a0); + if (it != kvmap.end()) { + it->second->convert(a1); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a2); + if (it != kvmap.end()) { + it->second->convert(a3); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a4); + if (it != kvmap.end()) { + it->second->convert(a5); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a6); + if (it != kvmap.end()) { + it->second->convert(a7); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a8); + if (it != kvmap.end()) { + it->second->convert(a9); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a10); + if (it != kvmap.end()) { + it->second->convert(a11); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a12); + if (it != kvmap.end()) { + it->second->convert(a13); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a14); + if (it != kvmap.end()) { + it->second->convert(a15); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a16); + if (it != kvmap.end()) { + it->second->convert(a17); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a18); + if (it != kvmap.end()) { + it->second->convert(a19); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a20); + if (it != kvmap.end()) { + it->second->convert(a21); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a22); + if (it != kvmap.end()) { + it->second->convert(a23); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a24); + if (it != kvmap.end()) { + it->second->convert(a25); + } + } + + } + void msgpack_object(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::MAP; + o->via.map.ptr = static_cast<clmdep_msgpack::object_kv*>(z.allocate_align(sizeof(clmdep_msgpack::object_kv)*13)); + o->via.map.size = 13; + + o->via.map.ptr[0].key = clmdep_msgpack::object(a0, z); + o->via.map.ptr[0].val = clmdep_msgpack::object(a1, z); + + o->via.map.ptr[1].key = clmdep_msgpack::object(a2, z); + o->via.map.ptr[1].val = clmdep_msgpack::object(a3, z); + + o->via.map.ptr[2].key = clmdep_msgpack::object(a4, z); + o->via.map.ptr[2].val = clmdep_msgpack::object(a5, z); + + o->via.map.ptr[3].key = clmdep_msgpack::object(a6, z); + o->via.map.ptr[3].val = clmdep_msgpack::object(a7, z); + + o->via.map.ptr[4].key = clmdep_msgpack::object(a8, z); + o->via.map.ptr[4].val = clmdep_msgpack::object(a9, z); + + o->via.map.ptr[5].key = clmdep_msgpack::object(a10, z); + o->via.map.ptr[5].val = clmdep_msgpack::object(a11, z); + + o->via.map.ptr[6].key = clmdep_msgpack::object(a12, z); + o->via.map.ptr[6].val = clmdep_msgpack::object(a13, z); + + o->via.map.ptr[7].key = clmdep_msgpack::object(a14, z); + o->via.map.ptr[7].val = clmdep_msgpack::object(a15, z); + + o->via.map.ptr[8].key = clmdep_msgpack::object(a16, z); + o->via.map.ptr[8].val = clmdep_msgpack::object(a17, z); + + o->via.map.ptr[9].key = clmdep_msgpack::object(a18, z); + o->via.map.ptr[9].val = clmdep_msgpack::object(a19, z); + + o->via.map.ptr[10].key = clmdep_msgpack::object(a20, z); + o->via.map.ptr[10].val = clmdep_msgpack::object(a21, z); + + o->via.map.ptr[11].key = clmdep_msgpack::object(a22, z); + o->via.map.ptr[11].val = clmdep_msgpack::object(a23, z); + + o->via.map.ptr[12].key = clmdep_msgpack::object(a24, z); + o->via.map.ptr[12].val = clmdep_msgpack::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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27> { + define_map(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), 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 <typename Packer> + void msgpack_pack(Packer& pk) const + { + pk.pack_map(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); + 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(clmdep_msgpack::object const& o) const + { + if(o.type != clmdep_msgpack::type::MAP) { throw clmdep_msgpack::type_error(); } + std::map<std::string, clmdep_msgpack::object const*> kvmap; + for (uint32_t i = 0; i < o.via.map.size; ++i) { + kvmap.insert( + std::map<std::string, clmdep_msgpack::object const*>::value_type( + std::string( + o.via.map.ptr[i].key.via.str.ptr, + o.via.map.ptr[i].key.via.str.size), + &o.via.map.ptr[i].val + ) + ); + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a0); + if (it != kvmap.end()) { + it->second->convert(a1); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a2); + if (it != kvmap.end()) { + it->second->convert(a3); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a4); + if (it != kvmap.end()) { + it->second->convert(a5); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a6); + if (it != kvmap.end()) { + it->second->convert(a7); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a8); + if (it != kvmap.end()) { + it->second->convert(a9); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a10); + if (it != kvmap.end()) { + it->second->convert(a11); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a12); + if (it != kvmap.end()) { + it->second->convert(a13); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a14); + if (it != kvmap.end()) { + it->second->convert(a15); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a16); + if (it != kvmap.end()) { + it->second->convert(a17); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a18); + if (it != kvmap.end()) { + it->second->convert(a19); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a20); + if (it != kvmap.end()) { + it->second->convert(a21); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a22); + if (it != kvmap.end()) { + it->second->convert(a23); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a24); + if (it != kvmap.end()) { + it->second->convert(a25); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a26); + if (it != kvmap.end()) { + it->second->convert(a27); + } + } + + } + void msgpack_object(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::MAP; + o->via.map.ptr = static_cast<clmdep_msgpack::object_kv*>(z.allocate_align(sizeof(clmdep_msgpack::object_kv)*14)); + o->via.map.size = 14; + + o->via.map.ptr[0].key = clmdep_msgpack::object(a0, z); + o->via.map.ptr[0].val = clmdep_msgpack::object(a1, z); + + o->via.map.ptr[1].key = clmdep_msgpack::object(a2, z); + o->via.map.ptr[1].val = clmdep_msgpack::object(a3, z); + + o->via.map.ptr[2].key = clmdep_msgpack::object(a4, z); + o->via.map.ptr[2].val = clmdep_msgpack::object(a5, z); + + o->via.map.ptr[3].key = clmdep_msgpack::object(a6, z); + o->via.map.ptr[3].val = clmdep_msgpack::object(a7, z); + + o->via.map.ptr[4].key = clmdep_msgpack::object(a8, z); + o->via.map.ptr[4].val = clmdep_msgpack::object(a9, z); + + o->via.map.ptr[5].key = clmdep_msgpack::object(a10, z); + o->via.map.ptr[5].val = clmdep_msgpack::object(a11, z); + + o->via.map.ptr[6].key = clmdep_msgpack::object(a12, z); + o->via.map.ptr[6].val = clmdep_msgpack::object(a13, z); + + o->via.map.ptr[7].key = clmdep_msgpack::object(a14, z); + o->via.map.ptr[7].val = clmdep_msgpack::object(a15, z); + + o->via.map.ptr[8].key = clmdep_msgpack::object(a16, z); + o->via.map.ptr[8].val = clmdep_msgpack::object(a17, z); + + o->via.map.ptr[9].key = clmdep_msgpack::object(a18, z); + o->via.map.ptr[9].val = clmdep_msgpack::object(a19, z); + + o->via.map.ptr[10].key = clmdep_msgpack::object(a20, z); + o->via.map.ptr[10].val = clmdep_msgpack::object(a21, z); + + o->via.map.ptr[11].key = clmdep_msgpack::object(a22, z); + o->via.map.ptr[11].val = clmdep_msgpack::object(a23, z); + + o->via.map.ptr[12].key = clmdep_msgpack::object(a24, z); + o->via.map.ptr[12].val = clmdep_msgpack::object(a25, z); + + o->via.map.ptr[13].key = clmdep_msgpack::object(a26, z); + o->via.map.ptr[13].val = clmdep_msgpack::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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29> { + define_map(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27, A28& _a28, A29& _a29) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), 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 <typename Packer> + void msgpack_pack(Packer& pk) const + { + pk.pack_map(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); + 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(clmdep_msgpack::object const& o) const + { + if(o.type != clmdep_msgpack::type::MAP) { throw clmdep_msgpack::type_error(); } + std::map<std::string, clmdep_msgpack::object const*> kvmap; + for (uint32_t i = 0; i < o.via.map.size; ++i) { + kvmap.insert( + std::map<std::string, clmdep_msgpack::object const*>::value_type( + std::string( + o.via.map.ptr[i].key.via.str.ptr, + o.via.map.ptr[i].key.via.str.size), + &o.via.map.ptr[i].val + ) + ); + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a0); + if (it != kvmap.end()) { + it->second->convert(a1); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a2); + if (it != kvmap.end()) { + it->second->convert(a3); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a4); + if (it != kvmap.end()) { + it->second->convert(a5); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a6); + if (it != kvmap.end()) { + it->second->convert(a7); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a8); + if (it != kvmap.end()) { + it->second->convert(a9); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a10); + if (it != kvmap.end()) { + it->second->convert(a11); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a12); + if (it != kvmap.end()) { + it->second->convert(a13); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a14); + if (it != kvmap.end()) { + it->second->convert(a15); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a16); + if (it != kvmap.end()) { + it->second->convert(a17); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a18); + if (it != kvmap.end()) { + it->second->convert(a19); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a20); + if (it != kvmap.end()) { + it->second->convert(a21); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a22); + if (it != kvmap.end()) { + it->second->convert(a23); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a24); + if (it != kvmap.end()) { + it->second->convert(a25); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a26); + if (it != kvmap.end()) { + it->second->convert(a27); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a28); + if (it != kvmap.end()) { + it->second->convert(a29); + } + } + + } + void msgpack_object(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::MAP; + o->via.map.ptr = static_cast<clmdep_msgpack::object_kv*>(z.allocate_align(sizeof(clmdep_msgpack::object_kv)*15)); + o->via.map.size = 15; + + o->via.map.ptr[0].key = clmdep_msgpack::object(a0, z); + o->via.map.ptr[0].val = clmdep_msgpack::object(a1, z); + + o->via.map.ptr[1].key = clmdep_msgpack::object(a2, z); + o->via.map.ptr[1].val = clmdep_msgpack::object(a3, z); + + o->via.map.ptr[2].key = clmdep_msgpack::object(a4, z); + o->via.map.ptr[2].val = clmdep_msgpack::object(a5, z); + + o->via.map.ptr[3].key = clmdep_msgpack::object(a6, z); + o->via.map.ptr[3].val = clmdep_msgpack::object(a7, z); + + o->via.map.ptr[4].key = clmdep_msgpack::object(a8, z); + o->via.map.ptr[4].val = clmdep_msgpack::object(a9, z); + + o->via.map.ptr[5].key = clmdep_msgpack::object(a10, z); + o->via.map.ptr[5].val = clmdep_msgpack::object(a11, z); + + o->via.map.ptr[6].key = clmdep_msgpack::object(a12, z); + o->via.map.ptr[6].val = clmdep_msgpack::object(a13, z); + + o->via.map.ptr[7].key = clmdep_msgpack::object(a14, z); + o->via.map.ptr[7].val = clmdep_msgpack::object(a15, z); + + o->via.map.ptr[8].key = clmdep_msgpack::object(a16, z); + o->via.map.ptr[8].val = clmdep_msgpack::object(a17, z); + + o->via.map.ptr[9].key = clmdep_msgpack::object(a18, z); + o->via.map.ptr[9].val = clmdep_msgpack::object(a19, z); + + o->via.map.ptr[10].key = clmdep_msgpack::object(a20, z); + o->via.map.ptr[10].val = clmdep_msgpack::object(a21, z); + + o->via.map.ptr[11].key = clmdep_msgpack::object(a22, z); + o->via.map.ptr[11].val = clmdep_msgpack::object(a23, z); + + o->via.map.ptr[12].key = clmdep_msgpack::object(a24, z); + o->via.map.ptr[12].val = clmdep_msgpack::object(a25, z); + + o->via.map.ptr[13].key = clmdep_msgpack::object(a26, z); + o->via.map.ptr[13].val = clmdep_msgpack::object(a27, z); + + o->via.map.ptr[14].key = clmdep_msgpack::object(a28, z); + o->via.map.ptr[14].val = clmdep_msgpack::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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31> { + define_map(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27, A28& _a28, A29& _a29, A30& _a30, A31& _a31) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), 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 <typename Packer> + void msgpack_pack(Packer& pk) const + { + pk.pack_map(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); + 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(clmdep_msgpack::object const& o) const + { + if(o.type != clmdep_msgpack::type::MAP) { throw clmdep_msgpack::type_error(); } + std::map<std::string, clmdep_msgpack::object const*> kvmap; + for (uint32_t i = 0; i < o.via.map.size; ++i) { + kvmap.insert( + std::map<std::string, clmdep_msgpack::object const*>::value_type( + std::string( + o.via.map.ptr[i].key.via.str.ptr, + o.via.map.ptr[i].key.via.str.size), + &o.via.map.ptr[i].val + ) + ); + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a0); + if (it != kvmap.end()) { + it->second->convert(a1); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a2); + if (it != kvmap.end()) { + it->second->convert(a3); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a4); + if (it != kvmap.end()) { + it->second->convert(a5); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a6); + if (it != kvmap.end()) { + it->second->convert(a7); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a8); + if (it != kvmap.end()) { + it->second->convert(a9); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a10); + if (it != kvmap.end()) { + it->second->convert(a11); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a12); + if (it != kvmap.end()) { + it->second->convert(a13); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a14); + if (it != kvmap.end()) { + it->second->convert(a15); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a16); + if (it != kvmap.end()) { + it->second->convert(a17); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a18); + if (it != kvmap.end()) { + it->second->convert(a19); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a20); + if (it != kvmap.end()) { + it->second->convert(a21); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a22); + if (it != kvmap.end()) { + it->second->convert(a23); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a24); + if (it != kvmap.end()) { + it->second->convert(a25); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a26); + if (it != kvmap.end()) { + it->second->convert(a27); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a28); + if (it != kvmap.end()) { + it->second->convert(a29); + } + } + + { + std::map<std::string, clmdep_msgpack::object const*>::const_iterator it = kvmap.find(a30); + if (it != kvmap.end()) { + it->second->convert(a31); + } + } + + } + void msgpack_object(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::MAP; + o->via.map.ptr = static_cast<clmdep_msgpack::object_kv*>(z.allocate_align(sizeof(clmdep_msgpack::object_kv)*16)); + o->via.map.size = 16; + + o->via.map.ptr[0].key = clmdep_msgpack::object(a0, z); + o->via.map.ptr[0].val = clmdep_msgpack::object(a1, z); + + o->via.map.ptr[1].key = clmdep_msgpack::object(a2, z); + o->via.map.ptr[1].val = clmdep_msgpack::object(a3, z); + + o->via.map.ptr[2].key = clmdep_msgpack::object(a4, z); + o->via.map.ptr[2].val = clmdep_msgpack::object(a5, z); + + o->via.map.ptr[3].key = clmdep_msgpack::object(a6, z); + o->via.map.ptr[3].val = clmdep_msgpack::object(a7, z); + + o->via.map.ptr[4].key = clmdep_msgpack::object(a8, z); + o->via.map.ptr[4].val = clmdep_msgpack::object(a9, z); + + o->via.map.ptr[5].key = clmdep_msgpack::object(a10, z); + o->via.map.ptr[5].val = clmdep_msgpack::object(a11, z); + + o->via.map.ptr[6].key = clmdep_msgpack::object(a12, z); + o->via.map.ptr[6].val = clmdep_msgpack::object(a13, z); + + o->via.map.ptr[7].key = clmdep_msgpack::object(a14, z); + o->via.map.ptr[7].val = clmdep_msgpack::object(a15, z); + + o->via.map.ptr[8].key = clmdep_msgpack::object(a16, z); + o->via.map.ptr[8].val = clmdep_msgpack::object(a17, z); + + o->via.map.ptr[9].key = clmdep_msgpack::object(a18, z); + o->via.map.ptr[9].val = clmdep_msgpack::object(a19, z); + + o->via.map.ptr[10].key = clmdep_msgpack::object(a20, z); + o->via.map.ptr[10].val = clmdep_msgpack::object(a21, z); + + o->via.map.ptr[11].key = clmdep_msgpack::object(a22, z); + o->via.map.ptr[11].val = clmdep_msgpack::object(a23, z); + + o->via.map.ptr[12].key = clmdep_msgpack::object(a24, z); + o->via.map.ptr[12].val = clmdep_msgpack::object(a25, z); + + o->via.map.ptr[13].key = clmdep_msgpack::object(a26, z); + o->via.map.ptr[13].val = clmdep_msgpack::object(a27, z); + + o->via.map.ptr[14].key = clmdep_msgpack::object(a28, z); + o->via.map.ptr[14].val = clmdep_msgpack::object(a29, z); + + o->via.map.ptr[15].key = clmdep_msgpack::object(a30, z); + o->via.map.ptr[15].val = clmdep_msgpack::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; +}; + +/// @endcond + +inline define_map<> make_define_map() +{ + return define_map<>(); +} + +/// @cond + +template <typename A0> +inline define_map<A0> make_define_map(A0& a0) +{ + return define_map<A0>(a0); +} + +template <typename A0, typename A1> +inline define_map<A0, A1> make_define_map(A0& a0, A1& a1) +{ + return define_map<A0, A1>(a0, a1); +} + +template <typename A0, typename A1, typename A2> +inline define_map<A0, A1, A2> make_define_map(A0& a0, A1& a1, A2& a2) +{ + return define_map<A0, A1, A2>(a0, a1, a2); +} + +template <typename A0, typename A1, typename A2, typename A3> +inline define_map<A0, A1, A2, A3> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3) +{ + return define_map<A0, A1, A2, A3>(a0, a1, a2, a3); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4> +inline define_map<A0, A1, A2, A3, A4> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4) +{ + return define_map<A0, A1, A2, A3, A4>(a0, a1, a2, a3, a4); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5> +inline define_map<A0, A1, A2, A3, A4, A5> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) +{ + return define_map<A0, A1, A2, A3, A4, A5>(a0, a1, a2, a3, a4, a5); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6> +inline define_map<A0, A1, A2, A3, A4, A5, A6> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) +{ + return define_map<A0, A1, A2, A3, A4, A5, A6>(a0, a1, a2, a3, a4, a5, a6); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> +inline define_map<A0, A1, A2, A3, A4, A5, A6, A7> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) +{ + return define_map<A0, A1, A2, A3, A4, A5, A6, A7>(a0, a1, a2, a3, a4, a5, a6, a7); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> +inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) +{ + return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8>(a0, a1, a2, a3, a4, a5, a6, a7, a8); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> +inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) +{ + return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10) +{ + return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11) +{ + return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12) +{ + return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13) +{ + return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14) +{ + return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15) +{ + return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16) +{ + return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17) +{ + return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18) +{ + return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19) +{ + return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20) +{ + return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21) +{ + return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22) +{ + return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23) +{ + return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24) +{ + return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25) +{ + return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26) +{ + return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27) +{ + return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28) +{ + return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28, A29& a29) +{ + return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28, A29& a29, A30& a30) +{ + return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28, A29& a29, A30& a30, A31& a31) +{ + return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31); +} + +/// @endcond + +} // namespace type +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond +} // namespace clmdep_msgpack + +#endif // MSGPACK_CPP03_DEFINE_MAP_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp new file mode 100644 index 000000000..0ec6d4f3c --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp @@ -0,0 +1,13917 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_CPP03_MSGPACK_TUPLE_HPP +#define MSGPACK_CPP03_MSGPACK_TUPLE_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/object.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace type { + +// FIXME operator== +// FIXME operator!= + + +/// @cond +template <typename A0 = void, typename A1 = void, typename A2 = void, typename A3 = void, typename A4 = void, typename A5 = void, typename A6 = void, typename A7 = void, typename A8 = void, typename A9 = void, typename A10 = void, typename A11 = void, typename A12 = void, typename A13 = void, typename A14 = void, typename A15 = void, typename A16 = void, typename A17 = void, typename A18 = void, typename A19 = void, typename A20 = void, typename A21 = void, typename A22 = void, typename A23 = void, typename A24 = void, typename A25 = void, typename A26 = void, typename A27 = void, typename A28 = void, typename A29 = void, typename A30 = void, typename A31 = void, typename A32 = void> +struct tuple; +/// @endcond + +template <typename Tuple, int N> +struct tuple_element; + +template <typename Tuple, int N> +struct const_tuple_element; + +template <typename T> +struct tuple_type { + typedef T type; + typedef T value_type; + typedef T& reference; + typedef const T& const_reference; + typedef const T& transparent_reference; +}; + +template <typename T> +struct tuple_type<T&> { + typedef T type; + typedef T& value_type; + typedef T& reference; + typedef const T& const_reference; + typedef T& transparent_reference; +}; + +template <typename T> +struct tuple_type<const T&> { + typedef T type; + typedef T& value_type; + typedef T& reference; + typedef const T& const_reference; + typedef const T& transparent_reference; +}; + +/// @cond + + +template <typename A0> +struct tuple_element<tuple<A0>, 0> : tuple_type<A0> { + tuple_element(tuple<A0>& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + + + +template <typename A0, typename A1> +struct tuple_element<tuple<A0, A1>, 0> : tuple_type<A0> { + tuple_element(tuple<A0, A1 >& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + +template <typename A0, typename A1> +struct tuple_element<tuple<A0, A1>, 1> : tuple_type<A1> { + tuple_element(tuple<A0, A1 >& x) : m_x(x.a1) {} + typename tuple_type<A1>::reference get() { return m_x; } + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::reference m_x; +}; + + + +template <typename A0, typename A1, typename A2> +struct tuple_element<tuple<A0, A1, A2>, 0> : tuple_type<A0> { + tuple_element(tuple<A0, A1 , A2 >& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + +template <typename A0, typename A1, typename A2> +struct tuple_element<tuple<A0, A1, A2>, 1> : tuple_type<A1> { + tuple_element(tuple<A0, A1 , A2 >& x) : m_x(x.a1) {} + typename tuple_type<A1>::reference get() { return m_x; } + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::reference m_x; +}; + +template <typename A0, typename A1, typename A2> +struct tuple_element<tuple<A0, A1, A2>, 2> : tuple_type<A2> { + tuple_element(tuple<A0, A1 , A2 >& x) : m_x(x.a2) {} + typename tuple_type<A2>::reference get() { return m_x; } + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3> +struct tuple_element<tuple<A0, A1, A2, A3>, 0> : tuple_type<A0> { + tuple_element(tuple<A0, A1 , A2 , A3 >& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3> +struct tuple_element<tuple<A0, A1, A2, A3>, 1> : tuple_type<A1> { + tuple_element(tuple<A0, A1 , A2 , A3 >& x) : m_x(x.a1) {} + typename tuple_type<A1>::reference get() { return m_x; } + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3> +struct tuple_element<tuple<A0, A1, A2, A3>, 2> : tuple_type<A2> { + tuple_element(tuple<A0, A1 , A2 , A3 >& x) : m_x(x.a2) {} + typename tuple_type<A2>::reference get() { return m_x; } + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3> +struct tuple_element<tuple<A0, A1, A2, A3>, 3> : tuple_type<A3> { + tuple_element(tuple<A0, A1 , A2 , A3 >& x) : m_x(x.a3) {} + typename tuple_type<A3>::reference get() { return m_x; } + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4> +struct tuple_element<tuple<A0, A1, A2, A3, A4>, 0> : tuple_type<A0> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 >& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4> +struct tuple_element<tuple<A0, A1, A2, A3, A4>, 1> : tuple_type<A1> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 >& x) : m_x(x.a1) {} + typename tuple_type<A1>::reference get() { return m_x; } + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4> +struct tuple_element<tuple<A0, A1, A2, A3, A4>, 2> : tuple_type<A2> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 >& x) : m_x(x.a2) {} + typename tuple_type<A2>::reference get() { return m_x; } + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4> +struct tuple_element<tuple<A0, A1, A2, A3, A4>, 3> : tuple_type<A3> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 >& x) : m_x(x.a3) {} + typename tuple_type<A3>::reference get() { return m_x; } + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4> +struct tuple_element<tuple<A0, A1, A2, A3, A4>, 4> : tuple_type<A4> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 >& x) : m_x(x.a4) {} + typename tuple_type<A4>::reference get() { return m_x; } + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5>, 0> : tuple_type<A0> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 >& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5>, 1> : tuple_type<A1> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 >& x) : m_x(x.a1) {} + typename tuple_type<A1>::reference get() { return m_x; } + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5>, 2> : tuple_type<A2> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 >& x) : m_x(x.a2) {} + typename tuple_type<A2>::reference get() { return m_x; } + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5>, 3> : tuple_type<A3> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 >& x) : m_x(x.a3) {} + typename tuple_type<A3>::reference get() { return m_x; } + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5>, 4> : tuple_type<A4> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 >& x) : m_x(x.a4) {} + typename tuple_type<A4>::reference get() { return m_x; } + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5>, 5> : tuple_type<A5> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 >& x) : m_x(x.a5) {} + typename tuple_type<A5>::reference get() { return m_x; } + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6>, 0> : tuple_type<A0> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 >& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6>, 1> : tuple_type<A1> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 >& x) : m_x(x.a1) {} + typename tuple_type<A1>::reference get() { return m_x; } + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6>, 2> : tuple_type<A2> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 >& x) : m_x(x.a2) {} + typename tuple_type<A2>::reference get() { return m_x; } + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6>, 3> : tuple_type<A3> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 >& x) : m_x(x.a3) {} + typename tuple_type<A3>::reference get() { return m_x; } + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6>, 4> : tuple_type<A4> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 >& x) : m_x(x.a4) {} + typename tuple_type<A4>::reference get() { return m_x; } + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6>, 5> : tuple_type<A5> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 >& x) : m_x(x.a5) {} + typename tuple_type<A5>::reference get() { return m_x; } + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6>, 6> : tuple_type<A6> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 >& x) : m_x(x.a6) {} + typename tuple_type<A6>::reference get() { return m_x; } + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7>, 0> : tuple_type<A0> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 >& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7>, 1> : tuple_type<A1> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 >& x) : m_x(x.a1) {} + typename tuple_type<A1>::reference get() { return m_x; } + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7>, 2> : tuple_type<A2> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 >& x) : m_x(x.a2) {} + typename tuple_type<A2>::reference get() { return m_x; } + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7>, 3> : tuple_type<A3> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 >& x) : m_x(x.a3) {} + typename tuple_type<A3>::reference get() { return m_x; } + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7>, 4> : tuple_type<A4> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 >& x) : m_x(x.a4) {} + typename tuple_type<A4>::reference get() { return m_x; } + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7>, 5> : tuple_type<A5> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 >& x) : m_x(x.a5) {} + typename tuple_type<A5>::reference get() { return m_x; } + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7>, 6> : tuple_type<A6> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 >& x) : m_x(x.a6) {} + typename tuple_type<A6>::reference get() { return m_x; } + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7>, 7> : tuple_type<A7> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 >& x) : m_x(x.a7) {} + typename tuple_type<A7>::reference get() { return m_x; } + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>, 0> : tuple_type<A0> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 >& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>, 1> : tuple_type<A1> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 >& x) : m_x(x.a1) {} + typename tuple_type<A1>::reference get() { return m_x; } + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>, 2> : tuple_type<A2> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 >& x) : m_x(x.a2) {} + typename tuple_type<A2>::reference get() { return m_x; } + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>, 3> : tuple_type<A3> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 >& x) : m_x(x.a3) {} + typename tuple_type<A3>::reference get() { return m_x; } + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>, 4> : tuple_type<A4> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 >& x) : m_x(x.a4) {} + typename tuple_type<A4>::reference get() { return m_x; } + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>, 5> : tuple_type<A5> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 >& x) : m_x(x.a5) {} + typename tuple_type<A5>::reference get() { return m_x; } + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>, 6> : tuple_type<A6> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 >& x) : m_x(x.a6) {} + typename tuple_type<A6>::reference get() { return m_x; } + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>, 7> : tuple_type<A7> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 >& x) : m_x(x.a7) {} + typename tuple_type<A7>::reference get() { return m_x; } + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>, 8> : tuple_type<A8> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 >& x) : m_x(x.a8) {} + typename tuple_type<A8>::reference get() { return m_x; } + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>, 0> : tuple_type<A0> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 >& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>, 1> : tuple_type<A1> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 >& x) : m_x(x.a1) {} + typename tuple_type<A1>::reference get() { return m_x; } + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>, 2> : tuple_type<A2> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 >& x) : m_x(x.a2) {} + typename tuple_type<A2>::reference get() { return m_x; } + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>, 3> : tuple_type<A3> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 >& x) : m_x(x.a3) {} + typename tuple_type<A3>::reference get() { return m_x; } + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>, 4> : tuple_type<A4> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 >& x) : m_x(x.a4) {} + typename tuple_type<A4>::reference get() { return m_x; } + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>, 5> : tuple_type<A5> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 >& x) : m_x(x.a5) {} + typename tuple_type<A5>::reference get() { return m_x; } + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>, 6> : tuple_type<A6> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 >& x) : m_x(x.a6) {} + typename tuple_type<A6>::reference get() { return m_x; } + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>, 7> : tuple_type<A7> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 >& x) : m_x(x.a7) {} + typename tuple_type<A7>::reference get() { return m_x; } + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>, 8> : tuple_type<A8> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 >& x) : m_x(x.a8) {} + typename tuple_type<A8>::reference get() { return m_x; } + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>, 9> : tuple_type<A9> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 >& x) : m_x(x.a9) {} + typename tuple_type<A9>::reference get() { return m_x; } + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>, 0> : tuple_type<A0> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 >& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>, 1> : tuple_type<A1> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 >& x) : m_x(x.a1) {} + typename tuple_type<A1>::reference get() { return m_x; } + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>, 2> : tuple_type<A2> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 >& x) : m_x(x.a2) {} + typename tuple_type<A2>::reference get() { return m_x; } + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>, 3> : tuple_type<A3> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 >& x) : m_x(x.a3) {} + typename tuple_type<A3>::reference get() { return m_x; } + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>, 4> : tuple_type<A4> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 >& x) : m_x(x.a4) {} + typename tuple_type<A4>::reference get() { return m_x; } + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>, 5> : tuple_type<A5> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 >& x) : m_x(x.a5) {} + typename tuple_type<A5>::reference get() { return m_x; } + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>, 6> : tuple_type<A6> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 >& x) : m_x(x.a6) {} + typename tuple_type<A6>::reference get() { return m_x; } + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>, 7> : tuple_type<A7> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 >& x) : m_x(x.a7) {} + typename tuple_type<A7>::reference get() { return m_x; } + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>, 8> : tuple_type<A8> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 >& x) : m_x(x.a8) {} + typename tuple_type<A8>::reference get() { return m_x; } + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>, 9> : tuple_type<A9> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 >& x) : m_x(x.a9) {} + typename tuple_type<A9>::reference get() { return m_x; } + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>, 10> : tuple_type<A10> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 >& x) : m_x(x.a10) {} + typename tuple_type<A10>::reference get() { return m_x; } + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>, 0> : tuple_type<A0> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 >& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>, 1> : tuple_type<A1> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 >& x) : m_x(x.a1) {} + typename tuple_type<A1>::reference get() { return m_x; } + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>, 2> : tuple_type<A2> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 >& x) : m_x(x.a2) {} + typename tuple_type<A2>::reference get() { return m_x; } + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>, 3> : tuple_type<A3> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 >& x) : m_x(x.a3) {} + typename tuple_type<A3>::reference get() { return m_x; } + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>, 4> : tuple_type<A4> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 >& x) : m_x(x.a4) {} + typename tuple_type<A4>::reference get() { return m_x; } + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>, 5> : tuple_type<A5> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 >& x) : m_x(x.a5) {} + typename tuple_type<A5>::reference get() { return m_x; } + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>, 6> : tuple_type<A6> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 >& x) : m_x(x.a6) {} + typename tuple_type<A6>::reference get() { return m_x; } + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>, 7> : tuple_type<A7> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 >& x) : m_x(x.a7) {} + typename tuple_type<A7>::reference get() { return m_x; } + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>, 8> : tuple_type<A8> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 >& x) : m_x(x.a8) {} + typename tuple_type<A8>::reference get() { return m_x; } + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>, 9> : tuple_type<A9> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 >& x) : m_x(x.a9) {} + typename tuple_type<A9>::reference get() { return m_x; } + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>, 10> : tuple_type<A10> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 >& x) : m_x(x.a10) {} + typename tuple_type<A10>::reference get() { return m_x; } + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>, 11> : tuple_type<A11> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 >& x) : m_x(x.a11) {} + typename tuple_type<A11>::reference get() { return m_x; } + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>, 0> : tuple_type<A0> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 >& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>, 1> : tuple_type<A1> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 >& x) : m_x(x.a1) {} + typename tuple_type<A1>::reference get() { return m_x; } + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>, 2> : tuple_type<A2> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 >& x) : m_x(x.a2) {} + typename tuple_type<A2>::reference get() { return m_x; } + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>, 3> : tuple_type<A3> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 >& x) : m_x(x.a3) {} + typename tuple_type<A3>::reference get() { return m_x; } + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>, 4> : tuple_type<A4> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 >& x) : m_x(x.a4) {} + typename tuple_type<A4>::reference get() { return m_x; } + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>, 5> : tuple_type<A5> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 >& x) : m_x(x.a5) {} + typename tuple_type<A5>::reference get() { return m_x; } + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>, 6> : tuple_type<A6> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 >& x) : m_x(x.a6) {} + typename tuple_type<A6>::reference get() { return m_x; } + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>, 7> : tuple_type<A7> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 >& x) : m_x(x.a7) {} + typename tuple_type<A7>::reference get() { return m_x; } + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>, 8> : tuple_type<A8> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 >& x) : m_x(x.a8) {} + typename tuple_type<A8>::reference get() { return m_x; } + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>, 9> : tuple_type<A9> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 >& x) : m_x(x.a9) {} + typename tuple_type<A9>::reference get() { return m_x; } + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>, 10> : tuple_type<A10> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 >& x) : m_x(x.a10) {} + typename tuple_type<A10>::reference get() { return m_x; } + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>, 11> : tuple_type<A11> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 >& x) : m_x(x.a11) {} + typename tuple_type<A11>::reference get() { return m_x; } + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>, 12> : tuple_type<A12> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 >& x) : m_x(x.a12) {} + typename tuple_type<A12>::reference get() { return m_x; } + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>, 0> : tuple_type<A0> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 >& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>, 1> : tuple_type<A1> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 >& x) : m_x(x.a1) {} + typename tuple_type<A1>::reference get() { return m_x; } + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>, 2> : tuple_type<A2> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 >& x) : m_x(x.a2) {} + typename tuple_type<A2>::reference get() { return m_x; } + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>, 3> : tuple_type<A3> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 >& x) : m_x(x.a3) {} + typename tuple_type<A3>::reference get() { return m_x; } + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>, 4> : tuple_type<A4> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 >& x) : m_x(x.a4) {} + typename tuple_type<A4>::reference get() { return m_x; } + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>, 5> : tuple_type<A5> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 >& x) : m_x(x.a5) {} + typename tuple_type<A5>::reference get() { return m_x; } + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>, 6> : tuple_type<A6> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 >& x) : m_x(x.a6) {} + typename tuple_type<A6>::reference get() { return m_x; } + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>, 7> : tuple_type<A7> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 >& x) : m_x(x.a7) {} + typename tuple_type<A7>::reference get() { return m_x; } + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>, 8> : tuple_type<A8> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 >& x) : m_x(x.a8) {} + typename tuple_type<A8>::reference get() { return m_x; } + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>, 9> : tuple_type<A9> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 >& x) : m_x(x.a9) {} + typename tuple_type<A9>::reference get() { return m_x; } + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>, 10> : tuple_type<A10> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 >& x) : m_x(x.a10) {} + typename tuple_type<A10>::reference get() { return m_x; } + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>, 11> : tuple_type<A11> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 >& x) : m_x(x.a11) {} + typename tuple_type<A11>::reference get() { return m_x; } + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>, 12> : tuple_type<A12> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 >& x) : m_x(x.a12) {} + typename tuple_type<A12>::reference get() { return m_x; } + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>, 13> : tuple_type<A13> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 >& x) : m_x(x.a13) {} + typename tuple_type<A13>::reference get() { return m_x; } + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, 0> : tuple_type<A0> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 >& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, 1> : tuple_type<A1> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 >& x) : m_x(x.a1) {} + typename tuple_type<A1>::reference get() { return m_x; } + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, 2> : tuple_type<A2> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 >& x) : m_x(x.a2) {} + typename tuple_type<A2>::reference get() { return m_x; } + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, 3> : tuple_type<A3> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 >& x) : m_x(x.a3) {} + typename tuple_type<A3>::reference get() { return m_x; } + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, 4> : tuple_type<A4> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 >& x) : m_x(x.a4) {} + typename tuple_type<A4>::reference get() { return m_x; } + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, 5> : tuple_type<A5> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 >& x) : m_x(x.a5) {} + typename tuple_type<A5>::reference get() { return m_x; } + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, 6> : tuple_type<A6> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 >& x) : m_x(x.a6) {} + typename tuple_type<A6>::reference get() { return m_x; } + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, 7> : tuple_type<A7> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 >& x) : m_x(x.a7) {} + typename tuple_type<A7>::reference get() { return m_x; } + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, 8> : tuple_type<A8> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 >& x) : m_x(x.a8) {} + typename tuple_type<A8>::reference get() { return m_x; } + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, 9> : tuple_type<A9> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 >& x) : m_x(x.a9) {} + typename tuple_type<A9>::reference get() { return m_x; } + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, 10> : tuple_type<A10> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 >& x) : m_x(x.a10) {} + typename tuple_type<A10>::reference get() { return m_x; } + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, 11> : tuple_type<A11> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 >& x) : m_x(x.a11) {} + typename tuple_type<A11>::reference get() { return m_x; } + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, 12> : tuple_type<A12> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 >& x) : m_x(x.a12) {} + typename tuple_type<A12>::reference get() { return m_x; } + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, 13> : tuple_type<A13> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 >& x) : m_x(x.a13) {} + typename tuple_type<A13>::reference get() { return m_x; } + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, 14> : tuple_type<A14> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 >& x) : m_x(x.a14) {} + typename tuple_type<A14>::reference get() { return m_x; } + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 0> : tuple_type<A0> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 >& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 1> : tuple_type<A1> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 >& x) : m_x(x.a1) {} + typename tuple_type<A1>::reference get() { return m_x; } + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 2> : tuple_type<A2> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 >& x) : m_x(x.a2) {} + typename tuple_type<A2>::reference get() { return m_x; } + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 3> : tuple_type<A3> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 >& x) : m_x(x.a3) {} + typename tuple_type<A3>::reference get() { return m_x; } + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 4> : tuple_type<A4> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 >& x) : m_x(x.a4) {} + typename tuple_type<A4>::reference get() { return m_x; } + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 5> : tuple_type<A5> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 >& x) : m_x(x.a5) {} + typename tuple_type<A5>::reference get() { return m_x; } + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 6> : tuple_type<A6> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 >& x) : m_x(x.a6) {} + typename tuple_type<A6>::reference get() { return m_x; } + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 7> : tuple_type<A7> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 >& x) : m_x(x.a7) {} + typename tuple_type<A7>::reference get() { return m_x; } + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 8> : tuple_type<A8> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 >& x) : m_x(x.a8) {} + typename tuple_type<A8>::reference get() { return m_x; } + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 9> : tuple_type<A9> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 >& x) : m_x(x.a9) {} + typename tuple_type<A9>::reference get() { return m_x; } + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 10> : tuple_type<A10> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 >& x) : m_x(x.a10) {} + typename tuple_type<A10>::reference get() { return m_x; } + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 11> : tuple_type<A11> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 >& x) : m_x(x.a11) {} + typename tuple_type<A11>::reference get() { return m_x; } + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 12> : tuple_type<A12> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 >& x) : m_x(x.a12) {} + typename tuple_type<A12>::reference get() { return m_x; } + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 13> : tuple_type<A13> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 >& x) : m_x(x.a13) {} + typename tuple_type<A13>::reference get() { return m_x; } + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 14> : tuple_type<A14> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 >& x) : m_x(x.a14) {} + typename tuple_type<A14>::reference get() { return m_x; } + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 15> : tuple_type<A15> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 >& x) : m_x(x.a15) {} + typename tuple_type<A15>::reference get() { return m_x; } + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 0> : tuple_type<A0> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 >& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 1> : tuple_type<A1> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 >& x) : m_x(x.a1) {} + typename tuple_type<A1>::reference get() { return m_x; } + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 2> : tuple_type<A2> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 >& x) : m_x(x.a2) {} + typename tuple_type<A2>::reference get() { return m_x; } + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 3> : tuple_type<A3> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 >& x) : m_x(x.a3) {} + typename tuple_type<A3>::reference get() { return m_x; } + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 4> : tuple_type<A4> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 >& x) : m_x(x.a4) {} + typename tuple_type<A4>::reference get() { return m_x; } + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 5> : tuple_type<A5> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 >& x) : m_x(x.a5) {} + typename tuple_type<A5>::reference get() { return m_x; } + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 6> : tuple_type<A6> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 >& x) : m_x(x.a6) {} + typename tuple_type<A6>::reference get() { return m_x; } + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 7> : tuple_type<A7> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 >& x) : m_x(x.a7) {} + typename tuple_type<A7>::reference get() { return m_x; } + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 8> : tuple_type<A8> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 >& x) : m_x(x.a8) {} + typename tuple_type<A8>::reference get() { return m_x; } + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 9> : tuple_type<A9> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 >& x) : m_x(x.a9) {} + typename tuple_type<A9>::reference get() { return m_x; } + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 10> : tuple_type<A10> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 >& x) : m_x(x.a10) {} + typename tuple_type<A10>::reference get() { return m_x; } + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 11> : tuple_type<A11> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 >& x) : m_x(x.a11) {} + typename tuple_type<A11>::reference get() { return m_x; } + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 12> : tuple_type<A12> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 >& x) : m_x(x.a12) {} + typename tuple_type<A12>::reference get() { return m_x; } + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 13> : tuple_type<A13> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 >& x) : m_x(x.a13) {} + typename tuple_type<A13>::reference get() { return m_x; } + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 14> : tuple_type<A14> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 >& x) : m_x(x.a14) {} + typename tuple_type<A14>::reference get() { return m_x; } + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 15> : tuple_type<A15> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 >& x) : m_x(x.a15) {} + typename tuple_type<A15>::reference get() { return m_x; } + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 16> : tuple_type<A16> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 >& x) : m_x(x.a16) {} + typename tuple_type<A16>::reference get() { return m_x; } + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 0> : tuple_type<A0> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 >& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 1> : tuple_type<A1> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 >& x) : m_x(x.a1) {} + typename tuple_type<A1>::reference get() { return m_x; } + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 2> : tuple_type<A2> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 >& x) : m_x(x.a2) {} + typename tuple_type<A2>::reference get() { return m_x; } + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 3> : tuple_type<A3> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 >& x) : m_x(x.a3) {} + typename tuple_type<A3>::reference get() { return m_x; } + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 4> : tuple_type<A4> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 >& x) : m_x(x.a4) {} + typename tuple_type<A4>::reference get() { return m_x; } + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 5> : tuple_type<A5> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 >& x) : m_x(x.a5) {} + typename tuple_type<A5>::reference get() { return m_x; } + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 6> : tuple_type<A6> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 >& x) : m_x(x.a6) {} + typename tuple_type<A6>::reference get() { return m_x; } + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 7> : tuple_type<A7> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 >& x) : m_x(x.a7) {} + typename tuple_type<A7>::reference get() { return m_x; } + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 8> : tuple_type<A8> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 >& x) : m_x(x.a8) {} + typename tuple_type<A8>::reference get() { return m_x; } + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 9> : tuple_type<A9> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 >& x) : m_x(x.a9) {} + typename tuple_type<A9>::reference get() { return m_x; } + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 10> : tuple_type<A10> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 >& x) : m_x(x.a10) {} + typename tuple_type<A10>::reference get() { return m_x; } + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 11> : tuple_type<A11> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 >& x) : m_x(x.a11) {} + typename tuple_type<A11>::reference get() { return m_x; } + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 12> : tuple_type<A12> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 >& x) : m_x(x.a12) {} + typename tuple_type<A12>::reference get() { return m_x; } + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 13> : tuple_type<A13> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 >& x) : m_x(x.a13) {} + typename tuple_type<A13>::reference get() { return m_x; } + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 14> : tuple_type<A14> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 >& x) : m_x(x.a14) {} + typename tuple_type<A14>::reference get() { return m_x; } + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 15> : tuple_type<A15> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 >& x) : m_x(x.a15) {} + typename tuple_type<A15>::reference get() { return m_x; } + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 16> : tuple_type<A16> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 >& x) : m_x(x.a16) {} + typename tuple_type<A16>::reference get() { return m_x; } + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 17> : tuple_type<A17> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 >& x) : m_x(x.a17) {} + typename tuple_type<A17>::reference get() { return m_x; } + typename tuple_type<A17>::const_reference get() const { return m_x; } +private: + typename tuple_type<A17>::reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 0> : tuple_type<A0> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 >& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 1> : tuple_type<A1> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 >& x) : m_x(x.a1) {} + typename tuple_type<A1>::reference get() { return m_x; } + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 2> : tuple_type<A2> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 >& x) : m_x(x.a2) {} + typename tuple_type<A2>::reference get() { return m_x; } + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 3> : tuple_type<A3> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 >& x) : m_x(x.a3) {} + typename tuple_type<A3>::reference get() { return m_x; } + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 4> : tuple_type<A4> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 >& x) : m_x(x.a4) {} + typename tuple_type<A4>::reference get() { return m_x; } + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 5> : tuple_type<A5> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 >& x) : m_x(x.a5) {} + typename tuple_type<A5>::reference get() { return m_x; } + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 6> : tuple_type<A6> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 >& x) : m_x(x.a6) {} + typename tuple_type<A6>::reference get() { return m_x; } + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 7> : tuple_type<A7> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 >& x) : m_x(x.a7) {} + typename tuple_type<A7>::reference get() { return m_x; } + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 8> : tuple_type<A8> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 >& x) : m_x(x.a8) {} + typename tuple_type<A8>::reference get() { return m_x; } + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 9> : tuple_type<A9> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 >& x) : m_x(x.a9) {} + typename tuple_type<A9>::reference get() { return m_x; } + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 10> : tuple_type<A10> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 >& x) : m_x(x.a10) {} + typename tuple_type<A10>::reference get() { return m_x; } + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 11> : tuple_type<A11> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 >& x) : m_x(x.a11) {} + typename tuple_type<A11>::reference get() { return m_x; } + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 12> : tuple_type<A12> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 >& x) : m_x(x.a12) {} + typename tuple_type<A12>::reference get() { return m_x; } + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 13> : tuple_type<A13> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 >& x) : m_x(x.a13) {} + typename tuple_type<A13>::reference get() { return m_x; } + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 14> : tuple_type<A14> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 >& x) : m_x(x.a14) {} + typename tuple_type<A14>::reference get() { return m_x; } + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 15> : tuple_type<A15> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 >& x) : m_x(x.a15) {} + typename tuple_type<A15>::reference get() { return m_x; } + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 16> : tuple_type<A16> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 >& x) : m_x(x.a16) {} + typename tuple_type<A16>::reference get() { return m_x; } + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 17> : tuple_type<A17> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 >& x) : m_x(x.a17) {} + typename tuple_type<A17>::reference get() { return m_x; } + typename tuple_type<A17>::const_reference get() const { return m_x; } +private: + typename tuple_type<A17>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 18> : tuple_type<A18> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 >& x) : m_x(x.a18) {} + typename tuple_type<A18>::reference get() { return m_x; } + typename tuple_type<A18>::const_reference get() const { return m_x; } +private: + typename tuple_type<A18>::reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 0> : tuple_type<A0> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 >& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 1> : tuple_type<A1> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 >& x) : m_x(x.a1) {} + typename tuple_type<A1>::reference get() { return m_x; } + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 2> : tuple_type<A2> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 >& x) : m_x(x.a2) {} + typename tuple_type<A2>::reference get() { return m_x; } + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 3> : tuple_type<A3> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 >& x) : m_x(x.a3) {} + typename tuple_type<A3>::reference get() { return m_x; } + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 4> : tuple_type<A4> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 >& x) : m_x(x.a4) {} + typename tuple_type<A4>::reference get() { return m_x; } + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 5> : tuple_type<A5> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 >& x) : m_x(x.a5) {} + typename tuple_type<A5>::reference get() { return m_x; } + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 6> : tuple_type<A6> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 >& x) : m_x(x.a6) {} + typename tuple_type<A6>::reference get() { return m_x; } + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 7> : tuple_type<A7> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 >& x) : m_x(x.a7) {} + typename tuple_type<A7>::reference get() { return m_x; } + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 8> : tuple_type<A8> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 >& x) : m_x(x.a8) {} + typename tuple_type<A8>::reference get() { return m_x; } + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 9> : tuple_type<A9> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 >& x) : m_x(x.a9) {} + typename tuple_type<A9>::reference get() { return m_x; } + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 10> : tuple_type<A10> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 >& x) : m_x(x.a10) {} + typename tuple_type<A10>::reference get() { return m_x; } + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 11> : tuple_type<A11> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 >& x) : m_x(x.a11) {} + typename tuple_type<A11>::reference get() { return m_x; } + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 12> : tuple_type<A12> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 >& x) : m_x(x.a12) {} + typename tuple_type<A12>::reference get() { return m_x; } + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 13> : tuple_type<A13> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 >& x) : m_x(x.a13) {} + typename tuple_type<A13>::reference get() { return m_x; } + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 14> : tuple_type<A14> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 >& x) : m_x(x.a14) {} + typename tuple_type<A14>::reference get() { return m_x; } + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 15> : tuple_type<A15> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 >& x) : m_x(x.a15) {} + typename tuple_type<A15>::reference get() { return m_x; } + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 16> : tuple_type<A16> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 >& x) : m_x(x.a16) {} + typename tuple_type<A16>::reference get() { return m_x; } + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 17> : tuple_type<A17> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 >& x) : m_x(x.a17) {} + typename tuple_type<A17>::reference get() { return m_x; } + typename tuple_type<A17>::const_reference get() const { return m_x; } +private: + typename tuple_type<A17>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 18> : tuple_type<A18> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 >& x) : m_x(x.a18) {} + typename tuple_type<A18>::reference get() { return m_x; } + typename tuple_type<A18>::const_reference get() const { return m_x; } +private: + typename tuple_type<A18>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 19> : tuple_type<A19> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 >& x) : m_x(x.a19) {} + typename tuple_type<A19>::reference get() { return m_x; } + typename tuple_type<A19>::const_reference get() const { return m_x; } +private: + typename tuple_type<A19>::reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 0> : tuple_type<A0> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 >& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 1> : tuple_type<A1> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 >& x) : m_x(x.a1) {} + typename tuple_type<A1>::reference get() { return m_x; } + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 2> : tuple_type<A2> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 >& x) : m_x(x.a2) {} + typename tuple_type<A2>::reference get() { return m_x; } + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 3> : tuple_type<A3> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 >& x) : m_x(x.a3) {} + typename tuple_type<A3>::reference get() { return m_x; } + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 4> : tuple_type<A4> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 >& x) : m_x(x.a4) {} + typename tuple_type<A4>::reference get() { return m_x; } + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 5> : tuple_type<A5> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 >& x) : m_x(x.a5) {} + typename tuple_type<A5>::reference get() { return m_x; } + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 6> : tuple_type<A6> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 >& x) : m_x(x.a6) {} + typename tuple_type<A6>::reference get() { return m_x; } + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 7> : tuple_type<A7> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 >& x) : m_x(x.a7) {} + typename tuple_type<A7>::reference get() { return m_x; } + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 8> : tuple_type<A8> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 >& x) : m_x(x.a8) {} + typename tuple_type<A8>::reference get() { return m_x; } + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 9> : tuple_type<A9> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 >& x) : m_x(x.a9) {} + typename tuple_type<A9>::reference get() { return m_x; } + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 10> : tuple_type<A10> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 >& x) : m_x(x.a10) {} + typename tuple_type<A10>::reference get() { return m_x; } + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 11> : tuple_type<A11> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 >& x) : m_x(x.a11) {} + typename tuple_type<A11>::reference get() { return m_x; } + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 12> : tuple_type<A12> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 >& x) : m_x(x.a12) {} + typename tuple_type<A12>::reference get() { return m_x; } + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 13> : tuple_type<A13> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 >& x) : m_x(x.a13) {} + typename tuple_type<A13>::reference get() { return m_x; } + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 14> : tuple_type<A14> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 >& x) : m_x(x.a14) {} + typename tuple_type<A14>::reference get() { return m_x; } + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 15> : tuple_type<A15> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 >& x) : m_x(x.a15) {} + typename tuple_type<A15>::reference get() { return m_x; } + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 16> : tuple_type<A16> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 >& x) : m_x(x.a16) {} + typename tuple_type<A16>::reference get() { return m_x; } + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 17> : tuple_type<A17> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 >& x) : m_x(x.a17) {} + typename tuple_type<A17>::reference get() { return m_x; } + typename tuple_type<A17>::const_reference get() const { return m_x; } +private: + typename tuple_type<A17>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 18> : tuple_type<A18> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 >& x) : m_x(x.a18) {} + typename tuple_type<A18>::reference get() { return m_x; } + typename tuple_type<A18>::const_reference get() const { return m_x; } +private: + typename tuple_type<A18>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 19> : tuple_type<A19> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 >& x) : m_x(x.a19) {} + typename tuple_type<A19>::reference get() { return m_x; } + typename tuple_type<A19>::const_reference get() const { return m_x; } +private: + typename tuple_type<A19>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 20> : tuple_type<A20> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 >& x) : m_x(x.a20) {} + typename tuple_type<A20>::reference get() { return m_x; } + typename tuple_type<A20>::const_reference get() const { return m_x; } +private: + typename tuple_type<A20>::reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 0> : tuple_type<A0> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 >& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 1> : tuple_type<A1> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 >& x) : m_x(x.a1) {} + typename tuple_type<A1>::reference get() { return m_x; } + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 2> : tuple_type<A2> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 >& x) : m_x(x.a2) {} + typename tuple_type<A2>::reference get() { return m_x; } + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 3> : tuple_type<A3> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 >& x) : m_x(x.a3) {} + typename tuple_type<A3>::reference get() { return m_x; } + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 4> : tuple_type<A4> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 >& x) : m_x(x.a4) {} + typename tuple_type<A4>::reference get() { return m_x; } + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 5> : tuple_type<A5> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 >& x) : m_x(x.a5) {} + typename tuple_type<A5>::reference get() { return m_x; } + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 6> : tuple_type<A6> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 >& x) : m_x(x.a6) {} + typename tuple_type<A6>::reference get() { return m_x; } + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 7> : tuple_type<A7> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 >& x) : m_x(x.a7) {} + typename tuple_type<A7>::reference get() { return m_x; } + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 8> : tuple_type<A8> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 >& x) : m_x(x.a8) {} + typename tuple_type<A8>::reference get() { return m_x; } + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 9> : tuple_type<A9> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 >& x) : m_x(x.a9) {} + typename tuple_type<A9>::reference get() { return m_x; } + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 10> : tuple_type<A10> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 >& x) : m_x(x.a10) {} + typename tuple_type<A10>::reference get() { return m_x; } + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 11> : tuple_type<A11> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 >& x) : m_x(x.a11) {} + typename tuple_type<A11>::reference get() { return m_x; } + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 12> : tuple_type<A12> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 >& x) : m_x(x.a12) {} + typename tuple_type<A12>::reference get() { return m_x; } + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 13> : tuple_type<A13> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 >& x) : m_x(x.a13) {} + typename tuple_type<A13>::reference get() { return m_x; } + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 14> : tuple_type<A14> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 >& x) : m_x(x.a14) {} + typename tuple_type<A14>::reference get() { return m_x; } + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 15> : tuple_type<A15> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 >& x) : m_x(x.a15) {} + typename tuple_type<A15>::reference get() { return m_x; } + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 16> : tuple_type<A16> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 >& x) : m_x(x.a16) {} + typename tuple_type<A16>::reference get() { return m_x; } + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 17> : tuple_type<A17> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 >& x) : m_x(x.a17) {} + typename tuple_type<A17>::reference get() { return m_x; } + typename tuple_type<A17>::const_reference get() const { return m_x; } +private: + typename tuple_type<A17>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 18> : tuple_type<A18> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 >& x) : m_x(x.a18) {} + typename tuple_type<A18>::reference get() { return m_x; } + typename tuple_type<A18>::const_reference get() const { return m_x; } +private: + typename tuple_type<A18>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 19> : tuple_type<A19> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 >& x) : m_x(x.a19) {} + typename tuple_type<A19>::reference get() { return m_x; } + typename tuple_type<A19>::const_reference get() const { return m_x; } +private: + typename tuple_type<A19>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 20> : tuple_type<A20> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 >& x) : m_x(x.a20) {} + typename tuple_type<A20>::reference get() { return m_x; } + typename tuple_type<A20>::const_reference get() const { return m_x; } +private: + typename tuple_type<A20>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 21> : tuple_type<A21> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 >& x) : m_x(x.a21) {} + typename tuple_type<A21>::reference get() { return m_x; } + typename tuple_type<A21>::const_reference get() const { return m_x; } +private: + typename tuple_type<A21>::reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 0> : tuple_type<A0> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 , A22 >& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 1> : tuple_type<A1> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 , A22 >& x) : m_x(x.a1) {} + typename tuple_type<A1>::reference get() { return m_x; } + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 2> : tuple_type<A2> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 , A22 >& x) : m_x(x.a2) {} + typename tuple_type<A2>::reference get() { return m_x; } + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 3> : tuple_type<A3> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 , A22 >& x) : m_x(x.a3) {} + typename tuple_type<A3>::reference get() { return m_x; } + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 4> : tuple_type<A4> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 , A22 >& x) : m_x(x.a4) {} + typename tuple_type<A4>::reference get() { return m_x; } + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 5> : tuple_type<A5> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 , A22 >& x) : m_x(x.a5) {} + typename tuple_type<A5>::reference get() { return m_x; } + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 6> : tuple_type<A6> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 , A22 >& x) : m_x(x.a6) {} + typename tuple_type<A6>::reference get() { return m_x; } + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 7> : tuple_type<A7> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 , A22 >& x) : m_x(x.a7) {} + typename tuple_type<A7>::reference get() { return m_x; } + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 8> : tuple_type<A8> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 , A22 >& x) : m_x(x.a8) {} + typename tuple_type<A8>::reference get() { return m_x; } + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 9> : tuple_type<A9> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 , A22 >& x) : m_x(x.a9) {} + typename tuple_type<A9>::reference get() { return m_x; } + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 10> : tuple_type<A10> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 , A22 >& x) : m_x(x.a10) {} + typename tuple_type<A10>::reference get() { return m_x; } + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 11> : tuple_type<A11> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 , A22 >& x) : m_x(x.a11) {} + typename tuple_type<A11>::reference get() { return m_x; } + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 12> : tuple_type<A12> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 , A22 >& x) : m_x(x.a12) {} + typename tuple_type<A12>::reference get() { return m_x; } + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 13> : tuple_type<A13> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 , A22 >& x) : m_x(x.a13) {} + typename tuple_type<A13>::reference get() { return m_x; } + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 14> : tuple_type<A14> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 , A22 >& x) : m_x(x.a14) {} + typename tuple_type<A14>::reference get() { return m_x; } + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 15> : tuple_type<A15> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 , A22 >& x) : m_x(x.a15) {} + typename tuple_type<A15>::reference get() { return m_x; } + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 16> : tuple_type<A16> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 , A22 >& x) : m_x(x.a16) {} + typename tuple_type<A16>::reference get() { return m_x; } + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 17> : tuple_type<A17> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 , A22 >& x) : m_x(x.a17) {} + typename tuple_type<A17>::reference get() { return m_x; } + typename tuple_type<A17>::const_reference get() const { return m_x; } +private: + typename tuple_type<A17>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 18> : tuple_type<A18> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 , A22 >& x) : m_x(x.a18) {} + typename tuple_type<A18>::reference get() { return m_x; } + typename tuple_type<A18>::const_reference get() const { return m_x; } +private: + typename tuple_type<A18>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 19> : tuple_type<A19> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 , A22 >& x) : m_x(x.a19) {} + typename tuple_type<A19>::reference get() { return m_x; } + typename tuple_type<A19>::const_reference get() const { return m_x; } +private: + typename tuple_type<A19>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 20> : tuple_type<A20> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 , A22 >& x) : m_x(x.a20) {} + typename tuple_type<A20>::reference get() { return m_x; } + typename tuple_type<A20>::const_reference get() const { return m_x; } +private: + typename tuple_type<A20>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 21> : tuple_type<A21> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 , A22 >& x) : m_x(x.a21) {} + typename tuple_type<A21>::reference get() { return m_x; } + typename tuple_type<A21>::const_reference get() const { return m_x; } +private: + typename tuple_type<A21>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 22> : tuple_type<A22> { + tuple_element(tuple<A0, A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18 , A19 , A20 , A21 , A22 >& x) : m_x(x.a22) {} + typename tuple_type<A22>::reference get() { return m_x; } + typename tuple_type<A22>::const_reference get() const { return m_x; } +private: + typename tuple_type<A22>::reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct tuple_element<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>, 0> : tuple_type<A0> { + tuple_element(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 >& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct tuple_element<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>, 1> : tuple_type<A1> { + tuple_element(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 >& x) : m_x(x.a1) {} + typename tuple_type<A1>::reference get() { return m_x; } + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct tuple_element<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>, 2> : tuple_type<A2> { + tuple_element(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 >& x) : m_x(x.a2) {} + typename tuple_type<A2>::reference get() { return m_x; } + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct tuple_element<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>, 3> : tuple_type<A3> { + tuple_element(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 >& x) : m_x(x.a3) {} + typename tuple_type<A3>::reference get() { return m_x; } + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct tuple_element<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>, 4> : tuple_type<A4> { + tuple_element(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 >& x) : m_x(x.a4) {} + typename tuple_type<A4>::reference get() { return m_x; } + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct tuple_element<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>, 5> : tuple_type<A5> { + tuple_element(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 >& x) : m_x(x.a5) {} + typename tuple_type<A5>::reference get() { return m_x; } + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct tuple_element<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>, 6> : tuple_type<A6> { + tuple_element(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 >& x) : m_x(x.a6) {} + typename tuple_type<A6>::reference get() { return m_x; } + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct tuple_element<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>, 7> : tuple_type<A7> { + tuple_element(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 >& x) : m_x(x.a7) {} + typename tuple_type<A7>::reference get() { return m_x; } + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct tuple_element<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>, 8> : tuple_type<A8> { + tuple_element(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 >& x) : m_x(x.a8) {} + typename tuple_type<A8>::reference get() { return m_x; } + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct tuple_element<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>, 9> : tuple_type<A9> { + tuple_element(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 >& x) : m_x(x.a9) {} + typename tuple_type<A9>::reference get() { return m_x; } + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct tuple_element<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>, 10> : tuple_type<A10> { + tuple_element(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 >& x) : m_x(x.a10) {} + typename tuple_type<A10>::reference get() { return m_x; } + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct tuple_element<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>, 11> : tuple_type<A11> { + tuple_element(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 >& x) : m_x(x.a11) {} + typename tuple_type<A11>::reference get() { return m_x; } + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct tuple_element<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>, 12> : tuple_type<A12> { + tuple_element(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 >& x) : m_x(x.a12) {} + typename tuple_type<A12>::reference get() { return m_x; } + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct tuple_element<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>, 13> : tuple_type<A13> { + tuple_element(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 >& x) : m_x(x.a13) {} + typename tuple_type<A13>::reference get() { return m_x; } + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct tuple_element<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>, 14> : tuple_type<A14> { + tuple_element(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 >& x) : m_x(x.a14) {} + typename tuple_type<A14>::reference get() { return m_x; } + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct tuple_element<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>, 15> : tuple_type<A15> { + tuple_element(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 >& x) : m_x(x.a15) {} + typename tuple_type<A15>::reference get() { return m_x; } + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct tuple_element<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>, 16> : tuple_type<A16> { + tuple_element(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 >& x) : m_x(x.a16) {} + typename tuple_type<A16>::reference get() { return m_x; } + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct tuple_element<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>, 17> : tuple_type<A17> { + tuple_element(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 >& x) : m_x(x.a17) {} + typename tuple_type<A17>::reference get() { return m_x; } + typename tuple_type<A17>::const_reference get() const { return m_x; } +private: + typename tuple_type<A17>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct tuple_element<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>, 18> : tuple_type<A18> { + tuple_element(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 >& x) : m_x(x.a18) {} + typename tuple_type<A18>::reference get() { return m_x; } + typename tuple_type<A18>::const_reference get() const { return m_x; } +private: + typename tuple_type<A18>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct tuple_element<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>, 19> : tuple_type<A19> { + tuple_element(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 >& x) : m_x(x.a19) {} + typename tuple_type<A19>::reference get() { return m_x; } + typename tuple_type<A19>::const_reference get() const { return m_x; } +private: + typename tuple_type<A19>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct tuple_element<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>, 20> : tuple_type<A20> { + tuple_element(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 >& x) : m_x(x.a20) {} + typename tuple_type<A20>::reference get() { return m_x; } + typename tuple_type<A20>::const_reference get() const { return m_x; } +private: + typename tuple_type<A20>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct tuple_element<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>, 21> : tuple_type<A21> { + tuple_element(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 >& x) : m_x(x.a21) {} + typename tuple_type<A21>::reference get() { return m_x; } + typename tuple_type<A21>::const_reference get() const { return m_x; } +private: + typename tuple_type<A21>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct tuple_element<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>, 22> : tuple_type<A22> { + tuple_element(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 >& x) : m_x(x.a22) {} + typename tuple_type<A22>::reference get() { return m_x; } + typename tuple_type<A22>::const_reference get() const { return m_x; } +private: + typename tuple_type<A22>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct tuple_element<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>, 23> : tuple_type<A23> { + tuple_element(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 >& x) : m_x(x.a23) {} + typename tuple_type<A23>::reference get() { return m_x; } + typename tuple_type<A23>::const_reference get() const { return m_x; } +private: + typename tuple_type<A23>::reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct tuple_element<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>, 0> : tuple_type<A0> { + tuple_element(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 >& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct tuple_element<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>, 1> : tuple_type<A1> { + tuple_element(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 >& x) : m_x(x.a1) {} + typename tuple_type<A1>::reference get() { return m_x; } + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct tuple_element<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>, 2> : tuple_type<A2> { + tuple_element(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 >& x) : m_x(x.a2) {} + typename tuple_type<A2>::reference get() { return m_x; } + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct tuple_element<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>, 3> : tuple_type<A3> { + tuple_element(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 >& x) : m_x(x.a3) {} + typename tuple_type<A3>::reference get() { return m_x; } + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct tuple_element<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>, 4> : tuple_type<A4> { + tuple_element(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 >& x) : m_x(x.a4) {} + typename tuple_type<A4>::reference get() { return m_x; } + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct tuple_element<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>, 5> : tuple_type<A5> { + tuple_element(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 >& x) : m_x(x.a5) {} + typename tuple_type<A5>::reference get() { return m_x; } + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct tuple_element<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>, 6> : tuple_type<A6> { + tuple_element(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 >& x) : m_x(x.a6) {} + typename tuple_type<A6>::reference get() { return m_x; } + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct tuple_element<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>, 7> : tuple_type<A7> { + tuple_element(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 >& x) : m_x(x.a7) {} + typename tuple_type<A7>::reference get() { return m_x; } + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct tuple_element<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>, 8> : tuple_type<A8> { + tuple_element(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 >& x) : m_x(x.a8) {} + typename tuple_type<A8>::reference get() { return m_x; } + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct tuple_element<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>, 9> : tuple_type<A9> { + tuple_element(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 >& x) : m_x(x.a9) {} + typename tuple_type<A9>::reference get() { return m_x; } + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct tuple_element<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>, 10> : tuple_type<A10> { + tuple_element(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 >& x) : m_x(x.a10) {} + typename tuple_type<A10>::reference get() { return m_x; } + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct tuple_element<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>, 11> : tuple_type<A11> { + tuple_element(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 >& x) : m_x(x.a11) {} + typename tuple_type<A11>::reference get() { return m_x; } + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct tuple_element<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>, 12> : tuple_type<A12> { + tuple_element(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 >& x) : m_x(x.a12) {} + typename tuple_type<A12>::reference get() { return m_x; } + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct tuple_element<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>, 13> : tuple_type<A13> { + tuple_element(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 >& x) : m_x(x.a13) {} + typename tuple_type<A13>::reference get() { return m_x; } + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct tuple_element<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>, 14> : tuple_type<A14> { + tuple_element(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 >& x) : m_x(x.a14) {} + typename tuple_type<A14>::reference get() { return m_x; } + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct tuple_element<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>, 15> : tuple_type<A15> { + tuple_element(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 >& x) : m_x(x.a15) {} + typename tuple_type<A15>::reference get() { return m_x; } + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct tuple_element<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>, 16> : tuple_type<A16> { + tuple_element(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 >& x) : m_x(x.a16) {} + typename tuple_type<A16>::reference get() { return m_x; } + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct tuple_element<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>, 17> : tuple_type<A17> { + tuple_element(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 >& x) : m_x(x.a17) {} + typename tuple_type<A17>::reference get() { return m_x; } + typename tuple_type<A17>::const_reference get() const { return m_x; } +private: + typename tuple_type<A17>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct tuple_element<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>, 18> : tuple_type<A18> { + tuple_element(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 >& x) : m_x(x.a18) {} + typename tuple_type<A18>::reference get() { return m_x; } + typename tuple_type<A18>::const_reference get() const { return m_x; } +private: + typename tuple_type<A18>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct tuple_element<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>, 19> : tuple_type<A19> { + tuple_element(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 >& x) : m_x(x.a19) {} + typename tuple_type<A19>::reference get() { return m_x; } + typename tuple_type<A19>::const_reference get() const { return m_x; } +private: + typename tuple_type<A19>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct tuple_element<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>, 20> : tuple_type<A20> { + tuple_element(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 >& x) : m_x(x.a20) {} + typename tuple_type<A20>::reference get() { return m_x; } + typename tuple_type<A20>::const_reference get() const { return m_x; } +private: + typename tuple_type<A20>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct tuple_element<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>, 21> : tuple_type<A21> { + tuple_element(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 >& x) : m_x(x.a21) {} + typename tuple_type<A21>::reference get() { return m_x; } + typename tuple_type<A21>::const_reference get() const { return m_x; } +private: + typename tuple_type<A21>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct tuple_element<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>, 22> : tuple_type<A22> { + tuple_element(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 >& x) : m_x(x.a22) {} + typename tuple_type<A22>::reference get() { return m_x; } + typename tuple_type<A22>::const_reference get() const { return m_x; } +private: + typename tuple_type<A22>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct tuple_element<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>, 23> : tuple_type<A23> { + tuple_element(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 >& x) : m_x(x.a23) {} + typename tuple_type<A23>::reference get() { return m_x; } + typename tuple_type<A23>::const_reference get() const { return m_x; } +private: + typename tuple_type<A23>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct tuple_element<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>, 24> : tuple_type<A24> { + tuple_element(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 >& x) : m_x(x.a24) {} + typename tuple_type<A24>::reference get() { return m_x; } + typename tuple_type<A24>::const_reference get() const { return m_x; } +private: + typename tuple_type<A24>::reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct tuple_element<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>, 0> : tuple_type<A0> { + tuple_element(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 >& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct tuple_element<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>, 1> : tuple_type<A1> { + tuple_element(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 >& x) : m_x(x.a1) {} + typename tuple_type<A1>::reference get() { return m_x; } + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct tuple_element<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>, 2> : tuple_type<A2> { + tuple_element(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 >& x) : m_x(x.a2) {} + typename tuple_type<A2>::reference get() { return m_x; } + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct tuple_element<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>, 3> : tuple_type<A3> { + tuple_element(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 >& x) : m_x(x.a3) {} + typename tuple_type<A3>::reference get() { return m_x; } + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct tuple_element<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>, 4> : tuple_type<A4> { + tuple_element(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 >& x) : m_x(x.a4) {} + typename tuple_type<A4>::reference get() { return m_x; } + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct tuple_element<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>, 5> : tuple_type<A5> { + tuple_element(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 >& x) : m_x(x.a5) {} + typename tuple_type<A5>::reference get() { return m_x; } + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct tuple_element<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>, 6> : tuple_type<A6> { + tuple_element(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 >& x) : m_x(x.a6) {} + typename tuple_type<A6>::reference get() { return m_x; } + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct tuple_element<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>, 7> : tuple_type<A7> { + tuple_element(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 >& x) : m_x(x.a7) {} + typename tuple_type<A7>::reference get() { return m_x; } + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct tuple_element<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>, 8> : tuple_type<A8> { + tuple_element(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 >& x) : m_x(x.a8) {} + typename tuple_type<A8>::reference get() { return m_x; } + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct tuple_element<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>, 9> : tuple_type<A9> { + tuple_element(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 >& x) : m_x(x.a9) {} + typename tuple_type<A9>::reference get() { return m_x; } + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct tuple_element<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>, 10> : tuple_type<A10> { + tuple_element(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 >& x) : m_x(x.a10) {} + typename tuple_type<A10>::reference get() { return m_x; } + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct tuple_element<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>, 11> : tuple_type<A11> { + tuple_element(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 >& x) : m_x(x.a11) {} + typename tuple_type<A11>::reference get() { return m_x; } + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct tuple_element<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>, 12> : tuple_type<A12> { + tuple_element(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 >& x) : m_x(x.a12) {} + typename tuple_type<A12>::reference get() { return m_x; } + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct tuple_element<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>, 13> : tuple_type<A13> { + tuple_element(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 >& x) : m_x(x.a13) {} + typename tuple_type<A13>::reference get() { return m_x; } + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct tuple_element<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>, 14> : tuple_type<A14> { + tuple_element(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 >& x) : m_x(x.a14) {} + typename tuple_type<A14>::reference get() { return m_x; } + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct tuple_element<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>, 15> : tuple_type<A15> { + tuple_element(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 >& x) : m_x(x.a15) {} + typename tuple_type<A15>::reference get() { return m_x; } + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct tuple_element<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>, 16> : tuple_type<A16> { + tuple_element(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 >& x) : m_x(x.a16) {} + typename tuple_type<A16>::reference get() { return m_x; } + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct tuple_element<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>, 17> : tuple_type<A17> { + tuple_element(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 >& x) : m_x(x.a17) {} + typename tuple_type<A17>::reference get() { return m_x; } + typename tuple_type<A17>::const_reference get() const { return m_x; } +private: + typename tuple_type<A17>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct tuple_element<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>, 18> : tuple_type<A18> { + tuple_element(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 >& x) : m_x(x.a18) {} + typename tuple_type<A18>::reference get() { return m_x; } + typename tuple_type<A18>::const_reference get() const { return m_x; } +private: + typename tuple_type<A18>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct tuple_element<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>, 19> : tuple_type<A19> { + tuple_element(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 >& x) : m_x(x.a19) {} + typename tuple_type<A19>::reference get() { return m_x; } + typename tuple_type<A19>::const_reference get() const { return m_x; } +private: + typename tuple_type<A19>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct tuple_element<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>, 20> : tuple_type<A20> { + tuple_element(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 >& x) : m_x(x.a20) {} + typename tuple_type<A20>::reference get() { return m_x; } + typename tuple_type<A20>::const_reference get() const { return m_x; } +private: + typename tuple_type<A20>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct tuple_element<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>, 21> : tuple_type<A21> { + tuple_element(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 >& x) : m_x(x.a21) {} + typename tuple_type<A21>::reference get() { return m_x; } + typename tuple_type<A21>::const_reference get() const { return m_x; } +private: + typename tuple_type<A21>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct tuple_element<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>, 22> : tuple_type<A22> { + tuple_element(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 >& x) : m_x(x.a22) {} + typename tuple_type<A22>::reference get() { return m_x; } + typename tuple_type<A22>::const_reference get() const { return m_x; } +private: + typename tuple_type<A22>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct tuple_element<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>, 23> : tuple_type<A23> { + tuple_element(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 >& x) : m_x(x.a23) {} + typename tuple_type<A23>::reference get() { return m_x; } + typename tuple_type<A23>::const_reference get() const { return m_x; } +private: + typename tuple_type<A23>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct tuple_element<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>, 24> : tuple_type<A24> { + tuple_element(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 >& x) : m_x(x.a24) {} + typename tuple_type<A24>::reference get() { return m_x; } + typename tuple_type<A24>::const_reference get() const { return m_x; } +private: + typename tuple_type<A24>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct tuple_element<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>, 25> : tuple_type<A25> { + tuple_element(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 >& x) : m_x(x.a25) {} + typename tuple_type<A25>::reference get() { return m_x; } + typename tuple_type<A25>::const_reference get() const { return m_x; } +private: + typename tuple_type<A25>::reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct tuple_element<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>, 0> : tuple_type<A0> { + tuple_element(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 >& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct tuple_element<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>, 1> : tuple_type<A1> { + tuple_element(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 >& x) : m_x(x.a1) {} + typename tuple_type<A1>::reference get() { return m_x; } + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct tuple_element<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>, 2> : tuple_type<A2> { + tuple_element(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 >& x) : m_x(x.a2) {} + typename tuple_type<A2>::reference get() { return m_x; } + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct tuple_element<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>, 3> : tuple_type<A3> { + tuple_element(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 >& x) : m_x(x.a3) {} + typename tuple_type<A3>::reference get() { return m_x; } + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct tuple_element<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>, 4> : tuple_type<A4> { + tuple_element(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 >& x) : m_x(x.a4) {} + typename tuple_type<A4>::reference get() { return m_x; } + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct tuple_element<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>, 5> : tuple_type<A5> { + tuple_element(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 >& x) : m_x(x.a5) {} + typename tuple_type<A5>::reference get() { return m_x; } + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct tuple_element<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>, 6> : tuple_type<A6> { + tuple_element(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 >& x) : m_x(x.a6) {} + typename tuple_type<A6>::reference get() { return m_x; } + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct tuple_element<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>, 7> : tuple_type<A7> { + tuple_element(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 >& x) : m_x(x.a7) {} + typename tuple_type<A7>::reference get() { return m_x; } + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct tuple_element<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>, 8> : tuple_type<A8> { + tuple_element(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 >& x) : m_x(x.a8) {} + typename tuple_type<A8>::reference get() { return m_x; } + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct tuple_element<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>, 9> : tuple_type<A9> { + tuple_element(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 >& x) : m_x(x.a9) {} + typename tuple_type<A9>::reference get() { return m_x; } + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct tuple_element<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>, 10> : tuple_type<A10> { + tuple_element(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 >& x) : m_x(x.a10) {} + typename tuple_type<A10>::reference get() { return m_x; } + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct tuple_element<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>, 11> : tuple_type<A11> { + tuple_element(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 >& x) : m_x(x.a11) {} + typename tuple_type<A11>::reference get() { return m_x; } + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct tuple_element<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>, 12> : tuple_type<A12> { + tuple_element(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 >& x) : m_x(x.a12) {} + typename tuple_type<A12>::reference get() { return m_x; } + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct tuple_element<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>, 13> : tuple_type<A13> { + tuple_element(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 >& x) : m_x(x.a13) {} + typename tuple_type<A13>::reference get() { return m_x; } + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct tuple_element<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>, 14> : tuple_type<A14> { + tuple_element(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 >& x) : m_x(x.a14) {} + typename tuple_type<A14>::reference get() { return m_x; } + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct tuple_element<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>, 15> : tuple_type<A15> { + tuple_element(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 >& x) : m_x(x.a15) {} + typename tuple_type<A15>::reference get() { return m_x; } + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct tuple_element<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>, 16> : tuple_type<A16> { + tuple_element(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 >& x) : m_x(x.a16) {} + typename tuple_type<A16>::reference get() { return m_x; } + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct tuple_element<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>, 17> : tuple_type<A17> { + tuple_element(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 >& x) : m_x(x.a17) {} + typename tuple_type<A17>::reference get() { return m_x; } + typename tuple_type<A17>::const_reference get() const { return m_x; } +private: + typename tuple_type<A17>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct tuple_element<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>, 18> : tuple_type<A18> { + tuple_element(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 >& x) : m_x(x.a18) {} + typename tuple_type<A18>::reference get() { return m_x; } + typename tuple_type<A18>::const_reference get() const { return m_x; } +private: + typename tuple_type<A18>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct tuple_element<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>, 19> : tuple_type<A19> { + tuple_element(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 >& x) : m_x(x.a19) {} + typename tuple_type<A19>::reference get() { return m_x; } + typename tuple_type<A19>::const_reference get() const { return m_x; } +private: + typename tuple_type<A19>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct tuple_element<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>, 20> : tuple_type<A20> { + tuple_element(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 >& x) : m_x(x.a20) {} + typename tuple_type<A20>::reference get() { return m_x; } + typename tuple_type<A20>::const_reference get() const { return m_x; } +private: + typename tuple_type<A20>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct tuple_element<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>, 21> : tuple_type<A21> { + tuple_element(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 >& x) : m_x(x.a21) {} + typename tuple_type<A21>::reference get() { return m_x; } + typename tuple_type<A21>::const_reference get() const { return m_x; } +private: + typename tuple_type<A21>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct tuple_element<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>, 22> : tuple_type<A22> { + tuple_element(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 >& x) : m_x(x.a22) {} + typename tuple_type<A22>::reference get() { return m_x; } + typename tuple_type<A22>::const_reference get() const { return m_x; } +private: + typename tuple_type<A22>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct tuple_element<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>, 23> : tuple_type<A23> { + tuple_element(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 >& x) : m_x(x.a23) {} + typename tuple_type<A23>::reference get() { return m_x; } + typename tuple_type<A23>::const_reference get() const { return m_x; } +private: + typename tuple_type<A23>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct tuple_element<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>, 24> : tuple_type<A24> { + tuple_element(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 >& x) : m_x(x.a24) {} + typename tuple_type<A24>::reference get() { return m_x; } + typename tuple_type<A24>::const_reference get() const { return m_x; } +private: + typename tuple_type<A24>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct tuple_element<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>, 25> : tuple_type<A25> { + tuple_element(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 >& x) : m_x(x.a25) {} + typename tuple_type<A25>::reference get() { return m_x; } + typename tuple_type<A25>::const_reference get() const { return m_x; } +private: + typename tuple_type<A25>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct tuple_element<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>, 26> : tuple_type<A26> { + tuple_element(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 >& x) : m_x(x.a26) {} + typename tuple_type<A26>::reference get() { return m_x; } + typename tuple_type<A26>::const_reference get() const { return m_x; } +private: + typename tuple_type<A26>::reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct tuple_element<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>, 0> : tuple_type<A0> { + tuple_element(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 >& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct tuple_element<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>, 1> : tuple_type<A1> { + tuple_element(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 >& x) : m_x(x.a1) {} + typename tuple_type<A1>::reference get() { return m_x; } + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct tuple_element<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>, 2> : tuple_type<A2> { + tuple_element(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 >& x) : m_x(x.a2) {} + typename tuple_type<A2>::reference get() { return m_x; } + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct tuple_element<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>, 3> : tuple_type<A3> { + tuple_element(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 >& x) : m_x(x.a3) {} + typename tuple_type<A3>::reference get() { return m_x; } + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct tuple_element<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>, 4> : tuple_type<A4> { + tuple_element(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 >& x) : m_x(x.a4) {} + typename tuple_type<A4>::reference get() { return m_x; } + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct tuple_element<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>, 5> : tuple_type<A5> { + tuple_element(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 >& x) : m_x(x.a5) {} + typename tuple_type<A5>::reference get() { return m_x; } + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct tuple_element<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>, 6> : tuple_type<A6> { + tuple_element(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 >& x) : m_x(x.a6) {} + typename tuple_type<A6>::reference get() { return m_x; } + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct tuple_element<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>, 7> : tuple_type<A7> { + tuple_element(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 >& x) : m_x(x.a7) {} + typename tuple_type<A7>::reference get() { return m_x; } + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct tuple_element<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>, 8> : tuple_type<A8> { + tuple_element(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 >& x) : m_x(x.a8) {} + typename tuple_type<A8>::reference get() { return m_x; } + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct tuple_element<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>, 9> : tuple_type<A9> { + tuple_element(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 >& x) : m_x(x.a9) {} + typename tuple_type<A9>::reference get() { return m_x; } + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct tuple_element<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>, 10> : tuple_type<A10> { + tuple_element(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 >& x) : m_x(x.a10) {} + typename tuple_type<A10>::reference get() { return m_x; } + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct tuple_element<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>, 11> : tuple_type<A11> { + tuple_element(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 >& x) : m_x(x.a11) {} + typename tuple_type<A11>::reference get() { return m_x; } + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct tuple_element<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>, 12> : tuple_type<A12> { + tuple_element(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 >& x) : m_x(x.a12) {} + typename tuple_type<A12>::reference get() { return m_x; } + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct tuple_element<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>, 13> : tuple_type<A13> { + tuple_element(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 >& x) : m_x(x.a13) {} + typename tuple_type<A13>::reference get() { return m_x; } + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct tuple_element<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>, 14> : tuple_type<A14> { + tuple_element(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 >& x) : m_x(x.a14) {} + typename tuple_type<A14>::reference get() { return m_x; } + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct tuple_element<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>, 15> : tuple_type<A15> { + tuple_element(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 >& x) : m_x(x.a15) {} + typename tuple_type<A15>::reference get() { return m_x; } + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct tuple_element<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>, 16> : tuple_type<A16> { + tuple_element(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 >& x) : m_x(x.a16) {} + typename tuple_type<A16>::reference get() { return m_x; } + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct tuple_element<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>, 17> : tuple_type<A17> { + tuple_element(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 >& x) : m_x(x.a17) {} + typename tuple_type<A17>::reference get() { return m_x; } + typename tuple_type<A17>::const_reference get() const { return m_x; } +private: + typename tuple_type<A17>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct tuple_element<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>, 18> : tuple_type<A18> { + tuple_element(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 >& x) : m_x(x.a18) {} + typename tuple_type<A18>::reference get() { return m_x; } + typename tuple_type<A18>::const_reference get() const { return m_x; } +private: + typename tuple_type<A18>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct tuple_element<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>, 19> : tuple_type<A19> { + tuple_element(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 >& x) : m_x(x.a19) {} + typename tuple_type<A19>::reference get() { return m_x; } + typename tuple_type<A19>::const_reference get() const { return m_x; } +private: + typename tuple_type<A19>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct tuple_element<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>, 20> : tuple_type<A20> { + tuple_element(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 >& x) : m_x(x.a20) {} + typename tuple_type<A20>::reference get() { return m_x; } + typename tuple_type<A20>::const_reference get() const { return m_x; } +private: + typename tuple_type<A20>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct tuple_element<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>, 21> : tuple_type<A21> { + tuple_element(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 >& x) : m_x(x.a21) {} + typename tuple_type<A21>::reference get() { return m_x; } + typename tuple_type<A21>::const_reference get() const { return m_x; } +private: + typename tuple_type<A21>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct tuple_element<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>, 22> : tuple_type<A22> { + tuple_element(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 >& x) : m_x(x.a22) {} + typename tuple_type<A22>::reference get() { return m_x; } + typename tuple_type<A22>::const_reference get() const { return m_x; } +private: + typename tuple_type<A22>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct tuple_element<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>, 23> : tuple_type<A23> { + tuple_element(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 >& x) : m_x(x.a23) {} + typename tuple_type<A23>::reference get() { return m_x; } + typename tuple_type<A23>::const_reference get() const { return m_x; } +private: + typename tuple_type<A23>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct tuple_element<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>, 24> : tuple_type<A24> { + tuple_element(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 >& x) : m_x(x.a24) {} + typename tuple_type<A24>::reference get() { return m_x; } + typename tuple_type<A24>::const_reference get() const { return m_x; } +private: + typename tuple_type<A24>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct tuple_element<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>, 25> : tuple_type<A25> { + tuple_element(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 >& x) : m_x(x.a25) {} + typename tuple_type<A25>::reference get() { return m_x; } + typename tuple_type<A25>::const_reference get() const { return m_x; } +private: + typename tuple_type<A25>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct tuple_element<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>, 26> : tuple_type<A26> { + tuple_element(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 >& x) : m_x(x.a26) {} + typename tuple_type<A26>::reference get() { return m_x; } + typename tuple_type<A26>::const_reference get() const { return m_x; } +private: + typename tuple_type<A26>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct tuple_element<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>, 27> : tuple_type<A27> { + tuple_element(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 >& x) : m_x(x.a27) {} + typename tuple_type<A27>::reference get() { return m_x; } + typename tuple_type<A27>::const_reference get() const { return m_x; } +private: + typename tuple_type<A27>::reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct tuple_element<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>, 0> : tuple_type<A0> { + tuple_element(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 >& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct tuple_element<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>, 1> : tuple_type<A1> { + tuple_element(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 >& x) : m_x(x.a1) {} + typename tuple_type<A1>::reference get() { return m_x; } + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct tuple_element<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>, 2> : tuple_type<A2> { + tuple_element(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 >& x) : m_x(x.a2) {} + typename tuple_type<A2>::reference get() { return m_x; } + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct tuple_element<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>, 3> : tuple_type<A3> { + tuple_element(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 >& x) : m_x(x.a3) {} + typename tuple_type<A3>::reference get() { return m_x; } + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct tuple_element<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>, 4> : tuple_type<A4> { + tuple_element(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 >& x) : m_x(x.a4) {} + typename tuple_type<A4>::reference get() { return m_x; } + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct tuple_element<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>, 5> : tuple_type<A5> { + tuple_element(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 >& x) : m_x(x.a5) {} + typename tuple_type<A5>::reference get() { return m_x; } + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct tuple_element<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>, 6> : tuple_type<A6> { + tuple_element(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 >& x) : m_x(x.a6) {} + typename tuple_type<A6>::reference get() { return m_x; } + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct tuple_element<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>, 7> : tuple_type<A7> { + tuple_element(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 >& x) : m_x(x.a7) {} + typename tuple_type<A7>::reference get() { return m_x; } + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct tuple_element<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>, 8> : tuple_type<A8> { + tuple_element(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 >& x) : m_x(x.a8) {} + typename tuple_type<A8>::reference get() { return m_x; } + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct tuple_element<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>, 9> : tuple_type<A9> { + tuple_element(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 >& x) : m_x(x.a9) {} + typename tuple_type<A9>::reference get() { return m_x; } + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct tuple_element<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>, 10> : tuple_type<A10> { + tuple_element(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 >& x) : m_x(x.a10) {} + typename tuple_type<A10>::reference get() { return m_x; } + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct tuple_element<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>, 11> : tuple_type<A11> { + tuple_element(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 >& x) : m_x(x.a11) {} + typename tuple_type<A11>::reference get() { return m_x; } + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct tuple_element<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>, 12> : tuple_type<A12> { + tuple_element(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 >& x) : m_x(x.a12) {} + typename tuple_type<A12>::reference get() { return m_x; } + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct tuple_element<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>, 13> : tuple_type<A13> { + tuple_element(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 >& x) : m_x(x.a13) {} + typename tuple_type<A13>::reference get() { return m_x; } + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct tuple_element<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>, 14> : tuple_type<A14> { + tuple_element(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 >& x) : m_x(x.a14) {} + typename tuple_type<A14>::reference get() { return m_x; } + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct tuple_element<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>, 15> : tuple_type<A15> { + tuple_element(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 >& x) : m_x(x.a15) {} + typename tuple_type<A15>::reference get() { return m_x; } + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct tuple_element<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>, 16> : tuple_type<A16> { + tuple_element(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 >& x) : m_x(x.a16) {} + typename tuple_type<A16>::reference get() { return m_x; } + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct tuple_element<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>, 17> : tuple_type<A17> { + tuple_element(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 >& x) : m_x(x.a17) {} + typename tuple_type<A17>::reference get() { return m_x; } + typename tuple_type<A17>::const_reference get() const { return m_x; } +private: + typename tuple_type<A17>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct tuple_element<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>, 18> : tuple_type<A18> { + tuple_element(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 >& x) : m_x(x.a18) {} + typename tuple_type<A18>::reference get() { return m_x; } + typename tuple_type<A18>::const_reference get() const { return m_x; } +private: + typename tuple_type<A18>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct tuple_element<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>, 19> : tuple_type<A19> { + tuple_element(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 >& x) : m_x(x.a19) {} + typename tuple_type<A19>::reference get() { return m_x; } + typename tuple_type<A19>::const_reference get() const { return m_x; } +private: + typename tuple_type<A19>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct tuple_element<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>, 20> : tuple_type<A20> { + tuple_element(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 >& x) : m_x(x.a20) {} + typename tuple_type<A20>::reference get() { return m_x; } + typename tuple_type<A20>::const_reference get() const { return m_x; } +private: + typename tuple_type<A20>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct tuple_element<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>, 21> : tuple_type<A21> { + tuple_element(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 >& x) : m_x(x.a21) {} + typename tuple_type<A21>::reference get() { return m_x; } + typename tuple_type<A21>::const_reference get() const { return m_x; } +private: + typename tuple_type<A21>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct tuple_element<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>, 22> : tuple_type<A22> { + tuple_element(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 >& x) : m_x(x.a22) {} + typename tuple_type<A22>::reference get() { return m_x; } + typename tuple_type<A22>::const_reference get() const { return m_x; } +private: + typename tuple_type<A22>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct tuple_element<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>, 23> : tuple_type<A23> { + tuple_element(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 >& x) : m_x(x.a23) {} + typename tuple_type<A23>::reference get() { return m_x; } + typename tuple_type<A23>::const_reference get() const { return m_x; } +private: + typename tuple_type<A23>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct tuple_element<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>, 24> : tuple_type<A24> { + tuple_element(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 >& x) : m_x(x.a24) {} + typename tuple_type<A24>::reference get() { return m_x; } + typename tuple_type<A24>::const_reference get() const { return m_x; } +private: + typename tuple_type<A24>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct tuple_element<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>, 25> : tuple_type<A25> { + tuple_element(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 >& x) : m_x(x.a25) {} + typename tuple_type<A25>::reference get() { return m_x; } + typename tuple_type<A25>::const_reference get() const { return m_x; } +private: + typename tuple_type<A25>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct tuple_element<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>, 26> : tuple_type<A26> { + tuple_element(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 >& x) : m_x(x.a26) {} + typename tuple_type<A26>::reference get() { return m_x; } + typename tuple_type<A26>::const_reference get() const { return m_x; } +private: + typename tuple_type<A26>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct tuple_element<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>, 27> : tuple_type<A27> { + tuple_element(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 >& x) : m_x(x.a27) {} + typename tuple_type<A27>::reference get() { return m_x; } + typename tuple_type<A27>::const_reference get() const { return m_x; } +private: + typename tuple_type<A27>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct tuple_element<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>, 28> : tuple_type<A28> { + tuple_element(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 >& x) : m_x(x.a28) {} + typename tuple_type<A28>::reference get() { return m_x; } + typename tuple_type<A28>::const_reference get() const { return m_x; } +private: + typename tuple_type<A28>::reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct tuple_element<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>, 0> : tuple_type<A0> { + tuple_element(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 >& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct tuple_element<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>, 1> : tuple_type<A1> { + tuple_element(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 >& x) : m_x(x.a1) {} + typename tuple_type<A1>::reference get() { return m_x; } + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct tuple_element<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>, 2> : tuple_type<A2> { + tuple_element(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 >& x) : m_x(x.a2) {} + typename tuple_type<A2>::reference get() { return m_x; } + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct tuple_element<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>, 3> : tuple_type<A3> { + tuple_element(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 >& x) : m_x(x.a3) {} + typename tuple_type<A3>::reference get() { return m_x; } + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct tuple_element<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>, 4> : tuple_type<A4> { + tuple_element(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 >& x) : m_x(x.a4) {} + typename tuple_type<A4>::reference get() { return m_x; } + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct tuple_element<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>, 5> : tuple_type<A5> { + tuple_element(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 >& x) : m_x(x.a5) {} + typename tuple_type<A5>::reference get() { return m_x; } + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct tuple_element<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>, 6> : tuple_type<A6> { + tuple_element(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 >& x) : m_x(x.a6) {} + typename tuple_type<A6>::reference get() { return m_x; } + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct tuple_element<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>, 7> : tuple_type<A7> { + tuple_element(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 >& x) : m_x(x.a7) {} + typename tuple_type<A7>::reference get() { return m_x; } + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct tuple_element<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>, 8> : tuple_type<A8> { + tuple_element(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 >& x) : m_x(x.a8) {} + typename tuple_type<A8>::reference get() { return m_x; } + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct tuple_element<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>, 9> : tuple_type<A9> { + tuple_element(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 >& x) : m_x(x.a9) {} + typename tuple_type<A9>::reference get() { return m_x; } + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct tuple_element<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>, 10> : tuple_type<A10> { + tuple_element(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 >& x) : m_x(x.a10) {} + typename tuple_type<A10>::reference get() { return m_x; } + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct tuple_element<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>, 11> : tuple_type<A11> { + tuple_element(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 >& x) : m_x(x.a11) {} + typename tuple_type<A11>::reference get() { return m_x; } + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct tuple_element<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>, 12> : tuple_type<A12> { + tuple_element(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 >& x) : m_x(x.a12) {} + typename tuple_type<A12>::reference get() { return m_x; } + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct tuple_element<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>, 13> : tuple_type<A13> { + tuple_element(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 >& x) : m_x(x.a13) {} + typename tuple_type<A13>::reference get() { return m_x; } + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct tuple_element<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>, 14> : tuple_type<A14> { + tuple_element(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 >& x) : m_x(x.a14) {} + typename tuple_type<A14>::reference get() { return m_x; } + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct tuple_element<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>, 15> : tuple_type<A15> { + tuple_element(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 >& x) : m_x(x.a15) {} + typename tuple_type<A15>::reference get() { return m_x; } + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct tuple_element<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>, 16> : tuple_type<A16> { + tuple_element(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 >& x) : m_x(x.a16) {} + typename tuple_type<A16>::reference get() { return m_x; } + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct tuple_element<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>, 17> : tuple_type<A17> { + tuple_element(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 >& x) : m_x(x.a17) {} + typename tuple_type<A17>::reference get() { return m_x; } + typename tuple_type<A17>::const_reference get() const { return m_x; } +private: + typename tuple_type<A17>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct tuple_element<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>, 18> : tuple_type<A18> { + tuple_element(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 >& x) : m_x(x.a18) {} + typename tuple_type<A18>::reference get() { return m_x; } + typename tuple_type<A18>::const_reference get() const { return m_x; } +private: + typename tuple_type<A18>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct tuple_element<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>, 19> : tuple_type<A19> { + tuple_element(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 >& x) : m_x(x.a19) {} + typename tuple_type<A19>::reference get() { return m_x; } + typename tuple_type<A19>::const_reference get() const { return m_x; } +private: + typename tuple_type<A19>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct tuple_element<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>, 20> : tuple_type<A20> { + tuple_element(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 >& x) : m_x(x.a20) {} + typename tuple_type<A20>::reference get() { return m_x; } + typename tuple_type<A20>::const_reference get() const { return m_x; } +private: + typename tuple_type<A20>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct tuple_element<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>, 21> : tuple_type<A21> { + tuple_element(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 >& x) : m_x(x.a21) {} + typename tuple_type<A21>::reference get() { return m_x; } + typename tuple_type<A21>::const_reference get() const { return m_x; } +private: + typename tuple_type<A21>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct tuple_element<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>, 22> : tuple_type<A22> { + tuple_element(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 >& x) : m_x(x.a22) {} + typename tuple_type<A22>::reference get() { return m_x; } + typename tuple_type<A22>::const_reference get() const { return m_x; } +private: + typename tuple_type<A22>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct tuple_element<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>, 23> : tuple_type<A23> { + tuple_element(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 >& x) : m_x(x.a23) {} + typename tuple_type<A23>::reference get() { return m_x; } + typename tuple_type<A23>::const_reference get() const { return m_x; } +private: + typename tuple_type<A23>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct tuple_element<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>, 24> : tuple_type<A24> { + tuple_element(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 >& x) : m_x(x.a24) {} + typename tuple_type<A24>::reference get() { return m_x; } + typename tuple_type<A24>::const_reference get() const { return m_x; } +private: + typename tuple_type<A24>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct tuple_element<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>, 25> : tuple_type<A25> { + tuple_element(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 >& x) : m_x(x.a25) {} + typename tuple_type<A25>::reference get() { return m_x; } + typename tuple_type<A25>::const_reference get() const { return m_x; } +private: + typename tuple_type<A25>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct tuple_element<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>, 26> : tuple_type<A26> { + tuple_element(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 >& x) : m_x(x.a26) {} + typename tuple_type<A26>::reference get() { return m_x; } + typename tuple_type<A26>::const_reference get() const { return m_x; } +private: + typename tuple_type<A26>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct tuple_element<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>, 27> : tuple_type<A27> { + tuple_element(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 >& x) : m_x(x.a27) {} + typename tuple_type<A27>::reference get() { return m_x; } + typename tuple_type<A27>::const_reference get() const { return m_x; } +private: + typename tuple_type<A27>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct tuple_element<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>, 28> : tuple_type<A28> { + tuple_element(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 >& x) : m_x(x.a28) {} + typename tuple_type<A28>::reference get() { return m_x; } + typename tuple_type<A28>::const_reference get() const { return m_x; } +private: + typename tuple_type<A28>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct tuple_element<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>, 29> : tuple_type<A29> { + tuple_element(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 >& x) : m_x(x.a29) {} + typename tuple_type<A29>::reference get() { return m_x; } + typename tuple_type<A29>::const_reference get() const { return m_x; } +private: + typename tuple_type<A29>::reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct tuple_element<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>, 0> : tuple_type<A0> { + tuple_element(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 >& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct tuple_element<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>, 1> : tuple_type<A1> { + tuple_element(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 >& x) : m_x(x.a1) {} + typename tuple_type<A1>::reference get() { return m_x; } + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct tuple_element<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>, 2> : tuple_type<A2> { + tuple_element(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 >& x) : m_x(x.a2) {} + typename tuple_type<A2>::reference get() { return m_x; } + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct tuple_element<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>, 3> : tuple_type<A3> { + tuple_element(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 >& x) : m_x(x.a3) {} + typename tuple_type<A3>::reference get() { return m_x; } + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct tuple_element<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>, 4> : tuple_type<A4> { + tuple_element(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 >& x) : m_x(x.a4) {} + typename tuple_type<A4>::reference get() { return m_x; } + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct tuple_element<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>, 5> : tuple_type<A5> { + tuple_element(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 >& x) : m_x(x.a5) {} + typename tuple_type<A5>::reference get() { return m_x; } + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct tuple_element<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>, 6> : tuple_type<A6> { + tuple_element(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 >& x) : m_x(x.a6) {} + typename tuple_type<A6>::reference get() { return m_x; } + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct tuple_element<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>, 7> : tuple_type<A7> { + tuple_element(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 >& x) : m_x(x.a7) {} + typename tuple_type<A7>::reference get() { return m_x; } + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct tuple_element<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>, 8> : tuple_type<A8> { + tuple_element(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 >& x) : m_x(x.a8) {} + typename tuple_type<A8>::reference get() { return m_x; } + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct tuple_element<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>, 9> : tuple_type<A9> { + tuple_element(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 >& x) : m_x(x.a9) {} + typename tuple_type<A9>::reference get() { return m_x; } + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct tuple_element<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>, 10> : tuple_type<A10> { + tuple_element(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 >& x) : m_x(x.a10) {} + typename tuple_type<A10>::reference get() { return m_x; } + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct tuple_element<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>, 11> : tuple_type<A11> { + tuple_element(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 >& x) : m_x(x.a11) {} + typename tuple_type<A11>::reference get() { return m_x; } + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct tuple_element<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>, 12> : tuple_type<A12> { + tuple_element(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 >& x) : m_x(x.a12) {} + typename tuple_type<A12>::reference get() { return m_x; } + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct tuple_element<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>, 13> : tuple_type<A13> { + tuple_element(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 >& x) : m_x(x.a13) {} + typename tuple_type<A13>::reference get() { return m_x; } + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct tuple_element<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>, 14> : tuple_type<A14> { + tuple_element(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 >& x) : m_x(x.a14) {} + typename tuple_type<A14>::reference get() { return m_x; } + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct tuple_element<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>, 15> : tuple_type<A15> { + tuple_element(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 >& x) : m_x(x.a15) {} + typename tuple_type<A15>::reference get() { return m_x; } + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct tuple_element<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>, 16> : tuple_type<A16> { + tuple_element(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 >& x) : m_x(x.a16) {} + typename tuple_type<A16>::reference get() { return m_x; } + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct tuple_element<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>, 17> : tuple_type<A17> { + tuple_element(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 >& x) : m_x(x.a17) {} + typename tuple_type<A17>::reference get() { return m_x; } + typename tuple_type<A17>::const_reference get() const { return m_x; } +private: + typename tuple_type<A17>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct tuple_element<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>, 18> : tuple_type<A18> { + tuple_element(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 >& x) : m_x(x.a18) {} + typename tuple_type<A18>::reference get() { return m_x; } + typename tuple_type<A18>::const_reference get() const { return m_x; } +private: + typename tuple_type<A18>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct tuple_element<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>, 19> : tuple_type<A19> { + tuple_element(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 >& x) : m_x(x.a19) {} + typename tuple_type<A19>::reference get() { return m_x; } + typename tuple_type<A19>::const_reference get() const { return m_x; } +private: + typename tuple_type<A19>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct tuple_element<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>, 20> : tuple_type<A20> { + tuple_element(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 >& x) : m_x(x.a20) {} + typename tuple_type<A20>::reference get() { return m_x; } + typename tuple_type<A20>::const_reference get() const { return m_x; } +private: + typename tuple_type<A20>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct tuple_element<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>, 21> : tuple_type<A21> { + tuple_element(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 >& x) : m_x(x.a21) {} + typename tuple_type<A21>::reference get() { return m_x; } + typename tuple_type<A21>::const_reference get() const { return m_x; } +private: + typename tuple_type<A21>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct tuple_element<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>, 22> : tuple_type<A22> { + tuple_element(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 >& x) : m_x(x.a22) {} + typename tuple_type<A22>::reference get() { return m_x; } + typename tuple_type<A22>::const_reference get() const { return m_x; } +private: + typename tuple_type<A22>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct tuple_element<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>, 23> : tuple_type<A23> { + tuple_element(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 >& x) : m_x(x.a23) {} + typename tuple_type<A23>::reference get() { return m_x; } + typename tuple_type<A23>::const_reference get() const { return m_x; } +private: + typename tuple_type<A23>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct tuple_element<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>, 24> : tuple_type<A24> { + tuple_element(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 >& x) : m_x(x.a24) {} + typename tuple_type<A24>::reference get() { return m_x; } + typename tuple_type<A24>::const_reference get() const { return m_x; } +private: + typename tuple_type<A24>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct tuple_element<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>, 25> : tuple_type<A25> { + tuple_element(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 >& x) : m_x(x.a25) {} + typename tuple_type<A25>::reference get() { return m_x; } + typename tuple_type<A25>::const_reference get() const { return m_x; } +private: + typename tuple_type<A25>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct tuple_element<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>, 26> : tuple_type<A26> { + tuple_element(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 >& x) : m_x(x.a26) {} + typename tuple_type<A26>::reference get() { return m_x; } + typename tuple_type<A26>::const_reference get() const { return m_x; } +private: + typename tuple_type<A26>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct tuple_element<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>, 27> : tuple_type<A27> { + tuple_element(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 >& x) : m_x(x.a27) {} + typename tuple_type<A27>::reference get() { return m_x; } + typename tuple_type<A27>::const_reference get() const { return m_x; } +private: + typename tuple_type<A27>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct tuple_element<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>, 28> : tuple_type<A28> { + tuple_element(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 >& x) : m_x(x.a28) {} + typename tuple_type<A28>::reference get() { return m_x; } + typename tuple_type<A28>::const_reference get() const { return m_x; } +private: + typename tuple_type<A28>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct tuple_element<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>, 29> : tuple_type<A29> { + tuple_element(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 >& x) : m_x(x.a29) {} + typename tuple_type<A29>::reference get() { return m_x; } + typename tuple_type<A29>::const_reference get() const { return m_x; } +private: + typename tuple_type<A29>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct tuple_element<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>, 30> : tuple_type<A30> { + tuple_element(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 >& x) : m_x(x.a30) {} + typename tuple_type<A30>::reference get() { return m_x; } + typename tuple_type<A30>::const_reference get() const { return m_x; } +private: + typename tuple_type<A30>::reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 0> : tuple_type<A0> { + tuple_element(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 >& x) : m_x(x.a0) {} + typename tuple_type<A0>::reference get() { return m_x; } + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 1> : tuple_type<A1> { + tuple_element(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 >& x) : m_x(x.a1) {} + typename tuple_type<A1>::reference get() { return m_x; } + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 2> : tuple_type<A2> { + tuple_element(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 >& x) : m_x(x.a2) {} + typename tuple_type<A2>::reference get() { return m_x; } + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 3> : tuple_type<A3> { + tuple_element(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 >& x) : m_x(x.a3) {} + typename tuple_type<A3>::reference get() { return m_x; } + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 4> : tuple_type<A4> { + tuple_element(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 >& x) : m_x(x.a4) {} + typename tuple_type<A4>::reference get() { return m_x; } + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 5> : tuple_type<A5> { + tuple_element(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 >& x) : m_x(x.a5) {} + typename tuple_type<A5>::reference get() { return m_x; } + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 6> : tuple_type<A6> { + tuple_element(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 >& x) : m_x(x.a6) {} + typename tuple_type<A6>::reference get() { return m_x; } + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 7> : tuple_type<A7> { + tuple_element(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 >& x) : m_x(x.a7) {} + typename tuple_type<A7>::reference get() { return m_x; } + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 8> : tuple_type<A8> { + tuple_element(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 >& x) : m_x(x.a8) {} + typename tuple_type<A8>::reference get() { return m_x; } + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 9> : tuple_type<A9> { + tuple_element(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 >& x) : m_x(x.a9) {} + typename tuple_type<A9>::reference get() { return m_x; } + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 10> : tuple_type<A10> { + tuple_element(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 >& x) : m_x(x.a10) {} + typename tuple_type<A10>::reference get() { return m_x; } + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 11> : tuple_type<A11> { + tuple_element(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 >& x) : m_x(x.a11) {} + typename tuple_type<A11>::reference get() { return m_x; } + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 12> : tuple_type<A12> { + tuple_element(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 >& x) : m_x(x.a12) {} + typename tuple_type<A12>::reference get() { return m_x; } + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 13> : tuple_type<A13> { + tuple_element(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 >& x) : m_x(x.a13) {} + typename tuple_type<A13>::reference get() { return m_x; } + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 14> : tuple_type<A14> { + tuple_element(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 >& x) : m_x(x.a14) {} + typename tuple_type<A14>::reference get() { return m_x; } + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 15> : tuple_type<A15> { + tuple_element(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 >& x) : m_x(x.a15) {} + typename tuple_type<A15>::reference get() { return m_x; } + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 16> : tuple_type<A16> { + tuple_element(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 >& x) : m_x(x.a16) {} + typename tuple_type<A16>::reference get() { return m_x; } + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 17> : tuple_type<A17> { + tuple_element(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 >& x) : m_x(x.a17) {} + typename tuple_type<A17>::reference get() { return m_x; } + typename tuple_type<A17>::const_reference get() const { return m_x; } +private: + typename tuple_type<A17>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 18> : tuple_type<A18> { + tuple_element(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 >& x) : m_x(x.a18) {} + typename tuple_type<A18>::reference get() { return m_x; } + typename tuple_type<A18>::const_reference get() const { return m_x; } +private: + typename tuple_type<A18>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 19> : tuple_type<A19> { + tuple_element(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 >& x) : m_x(x.a19) {} + typename tuple_type<A19>::reference get() { return m_x; } + typename tuple_type<A19>::const_reference get() const { return m_x; } +private: + typename tuple_type<A19>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 20> : tuple_type<A20> { + tuple_element(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 >& x) : m_x(x.a20) {} + typename tuple_type<A20>::reference get() { return m_x; } + typename tuple_type<A20>::const_reference get() const { return m_x; } +private: + typename tuple_type<A20>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 21> : tuple_type<A21> { + tuple_element(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 >& x) : m_x(x.a21) {} + typename tuple_type<A21>::reference get() { return m_x; } + typename tuple_type<A21>::const_reference get() const { return m_x; } +private: + typename tuple_type<A21>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 22> : tuple_type<A22> { + tuple_element(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 >& x) : m_x(x.a22) {} + typename tuple_type<A22>::reference get() { return m_x; } + typename tuple_type<A22>::const_reference get() const { return m_x; } +private: + typename tuple_type<A22>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 23> : tuple_type<A23> { + tuple_element(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 >& x) : m_x(x.a23) {} + typename tuple_type<A23>::reference get() { return m_x; } + typename tuple_type<A23>::const_reference get() const { return m_x; } +private: + typename tuple_type<A23>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 24> : tuple_type<A24> { + tuple_element(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 >& x) : m_x(x.a24) {} + typename tuple_type<A24>::reference get() { return m_x; } + typename tuple_type<A24>::const_reference get() const { return m_x; } +private: + typename tuple_type<A24>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 25> : tuple_type<A25> { + tuple_element(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 >& x) : m_x(x.a25) {} + typename tuple_type<A25>::reference get() { return m_x; } + typename tuple_type<A25>::const_reference get() const { return m_x; } +private: + typename tuple_type<A25>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 26> : tuple_type<A26> { + tuple_element(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 >& x) : m_x(x.a26) {} + typename tuple_type<A26>::reference get() { return m_x; } + typename tuple_type<A26>::const_reference get() const { return m_x; } +private: + typename tuple_type<A26>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 27> : tuple_type<A27> { + tuple_element(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 >& x) : m_x(x.a27) {} + typename tuple_type<A27>::reference get() { return m_x; } + typename tuple_type<A27>::const_reference get() const { return m_x; } +private: + typename tuple_type<A27>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 28> : tuple_type<A28> { + tuple_element(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 >& x) : m_x(x.a28) {} + typename tuple_type<A28>::reference get() { return m_x; } + typename tuple_type<A28>::const_reference get() const { return m_x; } +private: + typename tuple_type<A28>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 29> : tuple_type<A29> { + tuple_element(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 >& x) : m_x(x.a29) {} + typename tuple_type<A29>::reference get() { return m_x; } + typename tuple_type<A29>::const_reference get() const { return m_x; } +private: + typename tuple_type<A29>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 30> : tuple_type<A30> { + tuple_element(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 >& x) : m_x(x.a30) {} + typename tuple_type<A30>::reference get() { return m_x; } + typename tuple_type<A30>::const_reference get() const { return m_x; } +private: + typename tuple_type<A30>::reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct tuple_element<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>, 31> : tuple_type<A31> { + tuple_element(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 >& x) : m_x(x.a31) {} + typename tuple_type<A31>::reference get() { return m_x; } + typename tuple_type<A31>::const_reference get() const { return m_x; } +private: + typename tuple_type<A31>::reference m_x; +}; + + + + + +template <typename A0> +struct const_tuple_element<tuple<A0>, 0> : tuple_type<A0> { + const_tuple_element(const tuple<A0>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + + + +template <typename A0, typename A1> +struct const_tuple_element<tuple<A0, A1>, 0> : tuple_type<A0> { + const_tuple_element(const tuple<A0, A1>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + +template <typename A0, typename A1> +struct const_tuple_element<tuple<A0, A1>, 1> : tuple_type<A1> { + const_tuple_element(const tuple<A0, A1>& x) : m_x(x.a1) {} + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::const_reference m_x; +}; + + + +template <typename A0, typename A1, typename A2> +struct const_tuple_element<tuple<A0, A1, A2>, 0> : tuple_type<A0> { + const_tuple_element(const tuple<A0, A1, A2>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2> +struct const_tuple_element<tuple<A0, A1, A2>, 1> : tuple_type<A1> { + const_tuple_element(const tuple<A0, A1, A2>& x) : m_x(x.a1) {} + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2> +struct const_tuple_element<tuple<A0, A1, A2>, 2> : tuple_type<A2> { + const_tuple_element(const tuple<A0, A1, A2>& x) : m_x(x.a2) {} + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::const_reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3> +struct const_tuple_element<tuple<A0, A1, A2, A3>, 0> : tuple_type<A0> { + const_tuple_element(const tuple<A0, A1, A2, A3>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3> +struct const_tuple_element<tuple<A0, A1, A2, A3>, 1> : tuple_type<A1> { + const_tuple_element(const tuple<A0, A1, A2, A3>& x) : m_x(x.a1) {} + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3> +struct const_tuple_element<tuple<A0, A1, A2, A3>, 2> : tuple_type<A2> { + const_tuple_element(const tuple<A0, A1, A2, A3>& x) : m_x(x.a2) {} + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3> +struct const_tuple_element<tuple<A0, A1, A2, A3>, 3> : tuple_type<A3> { + const_tuple_element(const tuple<A0, A1, A2, A3>& x) : m_x(x.a3) {} + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::const_reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4>, 0> : tuple_type<A0> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4>, 1> : tuple_type<A1> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4>& x) : m_x(x.a1) {} + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4>, 2> : tuple_type<A2> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4>& x) : m_x(x.a2) {} + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4>, 3> : tuple_type<A3> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4>& x) : m_x(x.a3) {} + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4>, 4> : tuple_type<A4> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4>& x) : m_x(x.a4) {} + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::const_reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5>, 0> : tuple_type<A0> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5>, 1> : tuple_type<A1> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5>& x) : m_x(x.a1) {} + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5>, 2> : tuple_type<A2> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5>& x) : m_x(x.a2) {} + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5>, 3> : tuple_type<A3> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5>& x) : m_x(x.a3) {} + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5>, 4> : tuple_type<A4> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5>& x) : m_x(x.a4) {} + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5>, 5> : tuple_type<A5> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5>& x) : m_x(x.a5) {} + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::const_reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6>, 0> : tuple_type<A0> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6>, 1> : tuple_type<A1> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6>& x) : m_x(x.a1) {} + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6>, 2> : tuple_type<A2> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6>& x) : m_x(x.a2) {} + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6>, 3> : tuple_type<A3> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6>& x) : m_x(x.a3) {} + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6>, 4> : tuple_type<A4> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6>& x) : m_x(x.a4) {} + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6>, 5> : tuple_type<A5> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6>& x) : m_x(x.a5) {} + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6>, 6> : tuple_type<A6> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6>& x) : m_x(x.a6) {} + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::const_reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7>, 0> : tuple_type<A0> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7>, 1> : tuple_type<A1> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7>& x) : m_x(x.a1) {} + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7>, 2> : tuple_type<A2> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7>& x) : m_x(x.a2) {} + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7>, 3> : tuple_type<A3> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7>& x) : m_x(x.a3) {} + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7>, 4> : tuple_type<A4> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7>& x) : m_x(x.a4) {} + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7>, 5> : tuple_type<A5> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7>& x) : m_x(x.a5) {} + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7>, 6> : tuple_type<A6> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7>& x) : m_x(x.a6) {} + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7>, 7> : tuple_type<A7> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7>& x) : m_x(x.a7) {} + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::const_reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>, 0> : tuple_type<A0> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>, 1> : tuple_type<A1> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>& x) : m_x(x.a1) {} + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>, 2> : tuple_type<A2> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>& x) : m_x(x.a2) {} + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>, 3> : tuple_type<A3> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>& x) : m_x(x.a3) {} + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>, 4> : tuple_type<A4> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>& x) : m_x(x.a4) {} + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>, 5> : tuple_type<A5> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>& x) : m_x(x.a5) {} + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>, 6> : tuple_type<A6> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>& x) : m_x(x.a6) {} + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>, 7> : tuple_type<A7> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>& x) : m_x(x.a7) {} + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>, 8> : tuple_type<A8> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>& x) : m_x(x.a8) {} + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::const_reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>, 0> : tuple_type<A0> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>, 1> : tuple_type<A1> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>& x) : m_x(x.a1) {} + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>, 2> : tuple_type<A2> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>& x) : m_x(x.a2) {} + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>, 3> : tuple_type<A3> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>& x) : m_x(x.a3) {} + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>, 4> : tuple_type<A4> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>& x) : m_x(x.a4) {} + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>, 5> : tuple_type<A5> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>& x) : m_x(x.a5) {} + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>, 6> : tuple_type<A6> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>& x) : m_x(x.a6) {} + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>, 7> : tuple_type<A7> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>& x) : m_x(x.a7) {} + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>, 8> : tuple_type<A8> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>& x) : m_x(x.a8) {} + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>, 9> : tuple_type<A9> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>& x) : m_x(x.a9) {} + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::const_reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>, 0> : tuple_type<A0> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>, 1> : tuple_type<A1> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>& x) : m_x(x.a1) {} + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>, 2> : tuple_type<A2> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>& x) : m_x(x.a2) {} + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>, 3> : tuple_type<A3> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>& x) : m_x(x.a3) {} + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>, 4> : tuple_type<A4> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>& x) : m_x(x.a4) {} + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>, 5> : tuple_type<A5> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>& x) : m_x(x.a5) {} + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>, 6> : tuple_type<A6> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>& x) : m_x(x.a6) {} + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>, 7> : tuple_type<A7> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>& x) : m_x(x.a7) {} + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>, 8> : tuple_type<A8> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>& x) : m_x(x.a8) {} + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>, 9> : tuple_type<A9> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>& x) : m_x(x.a9) {} + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>, 10> : tuple_type<A10> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>& x) : m_x(x.a10) {} + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::const_reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>, 0> : tuple_type<A0> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>, 1> : tuple_type<A1> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>& x) : m_x(x.a1) {} + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>, 2> : tuple_type<A2> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>& x) : m_x(x.a2) {} + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>, 3> : tuple_type<A3> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>& x) : m_x(x.a3) {} + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>, 4> : tuple_type<A4> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>& x) : m_x(x.a4) {} + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>, 5> : tuple_type<A5> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>& x) : m_x(x.a5) {} + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>, 6> : tuple_type<A6> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>& x) : m_x(x.a6) {} + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>, 7> : tuple_type<A7> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>& x) : m_x(x.a7) {} + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>, 8> : tuple_type<A8> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>& x) : m_x(x.a8) {} + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>, 9> : tuple_type<A9> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>& x) : m_x(x.a9) {} + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>, 10> : tuple_type<A10> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>& x) : m_x(x.a10) {} + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>, 11> : tuple_type<A11> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>& x) : m_x(x.a11) {} + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::const_reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>, 0> : tuple_type<A0> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>, 1> : tuple_type<A1> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>& x) : m_x(x.a1) {} + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>, 2> : tuple_type<A2> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>& x) : m_x(x.a2) {} + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>, 3> : tuple_type<A3> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>& x) : m_x(x.a3) {} + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>, 4> : tuple_type<A4> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>& x) : m_x(x.a4) {} + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>, 5> : tuple_type<A5> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>& x) : m_x(x.a5) {} + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>, 6> : tuple_type<A6> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>& x) : m_x(x.a6) {} + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>, 7> : tuple_type<A7> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>& x) : m_x(x.a7) {} + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>, 8> : tuple_type<A8> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>& x) : m_x(x.a8) {} + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>, 9> : tuple_type<A9> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>& x) : m_x(x.a9) {} + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>, 10> : tuple_type<A10> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>& x) : m_x(x.a10) {} + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>, 11> : tuple_type<A11> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>& x) : m_x(x.a11) {} + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>, 12> : tuple_type<A12> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>& x) : m_x(x.a12) {} + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::const_reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>, 0> : tuple_type<A0> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>, 1> : tuple_type<A1> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>& x) : m_x(x.a1) {} + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>, 2> : tuple_type<A2> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>& x) : m_x(x.a2) {} + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>, 3> : tuple_type<A3> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>& x) : m_x(x.a3) {} + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>, 4> : tuple_type<A4> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>& x) : m_x(x.a4) {} + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>, 5> : tuple_type<A5> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>& x) : m_x(x.a5) {} + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>, 6> : tuple_type<A6> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>& x) : m_x(x.a6) {} + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>, 7> : tuple_type<A7> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>& x) : m_x(x.a7) {} + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>, 8> : tuple_type<A8> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>& x) : m_x(x.a8) {} + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>, 9> : tuple_type<A9> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>& x) : m_x(x.a9) {} + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>, 10> : tuple_type<A10> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>& x) : m_x(x.a10) {} + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>, 11> : tuple_type<A11> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>& x) : m_x(x.a11) {} + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>, 12> : tuple_type<A12> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>& x) : m_x(x.a12) {} + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>, 13> : tuple_type<A13> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>& x) : m_x(x.a13) {} + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::const_reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, 0> : tuple_type<A0> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, 1> : tuple_type<A1> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>& x) : m_x(x.a1) {} + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, 2> : tuple_type<A2> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>& x) : m_x(x.a2) {} + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, 3> : tuple_type<A3> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>& x) : m_x(x.a3) {} + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, 4> : tuple_type<A4> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>& x) : m_x(x.a4) {} + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, 5> : tuple_type<A5> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>& x) : m_x(x.a5) {} + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, 6> : tuple_type<A6> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>& x) : m_x(x.a6) {} + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, 7> : tuple_type<A7> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>& x) : m_x(x.a7) {} + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, 8> : tuple_type<A8> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>& x) : m_x(x.a8) {} + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, 9> : tuple_type<A9> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>& x) : m_x(x.a9) {} + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, 10> : tuple_type<A10> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>& x) : m_x(x.a10) {} + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, 11> : tuple_type<A11> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>& x) : m_x(x.a11) {} + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, 12> : tuple_type<A12> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>& x) : m_x(x.a12) {} + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, 13> : tuple_type<A13> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>& x) : m_x(x.a13) {} + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, 14> : tuple_type<A14> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>& x) : m_x(x.a14) {} + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::const_reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 0> : tuple_type<A0> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 1> : tuple_type<A1> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>& x) : m_x(x.a1) {} + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 2> : tuple_type<A2> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>& x) : m_x(x.a2) {} + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 3> : tuple_type<A3> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>& x) : m_x(x.a3) {} + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 4> : tuple_type<A4> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>& x) : m_x(x.a4) {} + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 5> : tuple_type<A5> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>& x) : m_x(x.a5) {} + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 6> : tuple_type<A6> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>& x) : m_x(x.a6) {} + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 7> : tuple_type<A7> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>& x) : m_x(x.a7) {} + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 8> : tuple_type<A8> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>& x) : m_x(x.a8) {} + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 9> : tuple_type<A9> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>& x) : m_x(x.a9) {} + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 10> : tuple_type<A10> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>& x) : m_x(x.a10) {} + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 11> : tuple_type<A11> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>& x) : m_x(x.a11) {} + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 12> : tuple_type<A12> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>& x) : m_x(x.a12) {} + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 13> : tuple_type<A13> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>& x) : m_x(x.a13) {} + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 14> : tuple_type<A14> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>& x) : m_x(x.a14) {} + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, 15> : tuple_type<A15> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>& x) : m_x(x.a15) {} + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::const_reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 0> : tuple_type<A0> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 1> : tuple_type<A1> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>& x) : m_x(x.a1) {} + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 2> : tuple_type<A2> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>& x) : m_x(x.a2) {} + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 3> : tuple_type<A3> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>& x) : m_x(x.a3) {} + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 4> : tuple_type<A4> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>& x) : m_x(x.a4) {} + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 5> : tuple_type<A5> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>& x) : m_x(x.a5) {} + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 6> : tuple_type<A6> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>& x) : m_x(x.a6) {} + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 7> : tuple_type<A7> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>& x) : m_x(x.a7) {} + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 8> : tuple_type<A8> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>& x) : m_x(x.a8) {} + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 9> : tuple_type<A9> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>& x) : m_x(x.a9) {} + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 10> : tuple_type<A10> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>& x) : m_x(x.a10) {} + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 11> : tuple_type<A11> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>& x) : m_x(x.a11) {} + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 12> : tuple_type<A12> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>& x) : m_x(x.a12) {} + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 13> : tuple_type<A13> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>& x) : m_x(x.a13) {} + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 14> : tuple_type<A14> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>& x) : m_x(x.a14) {} + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 15> : tuple_type<A15> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>& x) : m_x(x.a15) {} + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, 16> : tuple_type<A16> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>& x) : m_x(x.a16) {} + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::const_reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 0> : tuple_type<A0> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 1> : tuple_type<A1> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>& x) : m_x(x.a1) {} + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 2> : tuple_type<A2> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>& x) : m_x(x.a2) {} + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 3> : tuple_type<A3> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>& x) : m_x(x.a3) {} + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 4> : tuple_type<A4> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>& x) : m_x(x.a4) {} + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 5> : tuple_type<A5> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>& x) : m_x(x.a5) {} + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 6> : tuple_type<A6> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>& x) : m_x(x.a6) {} + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 7> : tuple_type<A7> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>& x) : m_x(x.a7) {} + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 8> : tuple_type<A8> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>& x) : m_x(x.a8) {} + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 9> : tuple_type<A9> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>& x) : m_x(x.a9) {} + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 10> : tuple_type<A10> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>& x) : m_x(x.a10) {} + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 11> : tuple_type<A11> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>& x) : m_x(x.a11) {} + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 12> : tuple_type<A12> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>& x) : m_x(x.a12) {} + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 13> : tuple_type<A13> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>& x) : m_x(x.a13) {} + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 14> : tuple_type<A14> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>& x) : m_x(x.a14) {} + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 15> : tuple_type<A15> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>& x) : m_x(x.a15) {} + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 16> : tuple_type<A16> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>& x) : m_x(x.a16) {} + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, 17> : tuple_type<A17> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>& x) : m_x(x.a17) {} + typename tuple_type<A17>::const_reference get() const { return m_x; } +private: + typename tuple_type<A17>::const_reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 0> : tuple_type<A0> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 1> : tuple_type<A1> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>& x) : m_x(x.a1) {} + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 2> : tuple_type<A2> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>& x) : m_x(x.a2) {} + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 3> : tuple_type<A3> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>& x) : m_x(x.a3) {} + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 4> : tuple_type<A4> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>& x) : m_x(x.a4) {} + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 5> : tuple_type<A5> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>& x) : m_x(x.a5) {} + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 6> : tuple_type<A6> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>& x) : m_x(x.a6) {} + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 7> : tuple_type<A7> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>& x) : m_x(x.a7) {} + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 8> : tuple_type<A8> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>& x) : m_x(x.a8) {} + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 9> : tuple_type<A9> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>& x) : m_x(x.a9) {} + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 10> : tuple_type<A10> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>& x) : m_x(x.a10) {} + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 11> : tuple_type<A11> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>& x) : m_x(x.a11) {} + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 12> : tuple_type<A12> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>& x) : m_x(x.a12) {} + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 13> : tuple_type<A13> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>& x) : m_x(x.a13) {} + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 14> : tuple_type<A14> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>& x) : m_x(x.a14) {} + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 15> : tuple_type<A15> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>& x) : m_x(x.a15) {} + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 16> : tuple_type<A16> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>& x) : m_x(x.a16) {} + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 17> : tuple_type<A17> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>& x) : m_x(x.a17) {} + typename tuple_type<A17>::const_reference get() const { return m_x; } +private: + typename tuple_type<A17>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, 18> : tuple_type<A18> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>& x) : m_x(x.a18) {} + typename tuple_type<A18>::const_reference get() const { return m_x; } +private: + typename tuple_type<A18>::const_reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 0> : tuple_type<A0> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 1> : tuple_type<A1> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>& x) : m_x(x.a1) {} + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 2> : tuple_type<A2> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>& x) : m_x(x.a2) {} + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 3> : tuple_type<A3> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>& x) : m_x(x.a3) {} + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 4> : tuple_type<A4> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>& x) : m_x(x.a4) {} + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 5> : tuple_type<A5> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>& x) : m_x(x.a5) {} + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 6> : tuple_type<A6> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>& x) : m_x(x.a6) {} + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 7> : tuple_type<A7> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>& x) : m_x(x.a7) {} + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 8> : tuple_type<A8> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>& x) : m_x(x.a8) {} + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 9> : tuple_type<A9> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>& x) : m_x(x.a9) {} + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 10> : tuple_type<A10> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>& x) : m_x(x.a10) {} + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 11> : tuple_type<A11> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>& x) : m_x(x.a11) {} + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 12> : tuple_type<A12> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>& x) : m_x(x.a12) {} + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 13> : tuple_type<A13> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>& x) : m_x(x.a13) {} + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 14> : tuple_type<A14> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>& x) : m_x(x.a14) {} + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 15> : tuple_type<A15> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>& x) : m_x(x.a15) {} + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 16> : tuple_type<A16> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>& x) : m_x(x.a16) {} + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 17> : tuple_type<A17> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>& x) : m_x(x.a17) {} + typename tuple_type<A17>::const_reference get() const { return m_x; } +private: + typename tuple_type<A17>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 18> : tuple_type<A18> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>& x) : m_x(x.a18) {} + typename tuple_type<A18>::const_reference get() const { return m_x; } +private: + typename tuple_type<A18>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, 19> : tuple_type<A19> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>& x) : m_x(x.a19) {} + typename tuple_type<A19>::const_reference get() const { return m_x; } +private: + typename tuple_type<A19>::const_reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 0> : tuple_type<A0> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 1> : tuple_type<A1> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& x) : m_x(x.a1) {} + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 2> : tuple_type<A2> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& x) : m_x(x.a2) {} + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 3> : tuple_type<A3> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& x) : m_x(x.a3) {} + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 4> : tuple_type<A4> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& x) : m_x(x.a4) {} + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 5> : tuple_type<A5> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& x) : m_x(x.a5) {} + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 6> : tuple_type<A6> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& x) : m_x(x.a6) {} + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 7> : tuple_type<A7> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& x) : m_x(x.a7) {} + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 8> : tuple_type<A8> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& x) : m_x(x.a8) {} + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 9> : tuple_type<A9> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& x) : m_x(x.a9) {} + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 10> : tuple_type<A10> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& x) : m_x(x.a10) {} + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 11> : tuple_type<A11> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& x) : m_x(x.a11) {} + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 12> : tuple_type<A12> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& x) : m_x(x.a12) {} + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 13> : tuple_type<A13> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& x) : m_x(x.a13) {} + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 14> : tuple_type<A14> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& x) : m_x(x.a14) {} + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 15> : tuple_type<A15> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& x) : m_x(x.a15) {} + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 16> : tuple_type<A16> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& x) : m_x(x.a16) {} + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 17> : tuple_type<A17> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& x) : m_x(x.a17) {} + typename tuple_type<A17>::const_reference get() const { return m_x; } +private: + typename tuple_type<A17>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 18> : tuple_type<A18> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& x) : m_x(x.a18) {} + typename tuple_type<A18>::const_reference get() const { return m_x; } +private: + typename tuple_type<A18>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 19> : tuple_type<A19> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& x) : m_x(x.a19) {} + typename tuple_type<A19>::const_reference get() const { return m_x; } +private: + typename tuple_type<A19>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, 20> : tuple_type<A20> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& x) : m_x(x.a20) {} + typename tuple_type<A20>::const_reference get() const { return m_x; } +private: + typename tuple_type<A20>::const_reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 0> : tuple_type<A0> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 1> : tuple_type<A1> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& x) : m_x(x.a1) {} + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 2> : tuple_type<A2> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& x) : m_x(x.a2) {} + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 3> : tuple_type<A3> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& x) : m_x(x.a3) {} + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 4> : tuple_type<A4> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& x) : m_x(x.a4) {} + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 5> : tuple_type<A5> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& x) : m_x(x.a5) {} + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 6> : tuple_type<A6> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& x) : m_x(x.a6) {} + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 7> : tuple_type<A7> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& x) : m_x(x.a7) {} + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 8> : tuple_type<A8> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& x) : m_x(x.a8) {} + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 9> : tuple_type<A9> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& x) : m_x(x.a9) {} + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 10> : tuple_type<A10> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& x) : m_x(x.a10) {} + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 11> : tuple_type<A11> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& x) : m_x(x.a11) {} + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 12> : tuple_type<A12> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& x) : m_x(x.a12) {} + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 13> : tuple_type<A13> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& x) : m_x(x.a13) {} + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 14> : tuple_type<A14> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& x) : m_x(x.a14) {} + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 15> : tuple_type<A15> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& x) : m_x(x.a15) {} + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 16> : tuple_type<A16> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& x) : m_x(x.a16) {} + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 17> : tuple_type<A17> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& x) : m_x(x.a17) {} + typename tuple_type<A17>::const_reference get() const { return m_x; } +private: + typename tuple_type<A17>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 18> : tuple_type<A18> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& x) : m_x(x.a18) {} + typename tuple_type<A18>::const_reference get() const { return m_x; } +private: + typename tuple_type<A18>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 19> : tuple_type<A19> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& x) : m_x(x.a19) {} + typename tuple_type<A19>::const_reference get() const { return m_x; } +private: + typename tuple_type<A19>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 20> : tuple_type<A20> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& x) : m_x(x.a20) {} + typename tuple_type<A20>::const_reference get() const { return m_x; } +private: + typename tuple_type<A20>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, 21> : tuple_type<A21> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& x) : m_x(x.a21) {} + typename tuple_type<A21>::const_reference get() const { return m_x; } +private: + typename tuple_type<A21>::const_reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 0> : tuple_type<A0> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 1> : tuple_type<A1> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& x) : m_x(x.a1) {} + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 2> : tuple_type<A2> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& x) : m_x(x.a2) {} + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 3> : tuple_type<A3> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& x) : m_x(x.a3) {} + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 4> : tuple_type<A4> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& x) : m_x(x.a4) {} + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 5> : tuple_type<A5> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& x) : m_x(x.a5) {} + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 6> : tuple_type<A6> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& x) : m_x(x.a6) {} + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 7> : tuple_type<A7> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& x) : m_x(x.a7) {} + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 8> : tuple_type<A8> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& x) : m_x(x.a8) {} + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 9> : tuple_type<A9> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& x) : m_x(x.a9) {} + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 10> : tuple_type<A10> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& x) : m_x(x.a10) {} + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 11> : tuple_type<A11> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& x) : m_x(x.a11) {} + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 12> : tuple_type<A12> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& x) : m_x(x.a12) {} + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 13> : tuple_type<A13> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& x) : m_x(x.a13) {} + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 14> : tuple_type<A14> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& x) : m_x(x.a14) {} + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 15> : tuple_type<A15> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& x) : m_x(x.a15) {} + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 16> : tuple_type<A16> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& x) : m_x(x.a16) {} + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 17> : tuple_type<A17> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& x) : m_x(x.a17) {} + typename tuple_type<A17>::const_reference get() const { return m_x; } +private: + typename tuple_type<A17>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 18> : tuple_type<A18> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& x) : m_x(x.a18) {} + typename tuple_type<A18>::const_reference get() const { return m_x; } +private: + typename tuple_type<A18>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 19> : tuple_type<A19> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& x) : m_x(x.a19) {} + typename tuple_type<A19>::const_reference get() const { return m_x; } +private: + typename tuple_type<A19>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 20> : tuple_type<A20> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& x) : m_x(x.a20) {} + typename tuple_type<A20>::const_reference get() const { return m_x; } +private: + typename tuple_type<A20>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 21> : tuple_type<A21> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& x) : m_x(x.a21) {} + typename tuple_type<A21>::const_reference get() const { return m_x; } +private: + typename tuple_type<A21>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct const_tuple_element<tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, 22> : tuple_type<A22> { + const_tuple_element(const tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& x) : m_x(x.a22) {} + typename tuple_type<A22>::const_reference get() const { return m_x; } +private: + typename tuple_type<A22>::const_reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct const_tuple_element<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>, 0> : tuple_type<A0> { + const_tuple_element(const 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>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct const_tuple_element<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>, 1> : tuple_type<A1> { + const_tuple_element(const 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>& x) : m_x(x.a1) {} + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct const_tuple_element<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>, 2> : tuple_type<A2> { + const_tuple_element(const 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>& x) : m_x(x.a2) {} + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct const_tuple_element<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>, 3> : tuple_type<A3> { + const_tuple_element(const 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>& x) : m_x(x.a3) {} + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct const_tuple_element<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>, 4> : tuple_type<A4> { + const_tuple_element(const 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>& x) : m_x(x.a4) {} + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct const_tuple_element<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>, 5> : tuple_type<A5> { + const_tuple_element(const 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>& x) : m_x(x.a5) {} + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct const_tuple_element<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>, 6> : tuple_type<A6> { + const_tuple_element(const 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>& x) : m_x(x.a6) {} + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct const_tuple_element<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>, 7> : tuple_type<A7> { + const_tuple_element(const 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>& x) : m_x(x.a7) {} + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct const_tuple_element<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>, 8> : tuple_type<A8> { + const_tuple_element(const 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>& x) : m_x(x.a8) {} + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct const_tuple_element<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>, 9> : tuple_type<A9> { + const_tuple_element(const 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>& x) : m_x(x.a9) {} + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct const_tuple_element<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>, 10> : tuple_type<A10> { + const_tuple_element(const 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>& x) : m_x(x.a10) {} + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct const_tuple_element<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>, 11> : tuple_type<A11> { + const_tuple_element(const 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>& x) : m_x(x.a11) {} + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct const_tuple_element<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>, 12> : tuple_type<A12> { + const_tuple_element(const 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>& x) : m_x(x.a12) {} + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct const_tuple_element<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>, 13> : tuple_type<A13> { + const_tuple_element(const 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>& x) : m_x(x.a13) {} + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct const_tuple_element<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>, 14> : tuple_type<A14> { + const_tuple_element(const 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>& x) : m_x(x.a14) {} + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct const_tuple_element<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>, 15> : tuple_type<A15> { + const_tuple_element(const 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>& x) : m_x(x.a15) {} + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct const_tuple_element<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>, 16> : tuple_type<A16> { + const_tuple_element(const 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>& x) : m_x(x.a16) {} + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct const_tuple_element<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>, 17> : tuple_type<A17> { + const_tuple_element(const 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>& x) : m_x(x.a17) {} + typename tuple_type<A17>::const_reference get() const { return m_x; } +private: + typename tuple_type<A17>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct const_tuple_element<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>, 18> : tuple_type<A18> { + const_tuple_element(const 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>& x) : m_x(x.a18) {} + typename tuple_type<A18>::const_reference get() const { return m_x; } +private: + typename tuple_type<A18>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct const_tuple_element<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>, 19> : tuple_type<A19> { + const_tuple_element(const 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>& x) : m_x(x.a19) {} + typename tuple_type<A19>::const_reference get() const { return m_x; } +private: + typename tuple_type<A19>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct const_tuple_element<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>, 20> : tuple_type<A20> { + const_tuple_element(const 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>& x) : m_x(x.a20) {} + typename tuple_type<A20>::const_reference get() const { return m_x; } +private: + typename tuple_type<A20>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct const_tuple_element<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>, 21> : tuple_type<A21> { + const_tuple_element(const 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>& x) : m_x(x.a21) {} + typename tuple_type<A21>::const_reference get() const { return m_x; } +private: + typename tuple_type<A21>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct const_tuple_element<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>, 22> : tuple_type<A22> { + const_tuple_element(const 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>& x) : m_x(x.a22) {} + typename tuple_type<A22>::const_reference get() const { return m_x; } +private: + typename tuple_type<A22>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct const_tuple_element<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>, 23> : tuple_type<A23> { + const_tuple_element(const 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>& x) : m_x(x.a23) {} + typename tuple_type<A23>::const_reference get() const { return m_x; } +private: + typename tuple_type<A23>::const_reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct const_tuple_element<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>, 0> : tuple_type<A0> { + const_tuple_element(const 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>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct const_tuple_element<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>, 1> : tuple_type<A1> { + const_tuple_element(const 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>& x) : m_x(x.a1) {} + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct const_tuple_element<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>, 2> : tuple_type<A2> { + const_tuple_element(const 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>& x) : m_x(x.a2) {} + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct const_tuple_element<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>, 3> : tuple_type<A3> { + const_tuple_element(const 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>& x) : m_x(x.a3) {} + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct const_tuple_element<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>, 4> : tuple_type<A4> { + const_tuple_element(const 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>& x) : m_x(x.a4) {} + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct const_tuple_element<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>, 5> : tuple_type<A5> { + const_tuple_element(const 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>& x) : m_x(x.a5) {} + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct const_tuple_element<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>, 6> : tuple_type<A6> { + const_tuple_element(const 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>& x) : m_x(x.a6) {} + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct const_tuple_element<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>, 7> : tuple_type<A7> { + const_tuple_element(const 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>& x) : m_x(x.a7) {} + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct const_tuple_element<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>, 8> : tuple_type<A8> { + const_tuple_element(const 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>& x) : m_x(x.a8) {} + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct const_tuple_element<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>, 9> : tuple_type<A9> { + const_tuple_element(const 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>& x) : m_x(x.a9) {} + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct const_tuple_element<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>, 10> : tuple_type<A10> { + const_tuple_element(const 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>& x) : m_x(x.a10) {} + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct const_tuple_element<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>, 11> : tuple_type<A11> { + const_tuple_element(const 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>& x) : m_x(x.a11) {} + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct const_tuple_element<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>, 12> : tuple_type<A12> { + const_tuple_element(const 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>& x) : m_x(x.a12) {} + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct const_tuple_element<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>, 13> : tuple_type<A13> { + const_tuple_element(const 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>& x) : m_x(x.a13) {} + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct const_tuple_element<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>, 14> : tuple_type<A14> { + const_tuple_element(const 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>& x) : m_x(x.a14) {} + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct const_tuple_element<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>, 15> : tuple_type<A15> { + const_tuple_element(const 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>& x) : m_x(x.a15) {} + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct const_tuple_element<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>, 16> : tuple_type<A16> { + const_tuple_element(const 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>& x) : m_x(x.a16) {} + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct const_tuple_element<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>, 17> : tuple_type<A17> { + const_tuple_element(const 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>& x) : m_x(x.a17) {} + typename tuple_type<A17>::const_reference get() const { return m_x; } +private: + typename tuple_type<A17>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct const_tuple_element<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>, 18> : tuple_type<A18> { + const_tuple_element(const 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>& x) : m_x(x.a18) {} + typename tuple_type<A18>::const_reference get() const { return m_x; } +private: + typename tuple_type<A18>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct const_tuple_element<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>, 19> : tuple_type<A19> { + const_tuple_element(const 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>& x) : m_x(x.a19) {} + typename tuple_type<A19>::const_reference get() const { return m_x; } +private: + typename tuple_type<A19>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct const_tuple_element<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>, 20> : tuple_type<A20> { + const_tuple_element(const 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>& x) : m_x(x.a20) {} + typename tuple_type<A20>::const_reference get() const { return m_x; } +private: + typename tuple_type<A20>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct const_tuple_element<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>, 21> : tuple_type<A21> { + const_tuple_element(const 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>& x) : m_x(x.a21) {} + typename tuple_type<A21>::const_reference get() const { return m_x; } +private: + typename tuple_type<A21>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct const_tuple_element<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>, 22> : tuple_type<A22> { + const_tuple_element(const 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>& x) : m_x(x.a22) {} + typename tuple_type<A22>::const_reference get() const { return m_x; } +private: + typename tuple_type<A22>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct const_tuple_element<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>, 23> : tuple_type<A23> { + const_tuple_element(const 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>& x) : m_x(x.a23) {} + typename tuple_type<A23>::const_reference get() const { return m_x; } +private: + typename tuple_type<A23>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct const_tuple_element<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>, 24> : tuple_type<A24> { + const_tuple_element(const 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>& x) : m_x(x.a24) {} + typename tuple_type<A24>::const_reference get() const { return m_x; } +private: + typename tuple_type<A24>::const_reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct const_tuple_element<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>, 0> : tuple_type<A0> { + const_tuple_element(const 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>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct const_tuple_element<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>, 1> : tuple_type<A1> { + const_tuple_element(const 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>& x) : m_x(x.a1) {} + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct const_tuple_element<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>, 2> : tuple_type<A2> { + const_tuple_element(const 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>& x) : m_x(x.a2) {} + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct const_tuple_element<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>, 3> : tuple_type<A3> { + const_tuple_element(const 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>& x) : m_x(x.a3) {} + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct const_tuple_element<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>, 4> : tuple_type<A4> { + const_tuple_element(const 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>& x) : m_x(x.a4) {} + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct const_tuple_element<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>, 5> : tuple_type<A5> { + const_tuple_element(const 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>& x) : m_x(x.a5) {} + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct const_tuple_element<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>, 6> : tuple_type<A6> { + const_tuple_element(const 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>& x) : m_x(x.a6) {} + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct const_tuple_element<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>, 7> : tuple_type<A7> { + const_tuple_element(const 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>& x) : m_x(x.a7) {} + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct const_tuple_element<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>, 8> : tuple_type<A8> { + const_tuple_element(const 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>& x) : m_x(x.a8) {} + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct const_tuple_element<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>, 9> : tuple_type<A9> { + const_tuple_element(const 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>& x) : m_x(x.a9) {} + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct const_tuple_element<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>, 10> : tuple_type<A10> { + const_tuple_element(const 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>& x) : m_x(x.a10) {} + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct const_tuple_element<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>, 11> : tuple_type<A11> { + const_tuple_element(const 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>& x) : m_x(x.a11) {} + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct const_tuple_element<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>, 12> : tuple_type<A12> { + const_tuple_element(const 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>& x) : m_x(x.a12) {} + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct const_tuple_element<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>, 13> : tuple_type<A13> { + const_tuple_element(const 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>& x) : m_x(x.a13) {} + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct const_tuple_element<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>, 14> : tuple_type<A14> { + const_tuple_element(const 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>& x) : m_x(x.a14) {} + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct const_tuple_element<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>, 15> : tuple_type<A15> { + const_tuple_element(const 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>& x) : m_x(x.a15) {} + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct const_tuple_element<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>, 16> : tuple_type<A16> { + const_tuple_element(const 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>& x) : m_x(x.a16) {} + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct const_tuple_element<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>, 17> : tuple_type<A17> { + const_tuple_element(const 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>& x) : m_x(x.a17) {} + typename tuple_type<A17>::const_reference get() const { return m_x; } +private: + typename tuple_type<A17>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct const_tuple_element<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>, 18> : tuple_type<A18> { + const_tuple_element(const 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>& x) : m_x(x.a18) {} + typename tuple_type<A18>::const_reference get() const { return m_x; } +private: + typename tuple_type<A18>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct const_tuple_element<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>, 19> : tuple_type<A19> { + const_tuple_element(const 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>& x) : m_x(x.a19) {} + typename tuple_type<A19>::const_reference get() const { return m_x; } +private: + typename tuple_type<A19>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct const_tuple_element<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>, 20> : tuple_type<A20> { + const_tuple_element(const 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>& x) : m_x(x.a20) {} + typename tuple_type<A20>::const_reference get() const { return m_x; } +private: + typename tuple_type<A20>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct const_tuple_element<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>, 21> : tuple_type<A21> { + const_tuple_element(const 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>& x) : m_x(x.a21) {} + typename tuple_type<A21>::const_reference get() const { return m_x; } +private: + typename tuple_type<A21>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct const_tuple_element<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>, 22> : tuple_type<A22> { + const_tuple_element(const 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>& x) : m_x(x.a22) {} + typename tuple_type<A22>::const_reference get() const { return m_x; } +private: + typename tuple_type<A22>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct const_tuple_element<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>, 23> : tuple_type<A23> { + const_tuple_element(const 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>& x) : m_x(x.a23) {} + typename tuple_type<A23>::const_reference get() const { return m_x; } +private: + typename tuple_type<A23>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct const_tuple_element<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>, 24> : tuple_type<A24> { + const_tuple_element(const 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>& x) : m_x(x.a24) {} + typename tuple_type<A24>::const_reference get() const { return m_x; } +private: + typename tuple_type<A24>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct const_tuple_element<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>, 25> : tuple_type<A25> { + const_tuple_element(const 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>& x) : m_x(x.a25) {} + typename tuple_type<A25>::const_reference get() const { return m_x; } +private: + typename tuple_type<A25>::const_reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct const_tuple_element<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>, 0> : tuple_type<A0> { + const_tuple_element(const 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>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct const_tuple_element<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>, 1> : tuple_type<A1> { + const_tuple_element(const 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>& x) : m_x(x.a1) {} + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct const_tuple_element<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>, 2> : tuple_type<A2> { + const_tuple_element(const 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>& x) : m_x(x.a2) {} + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct const_tuple_element<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>, 3> : tuple_type<A3> { + const_tuple_element(const 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>& x) : m_x(x.a3) {} + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct const_tuple_element<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>, 4> : tuple_type<A4> { + const_tuple_element(const 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>& x) : m_x(x.a4) {} + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct const_tuple_element<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>, 5> : tuple_type<A5> { + const_tuple_element(const 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>& x) : m_x(x.a5) {} + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct const_tuple_element<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>, 6> : tuple_type<A6> { + const_tuple_element(const 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>& x) : m_x(x.a6) {} + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct const_tuple_element<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>, 7> : tuple_type<A7> { + const_tuple_element(const 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>& x) : m_x(x.a7) {} + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct const_tuple_element<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>, 8> : tuple_type<A8> { + const_tuple_element(const 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>& x) : m_x(x.a8) {} + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct const_tuple_element<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>, 9> : tuple_type<A9> { + const_tuple_element(const 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>& x) : m_x(x.a9) {} + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct const_tuple_element<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>, 10> : tuple_type<A10> { + const_tuple_element(const 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>& x) : m_x(x.a10) {} + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct const_tuple_element<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>, 11> : tuple_type<A11> { + const_tuple_element(const 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>& x) : m_x(x.a11) {} + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct const_tuple_element<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>, 12> : tuple_type<A12> { + const_tuple_element(const 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>& x) : m_x(x.a12) {} + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct const_tuple_element<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>, 13> : tuple_type<A13> { + const_tuple_element(const 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>& x) : m_x(x.a13) {} + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct const_tuple_element<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>, 14> : tuple_type<A14> { + const_tuple_element(const 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>& x) : m_x(x.a14) {} + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct const_tuple_element<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>, 15> : tuple_type<A15> { + const_tuple_element(const 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>& x) : m_x(x.a15) {} + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct const_tuple_element<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>, 16> : tuple_type<A16> { + const_tuple_element(const 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>& x) : m_x(x.a16) {} + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct const_tuple_element<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>, 17> : tuple_type<A17> { + const_tuple_element(const 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>& x) : m_x(x.a17) {} + typename tuple_type<A17>::const_reference get() const { return m_x; } +private: + typename tuple_type<A17>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct const_tuple_element<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>, 18> : tuple_type<A18> { + const_tuple_element(const 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>& x) : m_x(x.a18) {} + typename tuple_type<A18>::const_reference get() const { return m_x; } +private: + typename tuple_type<A18>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct const_tuple_element<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>, 19> : tuple_type<A19> { + const_tuple_element(const 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>& x) : m_x(x.a19) {} + typename tuple_type<A19>::const_reference get() const { return m_x; } +private: + typename tuple_type<A19>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct const_tuple_element<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>, 20> : tuple_type<A20> { + const_tuple_element(const 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>& x) : m_x(x.a20) {} + typename tuple_type<A20>::const_reference get() const { return m_x; } +private: + typename tuple_type<A20>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct const_tuple_element<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>, 21> : tuple_type<A21> { + const_tuple_element(const 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>& x) : m_x(x.a21) {} + typename tuple_type<A21>::const_reference get() const { return m_x; } +private: + typename tuple_type<A21>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct const_tuple_element<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>, 22> : tuple_type<A22> { + const_tuple_element(const 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>& x) : m_x(x.a22) {} + typename tuple_type<A22>::const_reference get() const { return m_x; } +private: + typename tuple_type<A22>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct const_tuple_element<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>, 23> : tuple_type<A23> { + const_tuple_element(const 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>& x) : m_x(x.a23) {} + typename tuple_type<A23>::const_reference get() const { return m_x; } +private: + typename tuple_type<A23>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct const_tuple_element<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>, 24> : tuple_type<A24> { + const_tuple_element(const 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>& x) : m_x(x.a24) {} + typename tuple_type<A24>::const_reference get() const { return m_x; } +private: + typename tuple_type<A24>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct const_tuple_element<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>, 25> : tuple_type<A25> { + const_tuple_element(const 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>& x) : m_x(x.a25) {} + typename tuple_type<A25>::const_reference get() const { return m_x; } +private: + typename tuple_type<A25>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct const_tuple_element<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>, 26> : tuple_type<A26> { + const_tuple_element(const 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>& x) : m_x(x.a26) {} + typename tuple_type<A26>::const_reference get() const { return m_x; } +private: + typename tuple_type<A26>::const_reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct const_tuple_element<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>, 0> : tuple_type<A0> { + const_tuple_element(const 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>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct const_tuple_element<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>, 1> : tuple_type<A1> { + const_tuple_element(const 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>& x) : m_x(x.a1) {} + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct const_tuple_element<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>, 2> : tuple_type<A2> { + const_tuple_element(const 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>& x) : m_x(x.a2) {} + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct const_tuple_element<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>, 3> : tuple_type<A3> { + const_tuple_element(const 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>& x) : m_x(x.a3) {} + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct const_tuple_element<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>, 4> : tuple_type<A4> { + const_tuple_element(const 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>& x) : m_x(x.a4) {} + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct const_tuple_element<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>, 5> : tuple_type<A5> { + const_tuple_element(const 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>& x) : m_x(x.a5) {} + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct const_tuple_element<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>, 6> : tuple_type<A6> { + const_tuple_element(const 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>& x) : m_x(x.a6) {} + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct const_tuple_element<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>, 7> : tuple_type<A7> { + const_tuple_element(const 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>& x) : m_x(x.a7) {} + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct const_tuple_element<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>, 8> : tuple_type<A8> { + const_tuple_element(const 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>& x) : m_x(x.a8) {} + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct const_tuple_element<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>, 9> : tuple_type<A9> { + const_tuple_element(const 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>& x) : m_x(x.a9) {} + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct const_tuple_element<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>, 10> : tuple_type<A10> { + const_tuple_element(const 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>& x) : m_x(x.a10) {} + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct const_tuple_element<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>, 11> : tuple_type<A11> { + const_tuple_element(const 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>& x) : m_x(x.a11) {} + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct const_tuple_element<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>, 12> : tuple_type<A12> { + const_tuple_element(const 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>& x) : m_x(x.a12) {} + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct const_tuple_element<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>, 13> : tuple_type<A13> { + const_tuple_element(const 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>& x) : m_x(x.a13) {} + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct const_tuple_element<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>, 14> : tuple_type<A14> { + const_tuple_element(const 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>& x) : m_x(x.a14) {} + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct const_tuple_element<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>, 15> : tuple_type<A15> { + const_tuple_element(const 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>& x) : m_x(x.a15) {} + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct const_tuple_element<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>, 16> : tuple_type<A16> { + const_tuple_element(const 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>& x) : m_x(x.a16) {} + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct const_tuple_element<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>, 17> : tuple_type<A17> { + const_tuple_element(const 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>& x) : m_x(x.a17) {} + typename tuple_type<A17>::const_reference get() const { return m_x; } +private: + typename tuple_type<A17>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct const_tuple_element<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>, 18> : tuple_type<A18> { + const_tuple_element(const 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>& x) : m_x(x.a18) {} + typename tuple_type<A18>::const_reference get() const { return m_x; } +private: + typename tuple_type<A18>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct const_tuple_element<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>, 19> : tuple_type<A19> { + const_tuple_element(const 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>& x) : m_x(x.a19) {} + typename tuple_type<A19>::const_reference get() const { return m_x; } +private: + typename tuple_type<A19>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct const_tuple_element<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>, 20> : tuple_type<A20> { + const_tuple_element(const 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>& x) : m_x(x.a20) {} + typename tuple_type<A20>::const_reference get() const { return m_x; } +private: + typename tuple_type<A20>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct const_tuple_element<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>, 21> : tuple_type<A21> { + const_tuple_element(const 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>& x) : m_x(x.a21) {} + typename tuple_type<A21>::const_reference get() const { return m_x; } +private: + typename tuple_type<A21>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct const_tuple_element<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>, 22> : tuple_type<A22> { + const_tuple_element(const 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>& x) : m_x(x.a22) {} + typename tuple_type<A22>::const_reference get() const { return m_x; } +private: + typename tuple_type<A22>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct const_tuple_element<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>, 23> : tuple_type<A23> { + const_tuple_element(const 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>& x) : m_x(x.a23) {} + typename tuple_type<A23>::const_reference get() const { return m_x; } +private: + typename tuple_type<A23>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct const_tuple_element<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>, 24> : tuple_type<A24> { + const_tuple_element(const 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>& x) : m_x(x.a24) {} + typename tuple_type<A24>::const_reference get() const { return m_x; } +private: + typename tuple_type<A24>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct const_tuple_element<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>, 25> : tuple_type<A25> { + const_tuple_element(const 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>& x) : m_x(x.a25) {} + typename tuple_type<A25>::const_reference get() const { return m_x; } +private: + typename tuple_type<A25>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct const_tuple_element<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>, 26> : tuple_type<A26> { + const_tuple_element(const 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>& x) : m_x(x.a26) {} + typename tuple_type<A26>::const_reference get() const { return m_x; } +private: + typename tuple_type<A26>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct const_tuple_element<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>, 27> : tuple_type<A27> { + const_tuple_element(const 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>& x) : m_x(x.a27) {} + typename tuple_type<A27>::const_reference get() const { return m_x; } +private: + typename tuple_type<A27>::const_reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct const_tuple_element<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>, 0> : tuple_type<A0> { + const_tuple_element(const 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>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct const_tuple_element<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>, 1> : tuple_type<A1> { + const_tuple_element(const 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>& x) : m_x(x.a1) {} + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct const_tuple_element<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>, 2> : tuple_type<A2> { + const_tuple_element(const 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>& x) : m_x(x.a2) {} + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct const_tuple_element<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>, 3> : tuple_type<A3> { + const_tuple_element(const 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>& x) : m_x(x.a3) {} + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct const_tuple_element<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>, 4> : tuple_type<A4> { + const_tuple_element(const 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>& x) : m_x(x.a4) {} + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct const_tuple_element<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>, 5> : tuple_type<A5> { + const_tuple_element(const 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>& x) : m_x(x.a5) {} + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct const_tuple_element<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>, 6> : tuple_type<A6> { + const_tuple_element(const 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>& x) : m_x(x.a6) {} + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct const_tuple_element<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>, 7> : tuple_type<A7> { + const_tuple_element(const 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>& x) : m_x(x.a7) {} + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct const_tuple_element<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>, 8> : tuple_type<A8> { + const_tuple_element(const 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>& x) : m_x(x.a8) {} + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct const_tuple_element<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>, 9> : tuple_type<A9> { + const_tuple_element(const 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>& x) : m_x(x.a9) {} + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct const_tuple_element<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>, 10> : tuple_type<A10> { + const_tuple_element(const 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>& x) : m_x(x.a10) {} + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct const_tuple_element<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>, 11> : tuple_type<A11> { + const_tuple_element(const 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>& x) : m_x(x.a11) {} + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct const_tuple_element<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>, 12> : tuple_type<A12> { + const_tuple_element(const 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>& x) : m_x(x.a12) {} + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct const_tuple_element<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>, 13> : tuple_type<A13> { + const_tuple_element(const 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>& x) : m_x(x.a13) {} + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct const_tuple_element<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>, 14> : tuple_type<A14> { + const_tuple_element(const 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>& x) : m_x(x.a14) {} + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct const_tuple_element<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>, 15> : tuple_type<A15> { + const_tuple_element(const 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>& x) : m_x(x.a15) {} + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct const_tuple_element<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>, 16> : tuple_type<A16> { + const_tuple_element(const 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>& x) : m_x(x.a16) {} + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct const_tuple_element<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>, 17> : tuple_type<A17> { + const_tuple_element(const 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>& x) : m_x(x.a17) {} + typename tuple_type<A17>::const_reference get() const { return m_x; } +private: + typename tuple_type<A17>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct const_tuple_element<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>, 18> : tuple_type<A18> { + const_tuple_element(const 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>& x) : m_x(x.a18) {} + typename tuple_type<A18>::const_reference get() const { return m_x; } +private: + typename tuple_type<A18>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct const_tuple_element<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>, 19> : tuple_type<A19> { + const_tuple_element(const 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>& x) : m_x(x.a19) {} + typename tuple_type<A19>::const_reference get() const { return m_x; } +private: + typename tuple_type<A19>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct const_tuple_element<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>, 20> : tuple_type<A20> { + const_tuple_element(const 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>& x) : m_x(x.a20) {} + typename tuple_type<A20>::const_reference get() const { return m_x; } +private: + typename tuple_type<A20>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct const_tuple_element<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>, 21> : tuple_type<A21> { + const_tuple_element(const 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>& x) : m_x(x.a21) {} + typename tuple_type<A21>::const_reference get() const { return m_x; } +private: + typename tuple_type<A21>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct const_tuple_element<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>, 22> : tuple_type<A22> { + const_tuple_element(const 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>& x) : m_x(x.a22) {} + typename tuple_type<A22>::const_reference get() const { return m_x; } +private: + typename tuple_type<A22>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct const_tuple_element<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>, 23> : tuple_type<A23> { + const_tuple_element(const 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>& x) : m_x(x.a23) {} + typename tuple_type<A23>::const_reference get() const { return m_x; } +private: + typename tuple_type<A23>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct const_tuple_element<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>, 24> : tuple_type<A24> { + const_tuple_element(const 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>& x) : m_x(x.a24) {} + typename tuple_type<A24>::const_reference get() const { return m_x; } +private: + typename tuple_type<A24>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct const_tuple_element<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>, 25> : tuple_type<A25> { + const_tuple_element(const 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>& x) : m_x(x.a25) {} + typename tuple_type<A25>::const_reference get() const { return m_x; } +private: + typename tuple_type<A25>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct const_tuple_element<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>, 26> : tuple_type<A26> { + const_tuple_element(const 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>& x) : m_x(x.a26) {} + typename tuple_type<A26>::const_reference get() const { return m_x; } +private: + typename tuple_type<A26>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct const_tuple_element<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>, 27> : tuple_type<A27> { + const_tuple_element(const 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>& x) : m_x(x.a27) {} + typename tuple_type<A27>::const_reference get() const { return m_x; } +private: + typename tuple_type<A27>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct const_tuple_element<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>, 28> : tuple_type<A28> { + const_tuple_element(const 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>& x) : m_x(x.a28) {} + typename tuple_type<A28>::const_reference get() const { return m_x; } +private: + typename tuple_type<A28>::const_reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct const_tuple_element<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>, 0> : tuple_type<A0> { + const_tuple_element(const 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>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct const_tuple_element<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>, 1> : tuple_type<A1> { + const_tuple_element(const 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>& x) : m_x(x.a1) {} + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct const_tuple_element<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>, 2> : tuple_type<A2> { + const_tuple_element(const 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>& x) : m_x(x.a2) {} + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct const_tuple_element<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>, 3> : tuple_type<A3> { + const_tuple_element(const 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>& x) : m_x(x.a3) {} + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct const_tuple_element<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>, 4> : tuple_type<A4> { + const_tuple_element(const 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>& x) : m_x(x.a4) {} + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct const_tuple_element<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>, 5> : tuple_type<A5> { + const_tuple_element(const 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>& x) : m_x(x.a5) {} + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct const_tuple_element<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>, 6> : tuple_type<A6> { + const_tuple_element(const 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>& x) : m_x(x.a6) {} + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct const_tuple_element<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>, 7> : tuple_type<A7> { + const_tuple_element(const 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>& x) : m_x(x.a7) {} + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct const_tuple_element<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>, 8> : tuple_type<A8> { + const_tuple_element(const 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>& x) : m_x(x.a8) {} + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct const_tuple_element<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>, 9> : tuple_type<A9> { + const_tuple_element(const 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>& x) : m_x(x.a9) {} + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct const_tuple_element<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>, 10> : tuple_type<A10> { + const_tuple_element(const 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>& x) : m_x(x.a10) {} + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct const_tuple_element<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>, 11> : tuple_type<A11> { + const_tuple_element(const 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>& x) : m_x(x.a11) {} + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct const_tuple_element<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>, 12> : tuple_type<A12> { + const_tuple_element(const 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>& x) : m_x(x.a12) {} + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct const_tuple_element<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>, 13> : tuple_type<A13> { + const_tuple_element(const 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>& x) : m_x(x.a13) {} + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct const_tuple_element<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>, 14> : tuple_type<A14> { + const_tuple_element(const 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>& x) : m_x(x.a14) {} + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct const_tuple_element<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>, 15> : tuple_type<A15> { + const_tuple_element(const 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>& x) : m_x(x.a15) {} + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct const_tuple_element<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>, 16> : tuple_type<A16> { + const_tuple_element(const 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>& x) : m_x(x.a16) {} + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct const_tuple_element<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>, 17> : tuple_type<A17> { + const_tuple_element(const 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>& x) : m_x(x.a17) {} + typename tuple_type<A17>::const_reference get() const { return m_x; } +private: + typename tuple_type<A17>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct const_tuple_element<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>, 18> : tuple_type<A18> { + const_tuple_element(const 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>& x) : m_x(x.a18) {} + typename tuple_type<A18>::const_reference get() const { return m_x; } +private: + typename tuple_type<A18>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct const_tuple_element<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>, 19> : tuple_type<A19> { + const_tuple_element(const 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>& x) : m_x(x.a19) {} + typename tuple_type<A19>::const_reference get() const { return m_x; } +private: + typename tuple_type<A19>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct const_tuple_element<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>, 20> : tuple_type<A20> { + const_tuple_element(const 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>& x) : m_x(x.a20) {} + typename tuple_type<A20>::const_reference get() const { return m_x; } +private: + typename tuple_type<A20>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct const_tuple_element<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>, 21> : tuple_type<A21> { + const_tuple_element(const 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>& x) : m_x(x.a21) {} + typename tuple_type<A21>::const_reference get() const { return m_x; } +private: + typename tuple_type<A21>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct const_tuple_element<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>, 22> : tuple_type<A22> { + const_tuple_element(const 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>& x) : m_x(x.a22) {} + typename tuple_type<A22>::const_reference get() const { return m_x; } +private: + typename tuple_type<A22>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct const_tuple_element<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>, 23> : tuple_type<A23> { + const_tuple_element(const 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>& x) : m_x(x.a23) {} + typename tuple_type<A23>::const_reference get() const { return m_x; } +private: + typename tuple_type<A23>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct const_tuple_element<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>, 24> : tuple_type<A24> { + const_tuple_element(const 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>& x) : m_x(x.a24) {} + typename tuple_type<A24>::const_reference get() const { return m_x; } +private: + typename tuple_type<A24>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct const_tuple_element<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>, 25> : tuple_type<A25> { + const_tuple_element(const 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>& x) : m_x(x.a25) {} + typename tuple_type<A25>::const_reference get() const { return m_x; } +private: + typename tuple_type<A25>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct const_tuple_element<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>, 26> : tuple_type<A26> { + const_tuple_element(const 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>& x) : m_x(x.a26) {} + typename tuple_type<A26>::const_reference get() const { return m_x; } +private: + typename tuple_type<A26>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct const_tuple_element<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>, 27> : tuple_type<A27> { + const_tuple_element(const 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>& x) : m_x(x.a27) {} + typename tuple_type<A27>::const_reference get() const { return m_x; } +private: + typename tuple_type<A27>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct const_tuple_element<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>, 28> : tuple_type<A28> { + const_tuple_element(const 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>& x) : m_x(x.a28) {} + typename tuple_type<A28>::const_reference get() const { return m_x; } +private: + typename tuple_type<A28>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct const_tuple_element<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>, 29> : tuple_type<A29> { + const_tuple_element(const 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>& x) : m_x(x.a29) {} + typename tuple_type<A29>::const_reference get() const { return m_x; } +private: + typename tuple_type<A29>::const_reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct const_tuple_element<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>, 0> : tuple_type<A0> { + const_tuple_element(const 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>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct const_tuple_element<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>, 1> : tuple_type<A1> { + const_tuple_element(const 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>& x) : m_x(x.a1) {} + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct const_tuple_element<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>, 2> : tuple_type<A2> { + const_tuple_element(const 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>& x) : m_x(x.a2) {} + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct const_tuple_element<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>, 3> : tuple_type<A3> { + const_tuple_element(const 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>& x) : m_x(x.a3) {} + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct const_tuple_element<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>, 4> : tuple_type<A4> { + const_tuple_element(const 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>& x) : m_x(x.a4) {} + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct const_tuple_element<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>, 5> : tuple_type<A5> { + const_tuple_element(const 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>& x) : m_x(x.a5) {} + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct const_tuple_element<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>, 6> : tuple_type<A6> { + const_tuple_element(const 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>& x) : m_x(x.a6) {} + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct const_tuple_element<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>, 7> : tuple_type<A7> { + const_tuple_element(const 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>& x) : m_x(x.a7) {} + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct const_tuple_element<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>, 8> : tuple_type<A8> { + const_tuple_element(const 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>& x) : m_x(x.a8) {} + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct const_tuple_element<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>, 9> : tuple_type<A9> { + const_tuple_element(const 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>& x) : m_x(x.a9) {} + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct const_tuple_element<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>, 10> : tuple_type<A10> { + const_tuple_element(const 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>& x) : m_x(x.a10) {} + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct const_tuple_element<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>, 11> : tuple_type<A11> { + const_tuple_element(const 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>& x) : m_x(x.a11) {} + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct const_tuple_element<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>, 12> : tuple_type<A12> { + const_tuple_element(const 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>& x) : m_x(x.a12) {} + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct const_tuple_element<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>, 13> : tuple_type<A13> { + const_tuple_element(const 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>& x) : m_x(x.a13) {} + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct const_tuple_element<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>, 14> : tuple_type<A14> { + const_tuple_element(const 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>& x) : m_x(x.a14) {} + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct const_tuple_element<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>, 15> : tuple_type<A15> { + const_tuple_element(const 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>& x) : m_x(x.a15) {} + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct const_tuple_element<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>, 16> : tuple_type<A16> { + const_tuple_element(const 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>& x) : m_x(x.a16) {} + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct const_tuple_element<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>, 17> : tuple_type<A17> { + const_tuple_element(const 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>& x) : m_x(x.a17) {} + typename tuple_type<A17>::const_reference get() const { return m_x; } +private: + typename tuple_type<A17>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct const_tuple_element<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>, 18> : tuple_type<A18> { + const_tuple_element(const 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>& x) : m_x(x.a18) {} + typename tuple_type<A18>::const_reference get() const { return m_x; } +private: + typename tuple_type<A18>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct const_tuple_element<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>, 19> : tuple_type<A19> { + const_tuple_element(const 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>& x) : m_x(x.a19) {} + typename tuple_type<A19>::const_reference get() const { return m_x; } +private: + typename tuple_type<A19>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct const_tuple_element<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>, 20> : tuple_type<A20> { + const_tuple_element(const 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>& x) : m_x(x.a20) {} + typename tuple_type<A20>::const_reference get() const { return m_x; } +private: + typename tuple_type<A20>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct const_tuple_element<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>, 21> : tuple_type<A21> { + const_tuple_element(const 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>& x) : m_x(x.a21) {} + typename tuple_type<A21>::const_reference get() const { return m_x; } +private: + typename tuple_type<A21>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct const_tuple_element<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>, 22> : tuple_type<A22> { + const_tuple_element(const 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>& x) : m_x(x.a22) {} + typename tuple_type<A22>::const_reference get() const { return m_x; } +private: + typename tuple_type<A22>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct const_tuple_element<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>, 23> : tuple_type<A23> { + const_tuple_element(const 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>& x) : m_x(x.a23) {} + typename tuple_type<A23>::const_reference get() const { return m_x; } +private: + typename tuple_type<A23>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct const_tuple_element<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>, 24> : tuple_type<A24> { + const_tuple_element(const 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>& x) : m_x(x.a24) {} + typename tuple_type<A24>::const_reference get() const { return m_x; } +private: + typename tuple_type<A24>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct const_tuple_element<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>, 25> : tuple_type<A25> { + const_tuple_element(const 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>& x) : m_x(x.a25) {} + typename tuple_type<A25>::const_reference get() const { return m_x; } +private: + typename tuple_type<A25>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct const_tuple_element<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>, 26> : tuple_type<A26> { + const_tuple_element(const 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>& x) : m_x(x.a26) {} + typename tuple_type<A26>::const_reference get() const { return m_x; } +private: + typename tuple_type<A26>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct const_tuple_element<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>, 27> : tuple_type<A27> { + const_tuple_element(const 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>& x) : m_x(x.a27) {} + typename tuple_type<A27>::const_reference get() const { return m_x; } +private: + typename tuple_type<A27>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct const_tuple_element<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>, 28> : tuple_type<A28> { + const_tuple_element(const 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>& x) : m_x(x.a28) {} + typename tuple_type<A28>::const_reference get() const { return m_x; } +private: + typename tuple_type<A28>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct const_tuple_element<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>, 29> : tuple_type<A29> { + const_tuple_element(const 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>& x) : m_x(x.a29) {} + typename tuple_type<A29>::const_reference get() const { return m_x; } +private: + typename tuple_type<A29>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct const_tuple_element<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>, 30> : tuple_type<A30> { + const_tuple_element(const 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>& x) : m_x(x.a30) {} + typename tuple_type<A30>::const_reference get() const { return m_x; } +private: + typename tuple_type<A30>::const_reference m_x; +}; + + + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 0> : tuple_type<A0> { + const_tuple_element(const 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>& x) : m_x(x.a0) {} + typename tuple_type<A0>::const_reference get() const { return m_x; } +private: + typename tuple_type<A0>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 1> : tuple_type<A1> { + const_tuple_element(const 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>& x) : m_x(x.a1) {} + typename tuple_type<A1>::const_reference get() const { return m_x; } +private: + typename tuple_type<A1>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 2> : tuple_type<A2> { + const_tuple_element(const 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>& x) : m_x(x.a2) {} + typename tuple_type<A2>::const_reference get() const { return m_x; } +private: + typename tuple_type<A2>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 3> : tuple_type<A3> { + const_tuple_element(const 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>& x) : m_x(x.a3) {} + typename tuple_type<A3>::const_reference get() const { return m_x; } +private: + typename tuple_type<A3>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 4> : tuple_type<A4> { + const_tuple_element(const 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>& x) : m_x(x.a4) {} + typename tuple_type<A4>::const_reference get() const { return m_x; } +private: + typename tuple_type<A4>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 5> : tuple_type<A5> { + const_tuple_element(const 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>& x) : m_x(x.a5) {} + typename tuple_type<A5>::const_reference get() const { return m_x; } +private: + typename tuple_type<A5>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 6> : tuple_type<A6> { + const_tuple_element(const 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>& x) : m_x(x.a6) {} + typename tuple_type<A6>::const_reference get() const { return m_x; } +private: + typename tuple_type<A6>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 7> : tuple_type<A7> { + const_tuple_element(const 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>& x) : m_x(x.a7) {} + typename tuple_type<A7>::const_reference get() const { return m_x; } +private: + typename tuple_type<A7>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 8> : tuple_type<A8> { + const_tuple_element(const 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>& x) : m_x(x.a8) {} + typename tuple_type<A8>::const_reference get() const { return m_x; } +private: + typename tuple_type<A8>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 9> : tuple_type<A9> { + const_tuple_element(const 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>& x) : m_x(x.a9) {} + typename tuple_type<A9>::const_reference get() const { return m_x; } +private: + typename tuple_type<A9>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 10> : tuple_type<A10> { + const_tuple_element(const 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>& x) : m_x(x.a10) {} + typename tuple_type<A10>::const_reference get() const { return m_x; } +private: + typename tuple_type<A10>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 11> : tuple_type<A11> { + const_tuple_element(const 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>& x) : m_x(x.a11) {} + typename tuple_type<A11>::const_reference get() const { return m_x; } +private: + typename tuple_type<A11>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 12> : tuple_type<A12> { + const_tuple_element(const 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>& x) : m_x(x.a12) {} + typename tuple_type<A12>::const_reference get() const { return m_x; } +private: + typename tuple_type<A12>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 13> : tuple_type<A13> { + const_tuple_element(const 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>& x) : m_x(x.a13) {} + typename tuple_type<A13>::const_reference get() const { return m_x; } +private: + typename tuple_type<A13>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 14> : tuple_type<A14> { + const_tuple_element(const 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>& x) : m_x(x.a14) {} + typename tuple_type<A14>::const_reference get() const { return m_x; } +private: + typename tuple_type<A14>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 15> : tuple_type<A15> { + const_tuple_element(const 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>& x) : m_x(x.a15) {} + typename tuple_type<A15>::const_reference get() const { return m_x; } +private: + typename tuple_type<A15>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 16> : tuple_type<A16> { + const_tuple_element(const 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>& x) : m_x(x.a16) {} + typename tuple_type<A16>::const_reference get() const { return m_x; } +private: + typename tuple_type<A16>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 17> : tuple_type<A17> { + const_tuple_element(const 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>& x) : m_x(x.a17) {} + typename tuple_type<A17>::const_reference get() const { return m_x; } +private: + typename tuple_type<A17>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 18> : tuple_type<A18> { + const_tuple_element(const 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>& x) : m_x(x.a18) {} + typename tuple_type<A18>::const_reference get() const { return m_x; } +private: + typename tuple_type<A18>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 19> : tuple_type<A19> { + const_tuple_element(const 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>& x) : m_x(x.a19) {} + typename tuple_type<A19>::const_reference get() const { return m_x; } +private: + typename tuple_type<A19>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 20> : tuple_type<A20> { + const_tuple_element(const 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>& x) : m_x(x.a20) {} + typename tuple_type<A20>::const_reference get() const { return m_x; } +private: + typename tuple_type<A20>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 21> : tuple_type<A21> { + const_tuple_element(const 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>& x) : m_x(x.a21) {} + typename tuple_type<A21>::const_reference get() const { return m_x; } +private: + typename tuple_type<A21>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 22> : tuple_type<A22> { + const_tuple_element(const 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>& x) : m_x(x.a22) {} + typename tuple_type<A22>::const_reference get() const { return m_x; } +private: + typename tuple_type<A22>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 23> : tuple_type<A23> { + const_tuple_element(const 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>& x) : m_x(x.a23) {} + typename tuple_type<A23>::const_reference get() const { return m_x; } +private: + typename tuple_type<A23>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 24> : tuple_type<A24> { + const_tuple_element(const 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>& x) : m_x(x.a24) {} + typename tuple_type<A24>::const_reference get() const { return m_x; } +private: + typename tuple_type<A24>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 25> : tuple_type<A25> { + const_tuple_element(const 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>& x) : m_x(x.a25) {} + typename tuple_type<A25>::const_reference get() const { return m_x; } +private: + typename tuple_type<A25>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 26> : tuple_type<A26> { + const_tuple_element(const 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>& x) : m_x(x.a26) {} + typename tuple_type<A26>::const_reference get() const { return m_x; } +private: + typename tuple_type<A26>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 27> : tuple_type<A27> { + const_tuple_element(const 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>& x) : m_x(x.a27) {} + typename tuple_type<A27>::const_reference get() const { return m_x; } +private: + typename tuple_type<A27>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 28> : tuple_type<A28> { + const_tuple_element(const 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>& x) : m_x(x.a28) {} + typename tuple_type<A28>::const_reference get() const { return m_x; } +private: + typename tuple_type<A28>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 29> : tuple_type<A29> { + const_tuple_element(const 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>& x) : m_x(x.a29) {} + typename tuple_type<A29>::const_reference get() const { return m_x; } +private: + typename tuple_type<A29>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 30> : tuple_type<A30> { + const_tuple_element(const 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>& x) : m_x(x.a30) {} + typename tuple_type<A30>::const_reference get() const { return m_x; } +private: + typename tuple_type<A30>::const_reference m_x; +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct const_tuple_element<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>, 31> : tuple_type<A31> { + const_tuple_element(const 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>& x) : m_x(x.a31) {} + typename tuple_type<A31>::const_reference get() const { return m_x; } +private: + typename tuple_type<A31>::const_reference m_x; +}; + + +/// @endcond + +template <> +struct tuple<> { + tuple() {} + tuple(clmdep_msgpack::object const& o) { o.convert(*this); } + typedef tuple<> value_type; +}; + +/// @cond + +template <typename A0> +struct tuple<A0> { + typedef tuple<A0> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0) : + a0(_a0) {} + tuple(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*this).get(); } + + A0 a0; +}; + +template <int N, typename A0> +inline typename type::tuple_element<type::tuple<A0>, N>::reference get(type::tuple<A0>& t) +{ return t.template get<N>(); } +template <int N, typename A0> +inline typename type::const_tuple_element<type::tuple<A0>, N>::const_reference get(type::tuple<A0> const& t) +{ return t.template get<N>(); } + +template <typename A0, typename A1> +struct tuple<A0, A1> { + typedef tuple<A0, A1> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0, typename tuple_type<A1>::transparent_reference _a1) : + a0(_a0), a1(_a1) {} + tuple(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*this).get(); } + + A0 a0; + A1 a1; +}; + +template <int N, typename A0, typename A1> +inline typename type::tuple_element<type::tuple<A0, A1>, N>::reference get(type::tuple<A0, A1>& t) +{ return t.template get<N>(); } +template <int N, typename A0, typename A1> +inline typename type::const_tuple_element<type::tuple<A0, A1>, N>::const_reference get(type::tuple<A0, A1> const& t) +{ return t.template get<N>(); } + +template <typename A0, typename A1, typename A2> +struct tuple<A0, A1, A2> { + typedef tuple<A0, A1, A2> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0, typename tuple_type<A1>::transparent_reference _a1, typename tuple_type<A2>::transparent_reference _a2) : + a0(_a0), a1(_a1), a2(_a2) {} + tuple(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; +}; + +template <int N, typename A0, typename A1, typename A2> +inline typename type::tuple_element<type::tuple<A0, A1, A2>, N>::reference get(type::tuple<A0, A1, A2>& t) +{ return t.template get<N>(); } +template <int N, typename A0, typename A1, typename A2> +inline typename type::const_tuple_element<type::tuple<A0, A1, A2>, N>::const_reference get(type::tuple<A0, A1, A2> const& t) +{ return t.template get<N>(); } + +template <typename A0, typename A1, typename A2, typename A3> +struct tuple<A0, A1, A2, A3> { + typedef tuple<A0, A1, A2, A3> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0, typename tuple_type<A1>::transparent_reference _a1, typename tuple_type<A2>::transparent_reference _a2, typename tuple_type<A3>::transparent_reference _a3) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3) {} + tuple(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; +}; + +template <int N, typename A0, typename A1, typename A2, typename A3> +inline typename type::tuple_element<type::tuple<A0, A1, A2, A3>, N>::reference get(type::tuple<A0, A1, A2, A3>& t) +{ return t.template get<N>(); } +template <int N, typename A0, typename A1, typename A2, typename A3> +inline typename type::const_tuple_element<type::tuple<A0, A1, A2, A3>, N>::const_reference get(type::tuple<A0, A1, A2, A3> const& t) +{ return t.template get<N>(); } + +template <typename A0, typename A1, typename A2, typename A3, typename A4> +struct tuple<A0, A1, A2, A3, A4> { + typedef tuple<A0, A1, A2, A3, A4> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0, typename tuple_type<A1>::transparent_reference _a1, typename tuple_type<A2>::transparent_reference _a2, typename tuple_type<A3>::transparent_reference _a3, typename tuple_type<A4>::transparent_reference _a4) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4) {} + tuple(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; +}; + +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4> +inline typename type::tuple_element<type::tuple<A0, A1, A2, A3, A4>, N>::reference get(type::tuple<A0, A1, A2, A3, A4>& t) +{ return t.template get<N>(); } +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4> +inline typename type::const_tuple_element<type::tuple<A0, A1, A2, A3, A4>, N>::const_reference get(type::tuple<A0, A1, A2, A3, A4> const& t) +{ return t.template get<N>(); } + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5> +struct tuple<A0, A1, A2, A3, A4, A5> { + typedef tuple<A0, A1, A2, A3, A4, A5> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0, typename tuple_type<A1>::transparent_reference _a1, typename tuple_type<A2>::transparent_reference _a2, typename tuple_type<A3>::transparent_reference _a3, typename tuple_type<A4>::transparent_reference _a4, typename tuple_type<A5>::transparent_reference _a5) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5) {} + tuple(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; +}; + +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5> +inline typename type::tuple_element<type::tuple<A0, A1, A2, A3, A4, A5>, N>::reference get(type::tuple<A0, A1, A2, A3, A4, A5>& t) +{ return t.template get<N>(); } +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5> +inline typename type::const_tuple_element<type::tuple<A0, A1, A2, A3, A4, A5>, N>::const_reference get(type::tuple<A0, A1, A2, A3, A4, A5> const& t) +{ return t.template get<N>(); } + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6> +struct tuple<A0, A1, A2, A3, A4, A5, A6> { + typedef tuple<A0, A1, A2, A3, A4, A5, A6> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0, typename tuple_type<A1>::transparent_reference _a1, typename tuple_type<A2>::transparent_reference _a2, typename tuple_type<A3>::transparent_reference _a3, typename tuple_type<A4>::transparent_reference _a4, typename tuple_type<A5>::transparent_reference _a5, typename tuple_type<A6>::transparent_reference _a6) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6) {} + tuple(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; +}; + +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6> +inline typename type::tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6>, N>::reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6>& t) +{ return t.template get<N>(); } +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6> +inline typename type::const_tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6>, N>::const_reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6> const& t) +{ return t.template get<N>(); } + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> +struct tuple<A0, A1, A2, A3, A4, A5, A6, A7> { + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0, typename tuple_type<A1>::transparent_reference _a1, typename tuple_type<A2>::transparent_reference _a2, typename tuple_type<A3>::transparent_reference _a3, typename tuple_type<A4>::transparent_reference _a4, typename tuple_type<A5>::transparent_reference _a5, typename tuple_type<A6>::transparent_reference _a6, typename tuple_type<A7>::transparent_reference _a7) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7) {} + tuple(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; +}; + +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> +inline typename type::tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7>, N>::reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7>& t) +{ return t.template get<N>(); } +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> +inline typename type::const_tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7>, N>::const_reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7> const& t) +{ return t.template get<N>(); } + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> +struct tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8> { + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0, typename tuple_type<A1>::transparent_reference _a1, typename tuple_type<A2>::transparent_reference _a2, typename tuple_type<A3>::transparent_reference _a3, typename tuple_type<A4>::transparent_reference _a4, typename tuple_type<A5>::transparent_reference _a5, typename tuple_type<A6>::transparent_reference _a6, typename tuple_type<A7>::transparent_reference _a7, typename tuple_type<A8>::transparent_reference _a8) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8) {} + tuple(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; +}; + +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> +inline typename type::tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>, N>::reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>& t) +{ return t.template get<N>(); } +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> +inline typename type::const_tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>, N>::const_reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8> const& t) +{ return t.template get<N>(); } + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> +struct tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> { + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0, typename tuple_type<A1>::transparent_reference _a1, typename tuple_type<A2>::transparent_reference _a2, typename tuple_type<A3>::transparent_reference _a3, typename tuple_type<A4>::transparent_reference _a4, typename tuple_type<A5>::transparent_reference _a5, typename tuple_type<A6>::transparent_reference _a6, typename tuple_type<A7>::transparent_reference _a7, typename tuple_type<A8>::transparent_reference _a8, typename tuple_type<A9>::transparent_reference _a9) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9) {} + tuple(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; +}; + +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> +inline typename type::tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>, N>::reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>& t) +{ return t.template get<N>(); } +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> +inline typename type::const_tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>, N>::const_reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> const& t) +{ return t.template get<N>(); } + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +struct tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> { + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0, typename tuple_type<A1>::transparent_reference _a1, typename tuple_type<A2>::transparent_reference _a2, typename tuple_type<A3>::transparent_reference _a3, typename tuple_type<A4>::transparent_reference _a4, typename tuple_type<A5>::transparent_reference _a5, typename tuple_type<A6>::transparent_reference _a6, typename tuple_type<A7>::transparent_reference _a7, typename tuple_type<A8>::transparent_reference _a8, typename tuple_type<A9>::transparent_reference _a9, typename tuple_type<A10>::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(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*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 <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +inline typename type::tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>, N>::reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>& t) +{ return t.template get<N>(); } +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +inline typename type::const_tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>, N>::const_reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> const& t) +{ return t.template get<N>(); } + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +struct tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> { + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0, typename tuple_type<A1>::transparent_reference _a1, typename tuple_type<A2>::transparent_reference _a2, typename tuple_type<A3>::transparent_reference _a3, typename tuple_type<A4>::transparent_reference _a4, typename tuple_type<A5>::transparent_reference _a5, typename tuple_type<A6>::transparent_reference _a6, typename tuple_type<A7>::transparent_reference _a7, typename tuple_type<A8>::transparent_reference _a8, typename tuple_type<A9>::transparent_reference _a9, typename tuple_type<A10>::transparent_reference _a10, typename tuple_type<A11>::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(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*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 <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +inline typename type::tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>, N>::reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>& t) +{ return t.template get<N>(); } +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +inline typename type::const_tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>, N>::const_reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> const& t) +{ return t.template get<N>(); } + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +struct tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> { + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0, typename tuple_type<A1>::transparent_reference _a1, typename tuple_type<A2>::transparent_reference _a2, typename tuple_type<A3>::transparent_reference _a3, typename tuple_type<A4>::transparent_reference _a4, typename tuple_type<A5>::transparent_reference _a5, typename tuple_type<A6>::transparent_reference _a6, typename tuple_type<A7>::transparent_reference _a7, typename tuple_type<A8>::transparent_reference _a8, typename tuple_type<A9>::transparent_reference _a9, typename tuple_type<A10>::transparent_reference _a10, typename tuple_type<A11>::transparent_reference _a11, typename tuple_type<A12>::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(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*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 <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +inline typename type::tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>, N>::reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>& t) +{ return t.template get<N>(); } +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +inline typename type::const_tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>, N>::const_reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> const& t) +{ return t.template get<N>(); } + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> { + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0, typename tuple_type<A1>::transparent_reference _a1, typename tuple_type<A2>::transparent_reference _a2, typename tuple_type<A3>::transparent_reference _a3, typename tuple_type<A4>::transparent_reference _a4, typename tuple_type<A5>::transparent_reference _a5, typename tuple_type<A6>::transparent_reference _a6, typename tuple_type<A7>::transparent_reference _a7, typename tuple_type<A8>::transparent_reference _a8, typename tuple_type<A9>::transparent_reference _a9, typename tuple_type<A10>::transparent_reference _a10, typename tuple_type<A11>::transparent_reference _a11, typename tuple_type<A12>::transparent_reference _a12, typename tuple_type<A13>::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(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*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 <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +inline typename type::tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>, N>::reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>& t) +{ return t.template get<N>(); } +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +inline typename type::const_tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>, N>::const_reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> const& t) +{ return t.template get<N>(); } + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> { + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0, typename tuple_type<A1>::transparent_reference _a1, typename tuple_type<A2>::transparent_reference _a2, typename tuple_type<A3>::transparent_reference _a3, typename tuple_type<A4>::transparent_reference _a4, typename tuple_type<A5>::transparent_reference _a5, typename tuple_type<A6>::transparent_reference _a6, typename tuple_type<A7>::transparent_reference _a7, typename tuple_type<A8>::transparent_reference _a8, typename tuple_type<A9>::transparent_reference _a9, typename tuple_type<A10>::transparent_reference _a10, typename tuple_type<A11>::transparent_reference _a11, typename tuple_type<A12>::transparent_reference _a12, typename tuple_type<A13>::transparent_reference _a13, typename tuple_type<A14>::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(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*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 <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +inline typename type::tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, N>::reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>& t) +{ return t.template get<N>(); } +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +inline typename type::const_tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>, N>::const_reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> const& t) +{ return t.template get<N>(); } + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> { + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0, typename tuple_type<A1>::transparent_reference _a1, typename tuple_type<A2>::transparent_reference _a2, typename tuple_type<A3>::transparent_reference _a3, typename tuple_type<A4>::transparent_reference _a4, typename tuple_type<A5>::transparent_reference _a5, typename tuple_type<A6>::transparent_reference _a6, typename tuple_type<A7>::transparent_reference _a7, typename tuple_type<A8>::transparent_reference _a8, typename tuple_type<A9>::transparent_reference _a9, typename tuple_type<A10>::transparent_reference _a10, typename tuple_type<A11>::transparent_reference _a11, typename tuple_type<A12>::transparent_reference _a12, typename tuple_type<A13>::transparent_reference _a13, typename tuple_type<A14>::transparent_reference _a14, typename tuple_type<A15>::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(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*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 <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +inline typename type::tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, N>::reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>& t) +{ return t.template get<N>(); } +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +inline typename type::const_tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>, N>::const_reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> const& t) +{ return t.template get<N>(); } + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> { + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0, typename tuple_type<A1>::transparent_reference _a1, typename tuple_type<A2>::transparent_reference _a2, typename tuple_type<A3>::transparent_reference _a3, typename tuple_type<A4>::transparent_reference _a4, typename tuple_type<A5>::transparent_reference _a5, typename tuple_type<A6>::transparent_reference _a6, typename tuple_type<A7>::transparent_reference _a7, typename tuple_type<A8>::transparent_reference _a8, typename tuple_type<A9>::transparent_reference _a9, typename tuple_type<A10>::transparent_reference _a10, typename tuple_type<A11>::transparent_reference _a11, typename tuple_type<A12>::transparent_reference _a12, typename tuple_type<A13>::transparent_reference _a13, typename tuple_type<A14>::transparent_reference _a14, typename tuple_type<A15>::transparent_reference _a15, typename tuple_type<A16>::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(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*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 <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +inline typename type::tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, N>::reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>& t) +{ return t.template get<N>(); } +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +inline typename type::const_tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>, N>::const_reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> const& t) +{ return t.template get<N>(); } + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> { + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0, typename tuple_type<A1>::transparent_reference _a1, typename tuple_type<A2>::transparent_reference _a2, typename tuple_type<A3>::transparent_reference _a3, typename tuple_type<A4>::transparent_reference _a4, typename tuple_type<A5>::transparent_reference _a5, typename tuple_type<A6>::transparent_reference _a6, typename tuple_type<A7>::transparent_reference _a7, typename tuple_type<A8>::transparent_reference _a8, typename tuple_type<A9>::transparent_reference _a9, typename tuple_type<A10>::transparent_reference _a10, typename tuple_type<A11>::transparent_reference _a11, typename tuple_type<A12>::transparent_reference _a12, typename tuple_type<A13>::transparent_reference _a13, typename tuple_type<A14>::transparent_reference _a14, typename tuple_type<A15>::transparent_reference _a15, typename tuple_type<A16>::transparent_reference _a16, typename tuple_type<A17>::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(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*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 <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +inline typename type::tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, N>::reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>& t) +{ return t.template get<N>(); } +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +inline typename type::const_tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>, N>::const_reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> const& t) +{ return t.template get<N>(); } + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> { + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0, typename tuple_type<A1>::transparent_reference _a1, typename tuple_type<A2>::transparent_reference _a2, typename tuple_type<A3>::transparent_reference _a3, typename tuple_type<A4>::transparent_reference _a4, typename tuple_type<A5>::transparent_reference _a5, typename tuple_type<A6>::transparent_reference _a6, typename tuple_type<A7>::transparent_reference _a7, typename tuple_type<A8>::transparent_reference _a8, typename tuple_type<A9>::transparent_reference _a9, typename tuple_type<A10>::transparent_reference _a10, typename tuple_type<A11>::transparent_reference _a11, typename tuple_type<A12>::transparent_reference _a12, typename tuple_type<A13>::transparent_reference _a13, typename tuple_type<A14>::transparent_reference _a14, typename tuple_type<A15>::transparent_reference _a15, typename tuple_type<A16>::transparent_reference _a16, typename tuple_type<A17>::transparent_reference _a17, typename tuple_type<A18>::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(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*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 <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +inline typename type::tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, N>::reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>& t) +{ return t.template get<N>(); } +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +inline typename type::const_tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>, N>::const_reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> const& t) +{ return t.template get<N>(); } + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> { + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0, typename tuple_type<A1>::transparent_reference _a1, typename tuple_type<A2>::transparent_reference _a2, typename tuple_type<A3>::transparent_reference _a3, typename tuple_type<A4>::transparent_reference _a4, typename tuple_type<A5>::transparent_reference _a5, typename tuple_type<A6>::transparent_reference _a6, typename tuple_type<A7>::transparent_reference _a7, typename tuple_type<A8>::transparent_reference _a8, typename tuple_type<A9>::transparent_reference _a9, typename tuple_type<A10>::transparent_reference _a10, typename tuple_type<A11>::transparent_reference _a11, typename tuple_type<A12>::transparent_reference _a12, typename tuple_type<A13>::transparent_reference _a13, typename tuple_type<A14>::transparent_reference _a14, typename tuple_type<A15>::transparent_reference _a15, typename tuple_type<A16>::transparent_reference _a16, typename tuple_type<A17>::transparent_reference _a17, typename tuple_type<A18>::transparent_reference _a18, typename tuple_type<A19>::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(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*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 <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +inline typename type::tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, N>::reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>& t) +{ return t.template get<N>(); } +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +inline typename type::const_tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>, N>::const_reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> const& t) +{ return t.template get<N>(); } + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20> { + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0, typename tuple_type<A1>::transparent_reference _a1, typename tuple_type<A2>::transparent_reference _a2, typename tuple_type<A3>::transparent_reference _a3, typename tuple_type<A4>::transparent_reference _a4, typename tuple_type<A5>::transparent_reference _a5, typename tuple_type<A6>::transparent_reference _a6, typename tuple_type<A7>::transparent_reference _a7, typename tuple_type<A8>::transparent_reference _a8, typename tuple_type<A9>::transparent_reference _a9, typename tuple_type<A10>::transparent_reference _a10, typename tuple_type<A11>::transparent_reference _a11, typename tuple_type<A12>::transparent_reference _a12, typename tuple_type<A13>::transparent_reference _a13, typename tuple_type<A14>::transparent_reference _a14, typename tuple_type<A15>::transparent_reference _a15, typename tuple_type<A16>::transparent_reference _a16, typename tuple_type<A17>::transparent_reference _a17, typename tuple_type<A18>::transparent_reference _a18, typename tuple_type<A19>::transparent_reference _a19, typename tuple_type<A20>::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(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*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 <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +inline typename type::tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, N>::reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& t) +{ return t.template get<N>(); } +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +inline typename type::const_tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>, N>::const_reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20> const& t) +{ return t.template get<N>(); } + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> { + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0, typename tuple_type<A1>::transparent_reference _a1, typename tuple_type<A2>::transparent_reference _a2, typename tuple_type<A3>::transparent_reference _a3, typename tuple_type<A4>::transparent_reference _a4, typename tuple_type<A5>::transparent_reference _a5, typename tuple_type<A6>::transparent_reference _a6, typename tuple_type<A7>::transparent_reference _a7, typename tuple_type<A8>::transparent_reference _a8, typename tuple_type<A9>::transparent_reference _a9, typename tuple_type<A10>::transparent_reference _a10, typename tuple_type<A11>::transparent_reference _a11, typename tuple_type<A12>::transparent_reference _a12, typename tuple_type<A13>::transparent_reference _a13, typename tuple_type<A14>::transparent_reference _a14, typename tuple_type<A15>::transparent_reference _a15, typename tuple_type<A16>::transparent_reference _a16, typename tuple_type<A17>::transparent_reference _a17, typename tuple_type<A18>::transparent_reference _a18, typename tuple_type<A19>::transparent_reference _a19, typename tuple_type<A20>::transparent_reference _a20, typename tuple_type<A21>::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(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*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 <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +inline typename type::tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, N>::reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& t) +{ return t.template get<N>(); } +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +inline typename type::const_tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>, N>::const_reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> const& t) +{ return t.template get<N>(); } + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22> { + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0, typename tuple_type<A1>::transparent_reference _a1, typename tuple_type<A2>::transparent_reference _a2, typename tuple_type<A3>::transparent_reference _a3, typename tuple_type<A4>::transparent_reference _a4, typename tuple_type<A5>::transparent_reference _a5, typename tuple_type<A6>::transparent_reference _a6, typename tuple_type<A7>::transparent_reference _a7, typename tuple_type<A8>::transparent_reference _a8, typename tuple_type<A9>::transparent_reference _a9, typename tuple_type<A10>::transparent_reference _a10, typename tuple_type<A11>::transparent_reference _a11, typename tuple_type<A12>::transparent_reference _a12, typename tuple_type<A13>::transparent_reference _a13, typename tuple_type<A14>::transparent_reference _a14, typename tuple_type<A15>::transparent_reference _a15, typename tuple_type<A16>::transparent_reference _a16, typename tuple_type<A17>::transparent_reference _a17, typename tuple_type<A18>::transparent_reference _a18, typename tuple_type<A19>::transparent_reference _a19, typename tuple_type<A20>::transparent_reference _a20, typename tuple_type<A21>::transparent_reference _a21, typename tuple_type<A22>::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(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*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 <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +inline typename type::tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, N>::reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& t) +{ return t.template get<N>(); } +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +inline typename type::const_tuple_element<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>, N>::const_reference get(type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22> const& t) +{ return t.template get<N>(); } + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct 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> { + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0, typename tuple_type<A1>::transparent_reference _a1, typename tuple_type<A2>::transparent_reference _a2, typename tuple_type<A3>::transparent_reference _a3, typename tuple_type<A4>::transparent_reference _a4, typename tuple_type<A5>::transparent_reference _a5, typename tuple_type<A6>::transparent_reference _a6, typename tuple_type<A7>::transparent_reference _a7, typename tuple_type<A8>::transparent_reference _a8, typename tuple_type<A9>::transparent_reference _a9, typename tuple_type<A10>::transparent_reference _a10, typename tuple_type<A11>::transparent_reference _a11, typename tuple_type<A12>::transparent_reference _a12, typename tuple_type<A13>::transparent_reference _a13, typename tuple_type<A14>::transparent_reference _a14, typename tuple_type<A15>::transparent_reference _a15, typename tuple_type<A16>::transparent_reference _a16, typename tuple_type<A17>::transparent_reference _a17, typename tuple_type<A18>::transparent_reference _a18, typename tuple_type<A19>::transparent_reference _a19, typename tuple_type<A20>::transparent_reference _a20, typename tuple_type<A21>::transparent_reference _a21, typename tuple_type<A22>::transparent_reference _a22, typename tuple_type<A23>::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(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*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 <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +inline typename type::tuple_element<type::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>, N>::reference get(type::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>& t) +{ return t.template get<N>(); } +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +inline typename type::const_tuple_element<type::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>, N>::const_reference get(type::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> const& t) +{ return t.template get<N>(); } + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct 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> { + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0, typename tuple_type<A1>::transparent_reference _a1, typename tuple_type<A2>::transparent_reference _a2, typename tuple_type<A3>::transparent_reference _a3, typename tuple_type<A4>::transparent_reference _a4, typename tuple_type<A5>::transparent_reference _a5, typename tuple_type<A6>::transparent_reference _a6, typename tuple_type<A7>::transparent_reference _a7, typename tuple_type<A8>::transparent_reference _a8, typename tuple_type<A9>::transparent_reference _a9, typename tuple_type<A10>::transparent_reference _a10, typename tuple_type<A11>::transparent_reference _a11, typename tuple_type<A12>::transparent_reference _a12, typename tuple_type<A13>::transparent_reference _a13, typename tuple_type<A14>::transparent_reference _a14, typename tuple_type<A15>::transparent_reference _a15, typename tuple_type<A16>::transparent_reference _a16, typename tuple_type<A17>::transparent_reference _a17, typename tuple_type<A18>::transparent_reference _a18, typename tuple_type<A19>::transparent_reference _a19, typename tuple_type<A20>::transparent_reference _a20, typename tuple_type<A21>::transparent_reference _a21, typename tuple_type<A22>::transparent_reference _a22, typename tuple_type<A23>::transparent_reference _a23, typename tuple_type<A24>::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(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*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 <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +inline typename type::tuple_element<type::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>, N>::reference get(type::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>& t) +{ return t.template get<N>(); } +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +inline typename type::const_tuple_element<type::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>, N>::const_reference get(type::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> const& t) +{ return t.template get<N>(); } + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct 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> { + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0, typename tuple_type<A1>::transparent_reference _a1, typename tuple_type<A2>::transparent_reference _a2, typename tuple_type<A3>::transparent_reference _a3, typename tuple_type<A4>::transparent_reference _a4, typename tuple_type<A5>::transparent_reference _a5, typename tuple_type<A6>::transparent_reference _a6, typename tuple_type<A7>::transparent_reference _a7, typename tuple_type<A8>::transparent_reference _a8, typename tuple_type<A9>::transparent_reference _a9, typename tuple_type<A10>::transparent_reference _a10, typename tuple_type<A11>::transparent_reference _a11, typename tuple_type<A12>::transparent_reference _a12, typename tuple_type<A13>::transparent_reference _a13, typename tuple_type<A14>::transparent_reference _a14, typename tuple_type<A15>::transparent_reference _a15, typename tuple_type<A16>::transparent_reference _a16, typename tuple_type<A17>::transparent_reference _a17, typename tuple_type<A18>::transparent_reference _a18, typename tuple_type<A19>::transparent_reference _a19, typename tuple_type<A20>::transparent_reference _a20, typename tuple_type<A21>::transparent_reference _a21, typename tuple_type<A22>::transparent_reference _a22, typename tuple_type<A23>::transparent_reference _a23, typename tuple_type<A24>::transparent_reference _a24, typename tuple_type<A25>::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(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*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 <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +inline typename type::tuple_element<type::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>, N>::reference get(type::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>& t) +{ return t.template get<N>(); } +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +inline typename type::const_tuple_element<type::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>, N>::const_reference get(type::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> const& t) +{ return t.template get<N>(); } + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct 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> { + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0, typename tuple_type<A1>::transparent_reference _a1, typename tuple_type<A2>::transparent_reference _a2, typename tuple_type<A3>::transparent_reference _a3, typename tuple_type<A4>::transparent_reference _a4, typename tuple_type<A5>::transparent_reference _a5, typename tuple_type<A6>::transparent_reference _a6, typename tuple_type<A7>::transparent_reference _a7, typename tuple_type<A8>::transparent_reference _a8, typename tuple_type<A9>::transparent_reference _a9, typename tuple_type<A10>::transparent_reference _a10, typename tuple_type<A11>::transparent_reference _a11, typename tuple_type<A12>::transparent_reference _a12, typename tuple_type<A13>::transparent_reference _a13, typename tuple_type<A14>::transparent_reference _a14, typename tuple_type<A15>::transparent_reference _a15, typename tuple_type<A16>::transparent_reference _a16, typename tuple_type<A17>::transparent_reference _a17, typename tuple_type<A18>::transparent_reference _a18, typename tuple_type<A19>::transparent_reference _a19, typename tuple_type<A20>::transparent_reference _a20, typename tuple_type<A21>::transparent_reference _a21, typename tuple_type<A22>::transparent_reference _a22, typename tuple_type<A23>::transparent_reference _a23, typename tuple_type<A24>::transparent_reference _a24, typename tuple_type<A25>::transparent_reference _a25, typename tuple_type<A26>::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(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*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 <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +inline typename type::tuple_element<type::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>, N>::reference get(type::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>& t) +{ return t.template get<N>(); } +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +inline typename type::const_tuple_element<type::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>, N>::const_reference get(type::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> const& t) +{ return t.template get<N>(); } + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct 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> { + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0, typename tuple_type<A1>::transparent_reference _a1, typename tuple_type<A2>::transparent_reference _a2, typename tuple_type<A3>::transparent_reference _a3, typename tuple_type<A4>::transparent_reference _a4, typename tuple_type<A5>::transparent_reference _a5, typename tuple_type<A6>::transparent_reference _a6, typename tuple_type<A7>::transparent_reference _a7, typename tuple_type<A8>::transparent_reference _a8, typename tuple_type<A9>::transparent_reference _a9, typename tuple_type<A10>::transparent_reference _a10, typename tuple_type<A11>::transparent_reference _a11, typename tuple_type<A12>::transparent_reference _a12, typename tuple_type<A13>::transparent_reference _a13, typename tuple_type<A14>::transparent_reference _a14, typename tuple_type<A15>::transparent_reference _a15, typename tuple_type<A16>::transparent_reference _a16, typename tuple_type<A17>::transparent_reference _a17, typename tuple_type<A18>::transparent_reference _a18, typename tuple_type<A19>::transparent_reference _a19, typename tuple_type<A20>::transparent_reference _a20, typename tuple_type<A21>::transparent_reference _a21, typename tuple_type<A22>::transparent_reference _a22, typename tuple_type<A23>::transparent_reference _a23, typename tuple_type<A24>::transparent_reference _a24, typename tuple_type<A25>::transparent_reference _a25, typename tuple_type<A26>::transparent_reference _a26, typename tuple_type<A27>::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(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*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 <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +inline typename type::tuple_element<type::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>, N>::reference get(type::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>& t) +{ return t.template get<N>(); } +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +inline typename type::const_tuple_element<type::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>, N>::const_reference get(type::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> const& t) +{ return t.template get<N>(); } + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct 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> { + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0, typename tuple_type<A1>::transparent_reference _a1, typename tuple_type<A2>::transparent_reference _a2, typename tuple_type<A3>::transparent_reference _a3, typename tuple_type<A4>::transparent_reference _a4, typename tuple_type<A5>::transparent_reference _a5, typename tuple_type<A6>::transparent_reference _a6, typename tuple_type<A7>::transparent_reference _a7, typename tuple_type<A8>::transparent_reference _a8, typename tuple_type<A9>::transparent_reference _a9, typename tuple_type<A10>::transparent_reference _a10, typename tuple_type<A11>::transparent_reference _a11, typename tuple_type<A12>::transparent_reference _a12, typename tuple_type<A13>::transparent_reference _a13, typename tuple_type<A14>::transparent_reference _a14, typename tuple_type<A15>::transparent_reference _a15, typename tuple_type<A16>::transparent_reference _a16, typename tuple_type<A17>::transparent_reference _a17, typename tuple_type<A18>::transparent_reference _a18, typename tuple_type<A19>::transparent_reference _a19, typename tuple_type<A20>::transparent_reference _a20, typename tuple_type<A21>::transparent_reference _a21, typename tuple_type<A22>::transparent_reference _a22, typename tuple_type<A23>::transparent_reference _a23, typename tuple_type<A24>::transparent_reference _a24, typename tuple_type<A25>::transparent_reference _a25, typename tuple_type<A26>::transparent_reference _a26, typename tuple_type<A27>::transparent_reference _a27, typename tuple_type<A28>::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(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*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 <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +inline typename type::tuple_element<type::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>, N>::reference get(type::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>& t) +{ return t.template get<N>(); } +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +inline typename type::const_tuple_element<type::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>, N>::const_reference get(type::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> const& t) +{ return t.template get<N>(); } + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct 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> { + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0, typename tuple_type<A1>::transparent_reference _a1, typename tuple_type<A2>::transparent_reference _a2, typename tuple_type<A3>::transparent_reference _a3, typename tuple_type<A4>::transparent_reference _a4, typename tuple_type<A5>::transparent_reference _a5, typename tuple_type<A6>::transparent_reference _a6, typename tuple_type<A7>::transparent_reference _a7, typename tuple_type<A8>::transparent_reference _a8, typename tuple_type<A9>::transparent_reference _a9, typename tuple_type<A10>::transparent_reference _a10, typename tuple_type<A11>::transparent_reference _a11, typename tuple_type<A12>::transparent_reference _a12, typename tuple_type<A13>::transparent_reference _a13, typename tuple_type<A14>::transparent_reference _a14, typename tuple_type<A15>::transparent_reference _a15, typename tuple_type<A16>::transparent_reference _a16, typename tuple_type<A17>::transparent_reference _a17, typename tuple_type<A18>::transparent_reference _a18, typename tuple_type<A19>::transparent_reference _a19, typename tuple_type<A20>::transparent_reference _a20, typename tuple_type<A21>::transparent_reference _a21, typename tuple_type<A22>::transparent_reference _a22, typename tuple_type<A23>::transparent_reference _a23, typename tuple_type<A24>::transparent_reference _a24, typename tuple_type<A25>::transparent_reference _a25, typename tuple_type<A26>::transparent_reference _a26, typename tuple_type<A27>::transparent_reference _a27, typename tuple_type<A28>::transparent_reference _a28, typename tuple_type<A29>::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(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*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 <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +inline typename type::tuple_element<type::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>, N>::reference get(type::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>& t) +{ return t.template get<N>(); } +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +inline typename type::const_tuple_element<type::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>, N>::const_reference get(type::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> const& t) +{ return t.template get<N>(); } + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct 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> { + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0, typename tuple_type<A1>::transparent_reference _a1, typename tuple_type<A2>::transparent_reference _a2, typename tuple_type<A3>::transparent_reference _a3, typename tuple_type<A4>::transparent_reference _a4, typename tuple_type<A5>::transparent_reference _a5, typename tuple_type<A6>::transparent_reference _a6, typename tuple_type<A7>::transparent_reference _a7, typename tuple_type<A8>::transparent_reference _a8, typename tuple_type<A9>::transparent_reference _a9, typename tuple_type<A10>::transparent_reference _a10, typename tuple_type<A11>::transparent_reference _a11, typename tuple_type<A12>::transparent_reference _a12, typename tuple_type<A13>::transparent_reference _a13, typename tuple_type<A14>::transparent_reference _a14, typename tuple_type<A15>::transparent_reference _a15, typename tuple_type<A16>::transparent_reference _a16, typename tuple_type<A17>::transparent_reference _a17, typename tuple_type<A18>::transparent_reference _a18, typename tuple_type<A19>::transparent_reference _a19, typename tuple_type<A20>::transparent_reference _a20, typename tuple_type<A21>::transparent_reference _a21, typename tuple_type<A22>::transparent_reference _a22, typename tuple_type<A23>::transparent_reference _a23, typename tuple_type<A24>::transparent_reference _a24, typename tuple_type<A25>::transparent_reference _a25, typename tuple_type<A26>::transparent_reference _a26, typename tuple_type<A27>::transparent_reference _a27, typename tuple_type<A28>::transparent_reference _a28, typename tuple_type<A29>::transparent_reference _a29, typename tuple_type<A30>::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(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*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 <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +inline typename type::tuple_element<type::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>, N>::reference get(type::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>& t) +{ return t.template get<N>(); } +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +inline typename type::const_tuple_element<type::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>, N>::const_reference get(type::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> const& t) +{ return t.template get<N>(); } + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct 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> { + typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31> value_type; + tuple() {} + tuple(typename tuple_type<A0>::transparent_reference _a0, typename tuple_type<A1>::transparent_reference _a1, typename tuple_type<A2>::transparent_reference _a2, typename tuple_type<A3>::transparent_reference _a3, typename tuple_type<A4>::transparent_reference _a4, typename tuple_type<A5>::transparent_reference _a5, typename tuple_type<A6>::transparent_reference _a6, typename tuple_type<A7>::transparent_reference _a7, typename tuple_type<A8>::transparent_reference _a8, typename tuple_type<A9>::transparent_reference _a9, typename tuple_type<A10>::transparent_reference _a10, typename tuple_type<A11>::transparent_reference _a11, typename tuple_type<A12>::transparent_reference _a12, typename tuple_type<A13>::transparent_reference _a13, typename tuple_type<A14>::transparent_reference _a14, typename tuple_type<A15>::transparent_reference _a15, typename tuple_type<A16>::transparent_reference _a16, typename tuple_type<A17>::transparent_reference _a17, typename tuple_type<A18>::transparent_reference _a18, typename tuple_type<A19>::transparent_reference _a19, typename tuple_type<A20>::transparent_reference _a20, typename tuple_type<A21>::transparent_reference _a21, typename tuple_type<A22>::transparent_reference _a22, typename tuple_type<A23>::transparent_reference _a23, typename tuple_type<A24>::transparent_reference _a24, typename tuple_type<A25>::transparent_reference _a25, typename tuple_type<A26>::transparent_reference _a26, typename tuple_type<A27>::transparent_reference _a27, typename tuple_type<A28>::transparent_reference _a28, typename tuple_type<A29>::transparent_reference _a29, typename tuple_type<A30>::transparent_reference _a30, typename tuple_type<A31>::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(clmdep_msgpack::object const& o) { o.convert(*this); } + template <int N> typename tuple_element<value_type, N>::reference get() + { return tuple_element<value_type, N>(*this).get(); } + template <int N> typename const_tuple_element<value_type, N>::const_reference get() const + { return const_tuple_element<value_type, N>(*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 <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +inline typename type::tuple_element<type::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>, N>::reference get(type::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>& t) +{ return t.template get<N>(); } +template <int N, typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +inline typename type::const_tuple_element<type::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>, N>::const_reference get(type::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> const& t) +{ return t.template get<N>(); } + +/// @endcond + +inline tuple<> make_tuple() +{ + return tuple<>(); +} + +/// @cond + +template <typename A0> +inline tuple<A0> make_tuple(typename tuple_type<A0>::transparent_reference a0) +{ + return tuple<A0>(a0); +} + +template <typename A0, typename A1> +inline tuple<A0, A1> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1) +{ + return tuple<A0, A1>(a0, a1); +} + +template <typename A0, typename A1, typename A2> +inline tuple<A0, A1, A2> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2) +{ + return tuple<A0, A1, A2>(a0, a1, a2); +} + +template <typename A0, typename A1, typename A2, typename A3> +inline tuple<A0, A1, A2, A3> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3) +{ + return tuple<A0, A1, A2, A3>(a0, a1, a2, a3); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4> +inline tuple<A0, A1, A2, A3, A4> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4) +{ + return tuple<A0, A1, A2, A3, A4>(a0, a1, a2, a3, a4); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5> +inline tuple<A0, A1, A2, A3, A4, A5> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5) +{ + return tuple<A0, A1, A2, A3, A4, A5>(a0, a1, a2, a3, a4, a5); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6> +inline tuple<A0, A1, A2, A3, A4, A5, A6> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6) +{ + return tuple<A0, A1, A2, A3, A4, A5, A6>(a0, a1, a2, a3, a4, a5, a6); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> +inline tuple<A0, A1, A2, A3, A4, A5, A6, A7> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7) +{ + return tuple<A0, A1, A2, A3, A4, A5, A6, A7>(a0, a1, a2, a3, a4, a5, a6, a7); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> +inline tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8) +{ + return tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>(a0, a1, a2, a3, a4, a5, a6, a7, a8); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> +inline tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9) +{ + return tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +inline tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10) +{ + return tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +inline tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11) +{ + return tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +inline tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12) +{ + return tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +inline tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13) +{ + return tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +inline tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14) +{ + return tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +inline tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15) +{ + return tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +inline tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16) +{ + return tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +inline tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17) +{ + return tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +inline tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18) +{ + return tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +inline tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::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>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +inline tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::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>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +inline tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::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>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +inline tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21, typename tuple_type<A22>::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>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22); +} + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +inline 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> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21, typename tuple_type<A22>::transparent_reference a22, typename tuple_type<A23>::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>(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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +inline 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> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21, typename tuple_type<A22>::transparent_reference a22, typename tuple_type<A23>::transparent_reference a23, typename tuple_type<A24>::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>(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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +inline 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> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21, typename tuple_type<A22>::transparent_reference a22, typename tuple_type<A23>::transparent_reference a23, typename tuple_type<A24>::transparent_reference a24, typename tuple_type<A25>::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>(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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +inline 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> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21, typename tuple_type<A22>::transparent_reference a22, typename tuple_type<A23>::transparent_reference a23, typename tuple_type<A24>::transparent_reference a24, typename tuple_type<A25>::transparent_reference a25, typename tuple_type<A26>::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>(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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +inline 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> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21, typename tuple_type<A22>::transparent_reference a22, typename tuple_type<A23>::transparent_reference a23, typename tuple_type<A24>::transparent_reference a24, typename tuple_type<A25>::transparent_reference a25, typename tuple_type<A26>::transparent_reference a26, typename tuple_type<A27>::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>(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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +inline 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> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21, typename tuple_type<A22>::transparent_reference a22, typename tuple_type<A23>::transparent_reference a23, typename tuple_type<A24>::transparent_reference a24, typename tuple_type<A25>::transparent_reference a25, typename tuple_type<A26>::transparent_reference a26, typename tuple_type<A27>::transparent_reference a27, typename tuple_type<A28>::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>(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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +inline 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> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21, typename tuple_type<A22>::transparent_reference a22, typename tuple_type<A23>::transparent_reference a23, typename tuple_type<A24>::transparent_reference a24, typename tuple_type<A25>::transparent_reference a25, typename tuple_type<A26>::transparent_reference a26, typename tuple_type<A27>::transparent_reference a27, typename tuple_type<A28>::transparent_reference a28, typename tuple_type<A29>::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>(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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +inline 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> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21, typename tuple_type<A22>::transparent_reference a22, typename tuple_type<A23>::transparent_reference a23, typename tuple_type<A24>::transparent_reference a24, typename tuple_type<A25>::transparent_reference a25, typename tuple_type<A26>::transparent_reference a26, typename tuple_type<A27>::transparent_reference a27, typename tuple_type<A28>::transparent_reference a28, typename tuple_type<A29>::transparent_reference a29, typename tuple_type<A30>::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>(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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +inline 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> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21, typename tuple_type<A22>::transparent_reference a22, typename tuple_type<A23>::transparent_reference a23, typename tuple_type<A24>::transparent_reference a24, typename tuple_type<A25>::transparent_reference a25, typename tuple_type<A26>::transparent_reference a26, typename tuple_type<A27>::transparent_reference a27, typename tuple_type<A28>::transparent_reference a28, typename tuple_type<A29>::transparent_reference a29, typename tuple_type<A30>::transparent_reference a30, typename tuple_type<A31>::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>(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); +} + +/// @endcond + +} // namespace type + +namespace adaptor { + +template <> +struct convert<type::tuple<> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::tuple<>&) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + return o; + } +}; + +/// @cond + +template <typename A0> +struct convert<type::tuple<A0> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::tuple<A0>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 1) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + return o; + } +}; + +template <typename A0, typename A1> +struct convert<type::tuple<A0, A1> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::tuple<A0, A1>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 2) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[1].clmdep_msgpack::object::convert<typename type::tuple_type<A1>::type>(v.template get<1>()); + return o; + } +}; + +template <typename A0, typename A1, typename A2> +struct convert<type::tuple<A0, A1, A2> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::tuple<A0, A1, A2>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 3) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[1].clmdep_msgpack::object::convert<typename type::tuple_type<A1>::type>(v.template get<1>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[2].clmdep_msgpack::object::convert<typename type::tuple_type<A2>::type>(v.template get<2>()); + return o; + } +}; + +template <typename A0, typename A1, typename A2, typename A3> +struct convert<type::tuple<A0, A1, A2, A3> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::tuple<A0, A1, A2, A3>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 4) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[1].clmdep_msgpack::object::convert<typename type::tuple_type<A1>::type>(v.template get<1>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[2].clmdep_msgpack::object::convert<typename type::tuple_type<A2>::type>(v.template get<2>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[3].clmdep_msgpack::object::convert<typename type::tuple_type<A3>::type>(v.template get<3>()); + return o; + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4> +struct convert<type::tuple<A0, A1, A2, A3, A4> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::tuple<A0, A1, A2, A3, A4>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 5) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[1].clmdep_msgpack::object::convert<typename type::tuple_type<A1>::type>(v.template get<1>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[2].clmdep_msgpack::object::convert<typename type::tuple_type<A2>::type>(v.template get<2>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[3].clmdep_msgpack::object::convert<typename type::tuple_type<A3>::type>(v.template get<3>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[4].clmdep_msgpack::object::convert<typename type::tuple_type<A4>::type>(v.template get<4>()); + return o; + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5> +struct convert<type::tuple<A0, A1, A2, A3, A4, A5> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::tuple<A0, A1, A2, A3, A4, A5>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 6) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[1].clmdep_msgpack::object::convert<typename type::tuple_type<A1>::type>(v.template get<1>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[2].clmdep_msgpack::object::convert<typename type::tuple_type<A2>::type>(v.template get<2>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[3].clmdep_msgpack::object::convert<typename type::tuple_type<A3>::type>(v.template get<3>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[4].clmdep_msgpack::object::convert<typename type::tuple_type<A4>::type>(v.template get<4>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[5].clmdep_msgpack::object::convert<typename type::tuple_type<A5>::type>(v.template get<5>()); + return o; + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6> +struct convert<type::tuple<A0, A1, A2, A3, A4, A5, A6> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::tuple<A0, A1, A2, A3, A4, A5, A6>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 7) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[1].clmdep_msgpack::object::convert<typename type::tuple_type<A1>::type>(v.template get<1>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[2].clmdep_msgpack::object::convert<typename type::tuple_type<A2>::type>(v.template get<2>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[3].clmdep_msgpack::object::convert<typename type::tuple_type<A3>::type>(v.template get<3>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[4].clmdep_msgpack::object::convert<typename type::tuple_type<A4>::type>(v.template get<4>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[5].clmdep_msgpack::object::convert<typename type::tuple_type<A5>::type>(v.template get<5>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[6].clmdep_msgpack::object::convert<typename type::tuple_type<A6>::type>(v.template get<6>()); + return o; + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> +struct convert<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::tuple<A0, A1, A2, A3, A4, A5, A6, A7>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 8) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[1].clmdep_msgpack::object::convert<typename type::tuple_type<A1>::type>(v.template get<1>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[2].clmdep_msgpack::object::convert<typename type::tuple_type<A2>::type>(v.template get<2>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[3].clmdep_msgpack::object::convert<typename type::tuple_type<A3>::type>(v.template get<3>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[4].clmdep_msgpack::object::convert<typename type::tuple_type<A4>::type>(v.template get<4>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[5].clmdep_msgpack::object::convert<typename type::tuple_type<A5>::type>(v.template get<5>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[6].clmdep_msgpack::object::convert<typename type::tuple_type<A6>::type>(v.template get<6>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[7].clmdep_msgpack::object::convert<typename type::tuple_type<A7>::type>(v.template get<7>()); + return o; + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> +struct convert<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 9) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[1].clmdep_msgpack::object::convert<typename type::tuple_type<A1>::type>(v.template get<1>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[2].clmdep_msgpack::object::convert<typename type::tuple_type<A2>::type>(v.template get<2>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[3].clmdep_msgpack::object::convert<typename type::tuple_type<A3>::type>(v.template get<3>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[4].clmdep_msgpack::object::convert<typename type::tuple_type<A4>::type>(v.template get<4>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[5].clmdep_msgpack::object::convert<typename type::tuple_type<A5>::type>(v.template get<5>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[6].clmdep_msgpack::object::convert<typename type::tuple_type<A6>::type>(v.template get<6>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[7].clmdep_msgpack::object::convert<typename type::tuple_type<A7>::type>(v.template get<7>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[8].clmdep_msgpack::object::convert<typename type::tuple_type<A8>::type>(v.template get<8>()); + return o; + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> +struct convert<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 10) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[1].clmdep_msgpack::object::convert<typename type::tuple_type<A1>::type>(v.template get<1>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[2].clmdep_msgpack::object::convert<typename type::tuple_type<A2>::type>(v.template get<2>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[3].clmdep_msgpack::object::convert<typename type::tuple_type<A3>::type>(v.template get<3>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[4].clmdep_msgpack::object::convert<typename type::tuple_type<A4>::type>(v.template get<4>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[5].clmdep_msgpack::object::convert<typename type::tuple_type<A5>::type>(v.template get<5>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[6].clmdep_msgpack::object::convert<typename type::tuple_type<A6>::type>(v.template get<6>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[7].clmdep_msgpack::object::convert<typename type::tuple_type<A7>::type>(v.template get<7>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[8].clmdep_msgpack::object::convert<typename type::tuple_type<A8>::type>(v.template get<8>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[9].clmdep_msgpack::object::convert<typename type::tuple_type<A9>::type>(v.template get<9>()); + return o; + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +struct convert<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 11) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[1].clmdep_msgpack::object::convert<typename type::tuple_type<A1>::type>(v.template get<1>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[2].clmdep_msgpack::object::convert<typename type::tuple_type<A2>::type>(v.template get<2>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[3].clmdep_msgpack::object::convert<typename type::tuple_type<A3>::type>(v.template get<3>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[4].clmdep_msgpack::object::convert<typename type::tuple_type<A4>::type>(v.template get<4>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[5].clmdep_msgpack::object::convert<typename type::tuple_type<A5>::type>(v.template get<5>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[6].clmdep_msgpack::object::convert<typename type::tuple_type<A6>::type>(v.template get<6>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[7].clmdep_msgpack::object::convert<typename type::tuple_type<A7>::type>(v.template get<7>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[8].clmdep_msgpack::object::convert<typename type::tuple_type<A8>::type>(v.template get<8>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[9].clmdep_msgpack::object::convert<typename type::tuple_type<A9>::type>(v.template get<9>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[10].clmdep_msgpack::object::convert<typename type::tuple_type<A10>::type>(v.template get<10>()); + return o; + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +struct convert<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 12) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[1].clmdep_msgpack::object::convert<typename type::tuple_type<A1>::type>(v.template get<1>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[2].clmdep_msgpack::object::convert<typename type::tuple_type<A2>::type>(v.template get<2>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[3].clmdep_msgpack::object::convert<typename type::tuple_type<A3>::type>(v.template get<3>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[4].clmdep_msgpack::object::convert<typename type::tuple_type<A4>::type>(v.template get<4>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[5].clmdep_msgpack::object::convert<typename type::tuple_type<A5>::type>(v.template get<5>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[6].clmdep_msgpack::object::convert<typename type::tuple_type<A6>::type>(v.template get<6>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[7].clmdep_msgpack::object::convert<typename type::tuple_type<A7>::type>(v.template get<7>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[8].clmdep_msgpack::object::convert<typename type::tuple_type<A8>::type>(v.template get<8>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[9].clmdep_msgpack::object::convert<typename type::tuple_type<A9>::type>(v.template get<9>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[10].clmdep_msgpack::object::convert<typename type::tuple_type<A10>::type>(v.template get<10>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[11].clmdep_msgpack::object::convert<typename type::tuple_type<A11>::type>(v.template get<11>()); + return o; + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +struct convert<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 13) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[1].clmdep_msgpack::object::convert<typename type::tuple_type<A1>::type>(v.template get<1>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[2].clmdep_msgpack::object::convert<typename type::tuple_type<A2>::type>(v.template get<2>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[3].clmdep_msgpack::object::convert<typename type::tuple_type<A3>::type>(v.template get<3>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[4].clmdep_msgpack::object::convert<typename type::tuple_type<A4>::type>(v.template get<4>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[5].clmdep_msgpack::object::convert<typename type::tuple_type<A5>::type>(v.template get<5>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[6].clmdep_msgpack::object::convert<typename type::tuple_type<A6>::type>(v.template get<6>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[7].clmdep_msgpack::object::convert<typename type::tuple_type<A7>::type>(v.template get<7>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[8].clmdep_msgpack::object::convert<typename type::tuple_type<A8>::type>(v.template get<8>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[9].clmdep_msgpack::object::convert<typename type::tuple_type<A9>::type>(v.template get<9>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[10].clmdep_msgpack::object::convert<typename type::tuple_type<A10>::type>(v.template get<10>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[11].clmdep_msgpack::object::convert<typename type::tuple_type<A11>::type>(v.template get<11>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[12].clmdep_msgpack::object::convert<typename type::tuple_type<A12>::type>(v.template get<12>()); + return o; + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct convert<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 14) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[1].clmdep_msgpack::object::convert<typename type::tuple_type<A1>::type>(v.template get<1>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[2].clmdep_msgpack::object::convert<typename type::tuple_type<A2>::type>(v.template get<2>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[3].clmdep_msgpack::object::convert<typename type::tuple_type<A3>::type>(v.template get<3>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[4].clmdep_msgpack::object::convert<typename type::tuple_type<A4>::type>(v.template get<4>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[5].clmdep_msgpack::object::convert<typename type::tuple_type<A5>::type>(v.template get<5>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[6].clmdep_msgpack::object::convert<typename type::tuple_type<A6>::type>(v.template get<6>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[7].clmdep_msgpack::object::convert<typename type::tuple_type<A7>::type>(v.template get<7>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[8].clmdep_msgpack::object::convert<typename type::tuple_type<A8>::type>(v.template get<8>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[9].clmdep_msgpack::object::convert<typename type::tuple_type<A9>::type>(v.template get<9>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[10].clmdep_msgpack::object::convert<typename type::tuple_type<A10>::type>(v.template get<10>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[11].clmdep_msgpack::object::convert<typename type::tuple_type<A11>::type>(v.template get<11>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[12].clmdep_msgpack::object::convert<typename type::tuple_type<A12>::type>(v.template get<12>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[13].clmdep_msgpack::object::convert<typename type::tuple_type<A13>::type>(v.template get<13>()); + return o; + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct convert<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 15) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[1].clmdep_msgpack::object::convert<typename type::tuple_type<A1>::type>(v.template get<1>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[2].clmdep_msgpack::object::convert<typename type::tuple_type<A2>::type>(v.template get<2>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[3].clmdep_msgpack::object::convert<typename type::tuple_type<A3>::type>(v.template get<3>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[4].clmdep_msgpack::object::convert<typename type::tuple_type<A4>::type>(v.template get<4>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[5].clmdep_msgpack::object::convert<typename type::tuple_type<A5>::type>(v.template get<5>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[6].clmdep_msgpack::object::convert<typename type::tuple_type<A6>::type>(v.template get<6>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[7].clmdep_msgpack::object::convert<typename type::tuple_type<A7>::type>(v.template get<7>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[8].clmdep_msgpack::object::convert<typename type::tuple_type<A8>::type>(v.template get<8>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[9].clmdep_msgpack::object::convert<typename type::tuple_type<A9>::type>(v.template get<9>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[10].clmdep_msgpack::object::convert<typename type::tuple_type<A10>::type>(v.template get<10>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[11].clmdep_msgpack::object::convert<typename type::tuple_type<A11>::type>(v.template get<11>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[12].clmdep_msgpack::object::convert<typename type::tuple_type<A12>::type>(v.template get<12>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[13].clmdep_msgpack::object::convert<typename type::tuple_type<A13>::type>(v.template get<13>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[14].clmdep_msgpack::object::convert<typename type::tuple_type<A14>::type>(v.template get<14>()); + return o; + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct convert<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 16) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[1].clmdep_msgpack::object::convert<typename type::tuple_type<A1>::type>(v.template get<1>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[2].clmdep_msgpack::object::convert<typename type::tuple_type<A2>::type>(v.template get<2>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[3].clmdep_msgpack::object::convert<typename type::tuple_type<A3>::type>(v.template get<3>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[4].clmdep_msgpack::object::convert<typename type::tuple_type<A4>::type>(v.template get<4>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[5].clmdep_msgpack::object::convert<typename type::tuple_type<A5>::type>(v.template get<5>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[6].clmdep_msgpack::object::convert<typename type::tuple_type<A6>::type>(v.template get<6>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[7].clmdep_msgpack::object::convert<typename type::tuple_type<A7>::type>(v.template get<7>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[8].clmdep_msgpack::object::convert<typename type::tuple_type<A8>::type>(v.template get<8>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[9].clmdep_msgpack::object::convert<typename type::tuple_type<A9>::type>(v.template get<9>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[10].clmdep_msgpack::object::convert<typename type::tuple_type<A10>::type>(v.template get<10>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[11].clmdep_msgpack::object::convert<typename type::tuple_type<A11>::type>(v.template get<11>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[12].clmdep_msgpack::object::convert<typename type::tuple_type<A12>::type>(v.template get<12>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[13].clmdep_msgpack::object::convert<typename type::tuple_type<A13>::type>(v.template get<13>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[14].clmdep_msgpack::object::convert<typename type::tuple_type<A14>::type>(v.template get<14>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[15].clmdep_msgpack::object::convert<typename type::tuple_type<A15>::type>(v.template get<15>()); + return o; + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct convert<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 17) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[1].clmdep_msgpack::object::convert<typename type::tuple_type<A1>::type>(v.template get<1>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[2].clmdep_msgpack::object::convert<typename type::tuple_type<A2>::type>(v.template get<2>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[3].clmdep_msgpack::object::convert<typename type::tuple_type<A3>::type>(v.template get<3>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[4].clmdep_msgpack::object::convert<typename type::tuple_type<A4>::type>(v.template get<4>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[5].clmdep_msgpack::object::convert<typename type::tuple_type<A5>::type>(v.template get<5>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[6].clmdep_msgpack::object::convert<typename type::tuple_type<A6>::type>(v.template get<6>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[7].clmdep_msgpack::object::convert<typename type::tuple_type<A7>::type>(v.template get<7>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[8].clmdep_msgpack::object::convert<typename type::tuple_type<A8>::type>(v.template get<8>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[9].clmdep_msgpack::object::convert<typename type::tuple_type<A9>::type>(v.template get<9>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[10].clmdep_msgpack::object::convert<typename type::tuple_type<A10>::type>(v.template get<10>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[11].clmdep_msgpack::object::convert<typename type::tuple_type<A11>::type>(v.template get<11>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[12].clmdep_msgpack::object::convert<typename type::tuple_type<A12>::type>(v.template get<12>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[13].clmdep_msgpack::object::convert<typename type::tuple_type<A13>::type>(v.template get<13>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[14].clmdep_msgpack::object::convert<typename type::tuple_type<A14>::type>(v.template get<14>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[15].clmdep_msgpack::object::convert<typename type::tuple_type<A15>::type>(v.template get<15>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[16].clmdep_msgpack::object::convert<typename type::tuple_type<A16>::type>(v.template get<16>()); + return o; + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct convert<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 18) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[1].clmdep_msgpack::object::convert<typename type::tuple_type<A1>::type>(v.template get<1>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[2].clmdep_msgpack::object::convert<typename type::tuple_type<A2>::type>(v.template get<2>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[3].clmdep_msgpack::object::convert<typename type::tuple_type<A3>::type>(v.template get<3>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[4].clmdep_msgpack::object::convert<typename type::tuple_type<A4>::type>(v.template get<4>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[5].clmdep_msgpack::object::convert<typename type::tuple_type<A5>::type>(v.template get<5>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[6].clmdep_msgpack::object::convert<typename type::tuple_type<A6>::type>(v.template get<6>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[7].clmdep_msgpack::object::convert<typename type::tuple_type<A7>::type>(v.template get<7>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[8].clmdep_msgpack::object::convert<typename type::tuple_type<A8>::type>(v.template get<8>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[9].clmdep_msgpack::object::convert<typename type::tuple_type<A9>::type>(v.template get<9>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[10].clmdep_msgpack::object::convert<typename type::tuple_type<A10>::type>(v.template get<10>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[11].clmdep_msgpack::object::convert<typename type::tuple_type<A11>::type>(v.template get<11>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[12].clmdep_msgpack::object::convert<typename type::tuple_type<A12>::type>(v.template get<12>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[13].clmdep_msgpack::object::convert<typename type::tuple_type<A13>::type>(v.template get<13>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[14].clmdep_msgpack::object::convert<typename type::tuple_type<A14>::type>(v.template get<14>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[15].clmdep_msgpack::object::convert<typename type::tuple_type<A15>::type>(v.template get<15>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[16].clmdep_msgpack::object::convert<typename type::tuple_type<A16>::type>(v.template get<16>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[17].clmdep_msgpack::object::convert<typename type::tuple_type<A17>::type>(v.template get<17>()); + return o; + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct convert<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 19) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[1].clmdep_msgpack::object::convert<typename type::tuple_type<A1>::type>(v.template get<1>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[2].clmdep_msgpack::object::convert<typename type::tuple_type<A2>::type>(v.template get<2>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[3].clmdep_msgpack::object::convert<typename type::tuple_type<A3>::type>(v.template get<3>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[4].clmdep_msgpack::object::convert<typename type::tuple_type<A4>::type>(v.template get<4>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[5].clmdep_msgpack::object::convert<typename type::tuple_type<A5>::type>(v.template get<5>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[6].clmdep_msgpack::object::convert<typename type::tuple_type<A6>::type>(v.template get<6>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[7].clmdep_msgpack::object::convert<typename type::tuple_type<A7>::type>(v.template get<7>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[8].clmdep_msgpack::object::convert<typename type::tuple_type<A8>::type>(v.template get<8>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[9].clmdep_msgpack::object::convert<typename type::tuple_type<A9>::type>(v.template get<9>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[10].clmdep_msgpack::object::convert<typename type::tuple_type<A10>::type>(v.template get<10>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[11].clmdep_msgpack::object::convert<typename type::tuple_type<A11>::type>(v.template get<11>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[12].clmdep_msgpack::object::convert<typename type::tuple_type<A12>::type>(v.template get<12>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[13].clmdep_msgpack::object::convert<typename type::tuple_type<A13>::type>(v.template get<13>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[14].clmdep_msgpack::object::convert<typename type::tuple_type<A14>::type>(v.template get<14>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[15].clmdep_msgpack::object::convert<typename type::tuple_type<A15>::type>(v.template get<15>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[16].clmdep_msgpack::object::convert<typename type::tuple_type<A16>::type>(v.template get<16>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[17].clmdep_msgpack::object::convert<typename type::tuple_type<A17>::type>(v.template get<17>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[18].clmdep_msgpack::object::convert<typename type::tuple_type<A18>::type>(v.template get<18>()); + return o; + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct convert<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 20) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[1].clmdep_msgpack::object::convert<typename type::tuple_type<A1>::type>(v.template get<1>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[2].clmdep_msgpack::object::convert<typename type::tuple_type<A2>::type>(v.template get<2>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[3].clmdep_msgpack::object::convert<typename type::tuple_type<A3>::type>(v.template get<3>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[4].clmdep_msgpack::object::convert<typename type::tuple_type<A4>::type>(v.template get<4>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[5].clmdep_msgpack::object::convert<typename type::tuple_type<A5>::type>(v.template get<5>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[6].clmdep_msgpack::object::convert<typename type::tuple_type<A6>::type>(v.template get<6>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[7].clmdep_msgpack::object::convert<typename type::tuple_type<A7>::type>(v.template get<7>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[8].clmdep_msgpack::object::convert<typename type::tuple_type<A8>::type>(v.template get<8>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[9].clmdep_msgpack::object::convert<typename type::tuple_type<A9>::type>(v.template get<9>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[10].clmdep_msgpack::object::convert<typename type::tuple_type<A10>::type>(v.template get<10>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[11].clmdep_msgpack::object::convert<typename type::tuple_type<A11>::type>(v.template get<11>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[12].clmdep_msgpack::object::convert<typename type::tuple_type<A12>::type>(v.template get<12>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[13].clmdep_msgpack::object::convert<typename type::tuple_type<A13>::type>(v.template get<13>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[14].clmdep_msgpack::object::convert<typename type::tuple_type<A14>::type>(v.template get<14>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[15].clmdep_msgpack::object::convert<typename type::tuple_type<A15>::type>(v.template get<15>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[16].clmdep_msgpack::object::convert<typename type::tuple_type<A16>::type>(v.template get<16>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[17].clmdep_msgpack::object::convert<typename type::tuple_type<A17>::type>(v.template get<17>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[18].clmdep_msgpack::object::convert<typename type::tuple_type<A18>::type>(v.template get<18>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[19].clmdep_msgpack::object::convert<typename type::tuple_type<A19>::type>(v.template get<19>()); + return o; + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct convert<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 21) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[1].clmdep_msgpack::object::convert<typename type::tuple_type<A1>::type>(v.template get<1>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[2].clmdep_msgpack::object::convert<typename type::tuple_type<A2>::type>(v.template get<2>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[3].clmdep_msgpack::object::convert<typename type::tuple_type<A3>::type>(v.template get<3>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[4].clmdep_msgpack::object::convert<typename type::tuple_type<A4>::type>(v.template get<4>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[5].clmdep_msgpack::object::convert<typename type::tuple_type<A5>::type>(v.template get<5>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[6].clmdep_msgpack::object::convert<typename type::tuple_type<A6>::type>(v.template get<6>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[7].clmdep_msgpack::object::convert<typename type::tuple_type<A7>::type>(v.template get<7>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[8].clmdep_msgpack::object::convert<typename type::tuple_type<A8>::type>(v.template get<8>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[9].clmdep_msgpack::object::convert<typename type::tuple_type<A9>::type>(v.template get<9>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[10].clmdep_msgpack::object::convert<typename type::tuple_type<A10>::type>(v.template get<10>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[11].clmdep_msgpack::object::convert<typename type::tuple_type<A11>::type>(v.template get<11>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[12].clmdep_msgpack::object::convert<typename type::tuple_type<A12>::type>(v.template get<12>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[13].clmdep_msgpack::object::convert<typename type::tuple_type<A13>::type>(v.template get<13>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[14].clmdep_msgpack::object::convert<typename type::tuple_type<A14>::type>(v.template get<14>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[15].clmdep_msgpack::object::convert<typename type::tuple_type<A15>::type>(v.template get<15>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[16].clmdep_msgpack::object::convert<typename type::tuple_type<A16>::type>(v.template get<16>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[17].clmdep_msgpack::object::convert<typename type::tuple_type<A17>::type>(v.template get<17>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[18].clmdep_msgpack::object::convert<typename type::tuple_type<A18>::type>(v.template get<18>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[19].clmdep_msgpack::object::convert<typename type::tuple_type<A19>::type>(v.template get<19>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[20].clmdep_msgpack::object::convert<typename type::tuple_type<A20>::type>(v.template get<20>()); + return o; + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct convert<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 22) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[1].clmdep_msgpack::object::convert<typename type::tuple_type<A1>::type>(v.template get<1>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[2].clmdep_msgpack::object::convert<typename type::tuple_type<A2>::type>(v.template get<2>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[3].clmdep_msgpack::object::convert<typename type::tuple_type<A3>::type>(v.template get<3>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[4].clmdep_msgpack::object::convert<typename type::tuple_type<A4>::type>(v.template get<4>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[5].clmdep_msgpack::object::convert<typename type::tuple_type<A5>::type>(v.template get<5>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[6].clmdep_msgpack::object::convert<typename type::tuple_type<A6>::type>(v.template get<6>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[7].clmdep_msgpack::object::convert<typename type::tuple_type<A7>::type>(v.template get<7>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[8].clmdep_msgpack::object::convert<typename type::tuple_type<A8>::type>(v.template get<8>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[9].clmdep_msgpack::object::convert<typename type::tuple_type<A9>::type>(v.template get<9>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[10].clmdep_msgpack::object::convert<typename type::tuple_type<A10>::type>(v.template get<10>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[11].clmdep_msgpack::object::convert<typename type::tuple_type<A11>::type>(v.template get<11>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[12].clmdep_msgpack::object::convert<typename type::tuple_type<A12>::type>(v.template get<12>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[13].clmdep_msgpack::object::convert<typename type::tuple_type<A13>::type>(v.template get<13>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[14].clmdep_msgpack::object::convert<typename type::tuple_type<A14>::type>(v.template get<14>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[15].clmdep_msgpack::object::convert<typename type::tuple_type<A15>::type>(v.template get<15>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[16].clmdep_msgpack::object::convert<typename type::tuple_type<A16>::type>(v.template get<16>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[17].clmdep_msgpack::object::convert<typename type::tuple_type<A17>::type>(v.template get<17>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[18].clmdep_msgpack::object::convert<typename type::tuple_type<A18>::type>(v.template get<18>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[19].clmdep_msgpack::object::convert<typename type::tuple_type<A19>::type>(v.template get<19>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[20].clmdep_msgpack::object::convert<typename type::tuple_type<A20>::type>(v.template get<20>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[21].clmdep_msgpack::object::convert<typename type::tuple_type<A21>::type>(v.template get<21>()); + return o; + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct convert<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 23) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[1].clmdep_msgpack::object::convert<typename type::tuple_type<A1>::type>(v.template get<1>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[2].clmdep_msgpack::object::convert<typename type::tuple_type<A2>::type>(v.template get<2>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[3].clmdep_msgpack::object::convert<typename type::tuple_type<A3>::type>(v.template get<3>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[4].clmdep_msgpack::object::convert<typename type::tuple_type<A4>::type>(v.template get<4>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[5].clmdep_msgpack::object::convert<typename type::tuple_type<A5>::type>(v.template get<5>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[6].clmdep_msgpack::object::convert<typename type::tuple_type<A6>::type>(v.template get<6>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[7].clmdep_msgpack::object::convert<typename type::tuple_type<A7>::type>(v.template get<7>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[8].clmdep_msgpack::object::convert<typename type::tuple_type<A8>::type>(v.template get<8>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[9].clmdep_msgpack::object::convert<typename type::tuple_type<A9>::type>(v.template get<9>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[10].clmdep_msgpack::object::convert<typename type::tuple_type<A10>::type>(v.template get<10>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[11].clmdep_msgpack::object::convert<typename type::tuple_type<A11>::type>(v.template get<11>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[12].clmdep_msgpack::object::convert<typename type::tuple_type<A12>::type>(v.template get<12>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[13].clmdep_msgpack::object::convert<typename type::tuple_type<A13>::type>(v.template get<13>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[14].clmdep_msgpack::object::convert<typename type::tuple_type<A14>::type>(v.template get<14>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[15].clmdep_msgpack::object::convert<typename type::tuple_type<A15>::type>(v.template get<15>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[16].clmdep_msgpack::object::convert<typename type::tuple_type<A16>::type>(v.template get<16>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[17].clmdep_msgpack::object::convert<typename type::tuple_type<A17>::type>(v.template get<17>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[18].clmdep_msgpack::object::convert<typename type::tuple_type<A18>::type>(v.template get<18>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[19].clmdep_msgpack::object::convert<typename type::tuple_type<A19>::type>(v.template get<19>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[20].clmdep_msgpack::object::convert<typename type::tuple_type<A20>::type>(v.template get<20>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[21].clmdep_msgpack::object::convert<typename type::tuple_type<A21>::type>(v.template get<21>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[22].clmdep_msgpack::object::convert<typename type::tuple_type<A22>::type>(v.template get<22>()); + return o; + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct convert<type::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> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::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>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 24) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[1].clmdep_msgpack::object::convert<typename type::tuple_type<A1>::type>(v.template get<1>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[2].clmdep_msgpack::object::convert<typename type::tuple_type<A2>::type>(v.template get<2>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[3].clmdep_msgpack::object::convert<typename type::tuple_type<A3>::type>(v.template get<3>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[4].clmdep_msgpack::object::convert<typename type::tuple_type<A4>::type>(v.template get<4>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[5].clmdep_msgpack::object::convert<typename type::tuple_type<A5>::type>(v.template get<5>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[6].clmdep_msgpack::object::convert<typename type::tuple_type<A6>::type>(v.template get<6>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[7].clmdep_msgpack::object::convert<typename type::tuple_type<A7>::type>(v.template get<7>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[8].clmdep_msgpack::object::convert<typename type::tuple_type<A8>::type>(v.template get<8>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[9].clmdep_msgpack::object::convert<typename type::tuple_type<A9>::type>(v.template get<9>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[10].clmdep_msgpack::object::convert<typename type::tuple_type<A10>::type>(v.template get<10>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[11].clmdep_msgpack::object::convert<typename type::tuple_type<A11>::type>(v.template get<11>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[12].clmdep_msgpack::object::convert<typename type::tuple_type<A12>::type>(v.template get<12>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[13].clmdep_msgpack::object::convert<typename type::tuple_type<A13>::type>(v.template get<13>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[14].clmdep_msgpack::object::convert<typename type::tuple_type<A14>::type>(v.template get<14>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[15].clmdep_msgpack::object::convert<typename type::tuple_type<A15>::type>(v.template get<15>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[16].clmdep_msgpack::object::convert<typename type::tuple_type<A16>::type>(v.template get<16>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[17].clmdep_msgpack::object::convert<typename type::tuple_type<A17>::type>(v.template get<17>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[18].clmdep_msgpack::object::convert<typename type::tuple_type<A18>::type>(v.template get<18>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[19].clmdep_msgpack::object::convert<typename type::tuple_type<A19>::type>(v.template get<19>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[20].clmdep_msgpack::object::convert<typename type::tuple_type<A20>::type>(v.template get<20>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[21].clmdep_msgpack::object::convert<typename type::tuple_type<A21>::type>(v.template get<21>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[22].clmdep_msgpack::object::convert<typename type::tuple_type<A22>::type>(v.template get<22>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[23].clmdep_msgpack::object::convert<typename type::tuple_type<A23>::type>(v.template get<23>()); + return o; + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct convert<type::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> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::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>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 25) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[1].clmdep_msgpack::object::convert<typename type::tuple_type<A1>::type>(v.template get<1>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[2].clmdep_msgpack::object::convert<typename type::tuple_type<A2>::type>(v.template get<2>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[3].clmdep_msgpack::object::convert<typename type::tuple_type<A3>::type>(v.template get<3>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[4].clmdep_msgpack::object::convert<typename type::tuple_type<A4>::type>(v.template get<4>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[5].clmdep_msgpack::object::convert<typename type::tuple_type<A5>::type>(v.template get<5>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[6].clmdep_msgpack::object::convert<typename type::tuple_type<A6>::type>(v.template get<6>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[7].clmdep_msgpack::object::convert<typename type::tuple_type<A7>::type>(v.template get<7>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[8].clmdep_msgpack::object::convert<typename type::tuple_type<A8>::type>(v.template get<8>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[9].clmdep_msgpack::object::convert<typename type::tuple_type<A9>::type>(v.template get<9>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[10].clmdep_msgpack::object::convert<typename type::tuple_type<A10>::type>(v.template get<10>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[11].clmdep_msgpack::object::convert<typename type::tuple_type<A11>::type>(v.template get<11>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[12].clmdep_msgpack::object::convert<typename type::tuple_type<A12>::type>(v.template get<12>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[13].clmdep_msgpack::object::convert<typename type::tuple_type<A13>::type>(v.template get<13>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[14].clmdep_msgpack::object::convert<typename type::tuple_type<A14>::type>(v.template get<14>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[15].clmdep_msgpack::object::convert<typename type::tuple_type<A15>::type>(v.template get<15>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[16].clmdep_msgpack::object::convert<typename type::tuple_type<A16>::type>(v.template get<16>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[17].clmdep_msgpack::object::convert<typename type::tuple_type<A17>::type>(v.template get<17>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[18].clmdep_msgpack::object::convert<typename type::tuple_type<A18>::type>(v.template get<18>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[19].clmdep_msgpack::object::convert<typename type::tuple_type<A19>::type>(v.template get<19>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[20].clmdep_msgpack::object::convert<typename type::tuple_type<A20>::type>(v.template get<20>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[21].clmdep_msgpack::object::convert<typename type::tuple_type<A21>::type>(v.template get<21>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[22].clmdep_msgpack::object::convert<typename type::tuple_type<A22>::type>(v.template get<22>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[23].clmdep_msgpack::object::convert<typename type::tuple_type<A23>::type>(v.template get<23>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[24].clmdep_msgpack::object::convert<typename type::tuple_type<A24>::type>(v.template get<24>()); + return o; + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct convert<type::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> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::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>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 26) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[1].clmdep_msgpack::object::convert<typename type::tuple_type<A1>::type>(v.template get<1>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[2].clmdep_msgpack::object::convert<typename type::tuple_type<A2>::type>(v.template get<2>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[3].clmdep_msgpack::object::convert<typename type::tuple_type<A3>::type>(v.template get<3>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[4].clmdep_msgpack::object::convert<typename type::tuple_type<A4>::type>(v.template get<4>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[5].clmdep_msgpack::object::convert<typename type::tuple_type<A5>::type>(v.template get<5>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[6].clmdep_msgpack::object::convert<typename type::tuple_type<A6>::type>(v.template get<6>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[7].clmdep_msgpack::object::convert<typename type::tuple_type<A7>::type>(v.template get<7>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[8].clmdep_msgpack::object::convert<typename type::tuple_type<A8>::type>(v.template get<8>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[9].clmdep_msgpack::object::convert<typename type::tuple_type<A9>::type>(v.template get<9>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[10].clmdep_msgpack::object::convert<typename type::tuple_type<A10>::type>(v.template get<10>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[11].clmdep_msgpack::object::convert<typename type::tuple_type<A11>::type>(v.template get<11>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[12].clmdep_msgpack::object::convert<typename type::tuple_type<A12>::type>(v.template get<12>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[13].clmdep_msgpack::object::convert<typename type::tuple_type<A13>::type>(v.template get<13>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[14].clmdep_msgpack::object::convert<typename type::tuple_type<A14>::type>(v.template get<14>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[15].clmdep_msgpack::object::convert<typename type::tuple_type<A15>::type>(v.template get<15>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[16].clmdep_msgpack::object::convert<typename type::tuple_type<A16>::type>(v.template get<16>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[17].clmdep_msgpack::object::convert<typename type::tuple_type<A17>::type>(v.template get<17>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[18].clmdep_msgpack::object::convert<typename type::tuple_type<A18>::type>(v.template get<18>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[19].clmdep_msgpack::object::convert<typename type::tuple_type<A19>::type>(v.template get<19>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[20].clmdep_msgpack::object::convert<typename type::tuple_type<A20>::type>(v.template get<20>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[21].clmdep_msgpack::object::convert<typename type::tuple_type<A21>::type>(v.template get<21>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[22].clmdep_msgpack::object::convert<typename type::tuple_type<A22>::type>(v.template get<22>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[23].clmdep_msgpack::object::convert<typename type::tuple_type<A23>::type>(v.template get<23>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[24].clmdep_msgpack::object::convert<typename type::tuple_type<A24>::type>(v.template get<24>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[25].clmdep_msgpack::object::convert<typename type::tuple_type<A25>::type>(v.template get<25>()); + return o; + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct convert<type::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> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::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>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 27) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[1].clmdep_msgpack::object::convert<typename type::tuple_type<A1>::type>(v.template get<1>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[2].clmdep_msgpack::object::convert<typename type::tuple_type<A2>::type>(v.template get<2>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[3].clmdep_msgpack::object::convert<typename type::tuple_type<A3>::type>(v.template get<3>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[4].clmdep_msgpack::object::convert<typename type::tuple_type<A4>::type>(v.template get<4>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[5].clmdep_msgpack::object::convert<typename type::tuple_type<A5>::type>(v.template get<5>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[6].clmdep_msgpack::object::convert<typename type::tuple_type<A6>::type>(v.template get<6>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[7].clmdep_msgpack::object::convert<typename type::tuple_type<A7>::type>(v.template get<7>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[8].clmdep_msgpack::object::convert<typename type::tuple_type<A8>::type>(v.template get<8>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[9].clmdep_msgpack::object::convert<typename type::tuple_type<A9>::type>(v.template get<9>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[10].clmdep_msgpack::object::convert<typename type::tuple_type<A10>::type>(v.template get<10>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[11].clmdep_msgpack::object::convert<typename type::tuple_type<A11>::type>(v.template get<11>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[12].clmdep_msgpack::object::convert<typename type::tuple_type<A12>::type>(v.template get<12>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[13].clmdep_msgpack::object::convert<typename type::tuple_type<A13>::type>(v.template get<13>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[14].clmdep_msgpack::object::convert<typename type::tuple_type<A14>::type>(v.template get<14>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[15].clmdep_msgpack::object::convert<typename type::tuple_type<A15>::type>(v.template get<15>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[16].clmdep_msgpack::object::convert<typename type::tuple_type<A16>::type>(v.template get<16>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[17].clmdep_msgpack::object::convert<typename type::tuple_type<A17>::type>(v.template get<17>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[18].clmdep_msgpack::object::convert<typename type::tuple_type<A18>::type>(v.template get<18>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[19].clmdep_msgpack::object::convert<typename type::tuple_type<A19>::type>(v.template get<19>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[20].clmdep_msgpack::object::convert<typename type::tuple_type<A20>::type>(v.template get<20>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[21].clmdep_msgpack::object::convert<typename type::tuple_type<A21>::type>(v.template get<21>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[22].clmdep_msgpack::object::convert<typename type::tuple_type<A22>::type>(v.template get<22>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[23].clmdep_msgpack::object::convert<typename type::tuple_type<A23>::type>(v.template get<23>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[24].clmdep_msgpack::object::convert<typename type::tuple_type<A24>::type>(v.template get<24>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[25].clmdep_msgpack::object::convert<typename type::tuple_type<A25>::type>(v.template get<25>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[26].clmdep_msgpack::object::convert<typename type::tuple_type<A26>::type>(v.template get<26>()); + return o; + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct convert<type::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> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::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>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 28) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[1].clmdep_msgpack::object::convert<typename type::tuple_type<A1>::type>(v.template get<1>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[2].clmdep_msgpack::object::convert<typename type::tuple_type<A2>::type>(v.template get<2>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[3].clmdep_msgpack::object::convert<typename type::tuple_type<A3>::type>(v.template get<3>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[4].clmdep_msgpack::object::convert<typename type::tuple_type<A4>::type>(v.template get<4>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[5].clmdep_msgpack::object::convert<typename type::tuple_type<A5>::type>(v.template get<5>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[6].clmdep_msgpack::object::convert<typename type::tuple_type<A6>::type>(v.template get<6>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[7].clmdep_msgpack::object::convert<typename type::tuple_type<A7>::type>(v.template get<7>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[8].clmdep_msgpack::object::convert<typename type::tuple_type<A8>::type>(v.template get<8>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[9].clmdep_msgpack::object::convert<typename type::tuple_type<A9>::type>(v.template get<9>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[10].clmdep_msgpack::object::convert<typename type::tuple_type<A10>::type>(v.template get<10>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[11].clmdep_msgpack::object::convert<typename type::tuple_type<A11>::type>(v.template get<11>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[12].clmdep_msgpack::object::convert<typename type::tuple_type<A12>::type>(v.template get<12>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[13].clmdep_msgpack::object::convert<typename type::tuple_type<A13>::type>(v.template get<13>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[14].clmdep_msgpack::object::convert<typename type::tuple_type<A14>::type>(v.template get<14>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[15].clmdep_msgpack::object::convert<typename type::tuple_type<A15>::type>(v.template get<15>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[16].clmdep_msgpack::object::convert<typename type::tuple_type<A16>::type>(v.template get<16>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[17].clmdep_msgpack::object::convert<typename type::tuple_type<A17>::type>(v.template get<17>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[18].clmdep_msgpack::object::convert<typename type::tuple_type<A18>::type>(v.template get<18>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[19].clmdep_msgpack::object::convert<typename type::tuple_type<A19>::type>(v.template get<19>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[20].clmdep_msgpack::object::convert<typename type::tuple_type<A20>::type>(v.template get<20>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[21].clmdep_msgpack::object::convert<typename type::tuple_type<A21>::type>(v.template get<21>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[22].clmdep_msgpack::object::convert<typename type::tuple_type<A22>::type>(v.template get<22>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[23].clmdep_msgpack::object::convert<typename type::tuple_type<A23>::type>(v.template get<23>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[24].clmdep_msgpack::object::convert<typename type::tuple_type<A24>::type>(v.template get<24>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[25].clmdep_msgpack::object::convert<typename type::tuple_type<A25>::type>(v.template get<25>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[26].clmdep_msgpack::object::convert<typename type::tuple_type<A26>::type>(v.template get<26>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[27].clmdep_msgpack::object::convert<typename type::tuple_type<A27>::type>(v.template get<27>()); + return o; + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct convert<type::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> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::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>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 29) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[1].clmdep_msgpack::object::convert<typename type::tuple_type<A1>::type>(v.template get<1>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[2].clmdep_msgpack::object::convert<typename type::tuple_type<A2>::type>(v.template get<2>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[3].clmdep_msgpack::object::convert<typename type::tuple_type<A3>::type>(v.template get<3>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[4].clmdep_msgpack::object::convert<typename type::tuple_type<A4>::type>(v.template get<4>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[5].clmdep_msgpack::object::convert<typename type::tuple_type<A5>::type>(v.template get<5>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[6].clmdep_msgpack::object::convert<typename type::tuple_type<A6>::type>(v.template get<6>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[7].clmdep_msgpack::object::convert<typename type::tuple_type<A7>::type>(v.template get<7>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[8].clmdep_msgpack::object::convert<typename type::tuple_type<A8>::type>(v.template get<8>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[9].clmdep_msgpack::object::convert<typename type::tuple_type<A9>::type>(v.template get<9>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[10].clmdep_msgpack::object::convert<typename type::tuple_type<A10>::type>(v.template get<10>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[11].clmdep_msgpack::object::convert<typename type::tuple_type<A11>::type>(v.template get<11>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[12].clmdep_msgpack::object::convert<typename type::tuple_type<A12>::type>(v.template get<12>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[13].clmdep_msgpack::object::convert<typename type::tuple_type<A13>::type>(v.template get<13>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[14].clmdep_msgpack::object::convert<typename type::tuple_type<A14>::type>(v.template get<14>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[15].clmdep_msgpack::object::convert<typename type::tuple_type<A15>::type>(v.template get<15>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[16].clmdep_msgpack::object::convert<typename type::tuple_type<A16>::type>(v.template get<16>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[17].clmdep_msgpack::object::convert<typename type::tuple_type<A17>::type>(v.template get<17>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[18].clmdep_msgpack::object::convert<typename type::tuple_type<A18>::type>(v.template get<18>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[19].clmdep_msgpack::object::convert<typename type::tuple_type<A19>::type>(v.template get<19>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[20].clmdep_msgpack::object::convert<typename type::tuple_type<A20>::type>(v.template get<20>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[21].clmdep_msgpack::object::convert<typename type::tuple_type<A21>::type>(v.template get<21>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[22].clmdep_msgpack::object::convert<typename type::tuple_type<A22>::type>(v.template get<22>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[23].clmdep_msgpack::object::convert<typename type::tuple_type<A23>::type>(v.template get<23>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[24].clmdep_msgpack::object::convert<typename type::tuple_type<A24>::type>(v.template get<24>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[25].clmdep_msgpack::object::convert<typename type::tuple_type<A25>::type>(v.template get<25>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[26].clmdep_msgpack::object::convert<typename type::tuple_type<A26>::type>(v.template get<26>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[27].clmdep_msgpack::object::convert<typename type::tuple_type<A27>::type>(v.template get<27>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[28].clmdep_msgpack::object::convert<typename type::tuple_type<A28>::type>(v.template get<28>()); + return o; + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct convert<type::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> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::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>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 30) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[1].clmdep_msgpack::object::convert<typename type::tuple_type<A1>::type>(v.template get<1>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[2].clmdep_msgpack::object::convert<typename type::tuple_type<A2>::type>(v.template get<2>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[3].clmdep_msgpack::object::convert<typename type::tuple_type<A3>::type>(v.template get<3>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[4].clmdep_msgpack::object::convert<typename type::tuple_type<A4>::type>(v.template get<4>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[5].clmdep_msgpack::object::convert<typename type::tuple_type<A5>::type>(v.template get<5>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[6].clmdep_msgpack::object::convert<typename type::tuple_type<A6>::type>(v.template get<6>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[7].clmdep_msgpack::object::convert<typename type::tuple_type<A7>::type>(v.template get<7>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[8].clmdep_msgpack::object::convert<typename type::tuple_type<A8>::type>(v.template get<8>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[9].clmdep_msgpack::object::convert<typename type::tuple_type<A9>::type>(v.template get<9>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[10].clmdep_msgpack::object::convert<typename type::tuple_type<A10>::type>(v.template get<10>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[11].clmdep_msgpack::object::convert<typename type::tuple_type<A11>::type>(v.template get<11>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[12].clmdep_msgpack::object::convert<typename type::tuple_type<A12>::type>(v.template get<12>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[13].clmdep_msgpack::object::convert<typename type::tuple_type<A13>::type>(v.template get<13>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[14].clmdep_msgpack::object::convert<typename type::tuple_type<A14>::type>(v.template get<14>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[15].clmdep_msgpack::object::convert<typename type::tuple_type<A15>::type>(v.template get<15>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[16].clmdep_msgpack::object::convert<typename type::tuple_type<A16>::type>(v.template get<16>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[17].clmdep_msgpack::object::convert<typename type::tuple_type<A17>::type>(v.template get<17>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[18].clmdep_msgpack::object::convert<typename type::tuple_type<A18>::type>(v.template get<18>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[19].clmdep_msgpack::object::convert<typename type::tuple_type<A19>::type>(v.template get<19>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[20].clmdep_msgpack::object::convert<typename type::tuple_type<A20>::type>(v.template get<20>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[21].clmdep_msgpack::object::convert<typename type::tuple_type<A21>::type>(v.template get<21>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[22].clmdep_msgpack::object::convert<typename type::tuple_type<A22>::type>(v.template get<22>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[23].clmdep_msgpack::object::convert<typename type::tuple_type<A23>::type>(v.template get<23>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[24].clmdep_msgpack::object::convert<typename type::tuple_type<A24>::type>(v.template get<24>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[25].clmdep_msgpack::object::convert<typename type::tuple_type<A25>::type>(v.template get<25>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[26].clmdep_msgpack::object::convert<typename type::tuple_type<A26>::type>(v.template get<26>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[27].clmdep_msgpack::object::convert<typename type::tuple_type<A27>::type>(v.template get<27>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[28].clmdep_msgpack::object::convert<typename type::tuple_type<A28>::type>(v.template get<28>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[29].clmdep_msgpack::object::convert<typename type::tuple_type<A29>::type>(v.template get<29>()); + return o; + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct convert<type::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> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::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>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 31) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[1].clmdep_msgpack::object::convert<typename type::tuple_type<A1>::type>(v.template get<1>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[2].clmdep_msgpack::object::convert<typename type::tuple_type<A2>::type>(v.template get<2>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[3].clmdep_msgpack::object::convert<typename type::tuple_type<A3>::type>(v.template get<3>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[4].clmdep_msgpack::object::convert<typename type::tuple_type<A4>::type>(v.template get<4>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[5].clmdep_msgpack::object::convert<typename type::tuple_type<A5>::type>(v.template get<5>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[6].clmdep_msgpack::object::convert<typename type::tuple_type<A6>::type>(v.template get<6>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[7].clmdep_msgpack::object::convert<typename type::tuple_type<A7>::type>(v.template get<7>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[8].clmdep_msgpack::object::convert<typename type::tuple_type<A8>::type>(v.template get<8>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[9].clmdep_msgpack::object::convert<typename type::tuple_type<A9>::type>(v.template get<9>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[10].clmdep_msgpack::object::convert<typename type::tuple_type<A10>::type>(v.template get<10>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[11].clmdep_msgpack::object::convert<typename type::tuple_type<A11>::type>(v.template get<11>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[12].clmdep_msgpack::object::convert<typename type::tuple_type<A12>::type>(v.template get<12>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[13].clmdep_msgpack::object::convert<typename type::tuple_type<A13>::type>(v.template get<13>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[14].clmdep_msgpack::object::convert<typename type::tuple_type<A14>::type>(v.template get<14>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[15].clmdep_msgpack::object::convert<typename type::tuple_type<A15>::type>(v.template get<15>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[16].clmdep_msgpack::object::convert<typename type::tuple_type<A16>::type>(v.template get<16>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[17].clmdep_msgpack::object::convert<typename type::tuple_type<A17>::type>(v.template get<17>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[18].clmdep_msgpack::object::convert<typename type::tuple_type<A18>::type>(v.template get<18>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[19].clmdep_msgpack::object::convert<typename type::tuple_type<A19>::type>(v.template get<19>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[20].clmdep_msgpack::object::convert<typename type::tuple_type<A20>::type>(v.template get<20>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[21].clmdep_msgpack::object::convert<typename type::tuple_type<A21>::type>(v.template get<21>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[22].clmdep_msgpack::object::convert<typename type::tuple_type<A22>::type>(v.template get<22>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[23].clmdep_msgpack::object::convert<typename type::tuple_type<A23>::type>(v.template get<23>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[24].clmdep_msgpack::object::convert<typename type::tuple_type<A24>::type>(v.template get<24>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[25].clmdep_msgpack::object::convert<typename type::tuple_type<A25>::type>(v.template get<25>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[26].clmdep_msgpack::object::convert<typename type::tuple_type<A26>::type>(v.template get<26>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[27].clmdep_msgpack::object::convert<typename type::tuple_type<A27>::type>(v.template get<27>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[28].clmdep_msgpack::object::convert<typename type::tuple_type<A28>::type>(v.template get<28>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[29].clmdep_msgpack::object::convert<typename type::tuple_type<A29>::type>(v.template get<29>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[30].clmdep_msgpack::object::convert<typename type::tuple_type<A30>::type>(v.template get<30>()); + return o; + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct convert<type::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> > { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + type::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>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < 32) { throw clmdep_msgpack::type_error(); } + + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[0].clmdep_msgpack::object::convert<typename type::tuple_type<A0>::type>(v.template get<0>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[1].clmdep_msgpack::object::convert<typename type::tuple_type<A1>::type>(v.template get<1>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[2].clmdep_msgpack::object::convert<typename type::tuple_type<A2>::type>(v.template get<2>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[3].clmdep_msgpack::object::convert<typename type::tuple_type<A3>::type>(v.template get<3>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[4].clmdep_msgpack::object::convert<typename type::tuple_type<A4>::type>(v.template get<4>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[5].clmdep_msgpack::object::convert<typename type::tuple_type<A5>::type>(v.template get<5>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[6].clmdep_msgpack::object::convert<typename type::tuple_type<A6>::type>(v.template get<6>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[7].clmdep_msgpack::object::convert<typename type::tuple_type<A7>::type>(v.template get<7>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[8].clmdep_msgpack::object::convert<typename type::tuple_type<A8>::type>(v.template get<8>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[9].clmdep_msgpack::object::convert<typename type::tuple_type<A9>::type>(v.template get<9>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[10].clmdep_msgpack::object::convert<typename type::tuple_type<A10>::type>(v.template get<10>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[11].clmdep_msgpack::object::convert<typename type::tuple_type<A11>::type>(v.template get<11>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[12].clmdep_msgpack::object::convert<typename type::tuple_type<A12>::type>(v.template get<12>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[13].clmdep_msgpack::object::convert<typename type::tuple_type<A13>::type>(v.template get<13>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[14].clmdep_msgpack::object::convert<typename type::tuple_type<A14>::type>(v.template get<14>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[15].clmdep_msgpack::object::convert<typename type::tuple_type<A15>::type>(v.template get<15>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[16].clmdep_msgpack::object::convert<typename type::tuple_type<A16>::type>(v.template get<16>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[17].clmdep_msgpack::object::convert<typename type::tuple_type<A17>::type>(v.template get<17>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[18].clmdep_msgpack::object::convert<typename type::tuple_type<A18>::type>(v.template get<18>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[19].clmdep_msgpack::object::convert<typename type::tuple_type<A19>::type>(v.template get<19>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[20].clmdep_msgpack::object::convert<typename type::tuple_type<A20>::type>(v.template get<20>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[21].clmdep_msgpack::object::convert<typename type::tuple_type<A21>::type>(v.template get<21>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[22].clmdep_msgpack::object::convert<typename type::tuple_type<A22>::type>(v.template get<22>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[23].clmdep_msgpack::object::convert<typename type::tuple_type<A23>::type>(v.template get<23>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[24].clmdep_msgpack::object::convert<typename type::tuple_type<A24>::type>(v.template get<24>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[25].clmdep_msgpack::object::convert<typename type::tuple_type<A25>::type>(v.template get<25>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[26].clmdep_msgpack::object::convert<typename type::tuple_type<A26>::type>(v.template get<26>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[27].clmdep_msgpack::object::convert<typename type::tuple_type<A27>::type>(v.template get<27>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[28].clmdep_msgpack::object::convert<typename type::tuple_type<A28>::type>(v.template get<28>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[29].clmdep_msgpack::object::convert<typename type::tuple_type<A29>::type>(v.template get<29>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[30].clmdep_msgpack::object::convert<typename type::tuple_type<A30>::type>(v.template get<30>()); + // In order to avoid clang++'s invalid warning, clmdep_msgpack::object:: has been added. + o.via.array.ptr[31].clmdep_msgpack::object::convert<typename type::tuple_type<A31>::type>(v.template get<31>()); + return o; + } +}; + +/// @endcond + +template <> +struct pack<type::tuple<> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::tuple<>&) const { + o.pack_array(0); + return o; + } +}; + +/// @cond + +template <typename A0> +struct pack<type::tuple<A0> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::tuple<A0>& v) const { + o.pack_array(1); + + o.pack(v.template get<0>()); + return o; + } +}; + +template <typename A0, typename A1> +struct pack<type::tuple<A0, A1> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::tuple<A0, A1>& v) const { + o.pack_array(2); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + return o; + } +}; + +template <typename A0, typename A1, typename A2> +struct pack<type::tuple<A0, A1, A2> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::tuple<A0, A1, A2>& v) const { + 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 <typename A0, typename A1, typename A2, typename A3> +struct pack<type::tuple<A0, A1, A2, A3> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::tuple<A0, A1, A2, A3>& v) const { + 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 <typename A0, typename A1, typename A2, typename A3, typename A4> +struct pack<type::tuple<A0, A1, A2, A3, A4> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::tuple<A0, A1, A2, A3, A4>& v) const { + 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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5> +struct pack<type::tuple<A0, A1, A2, A3, A4, A5> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::tuple<A0, A1, A2, A3, A4, A5>& v) const { + 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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6> +struct pack<type::tuple<A0, A1, A2, A3, A4, A5, A6> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6>& v) const { + 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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> +struct pack<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7>& v) const { + 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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> +struct pack<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>& v) const { + 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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> +struct pack<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>& v) const { + 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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +struct pack<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>& v) const { + 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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +struct pack<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>& v) const { + 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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +struct pack<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>& v) const { + 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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct pack<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>& v) const { + 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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct pack<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>& v) const { + 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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct pack<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>& v) const { + 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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct pack<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>& v) const { + 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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct pack<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>& v) const { + 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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct pack<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>& v) const { + 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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct pack<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>& v) const { + 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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct pack<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& v) const { + 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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct pack<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& v) const { + 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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct pack<type::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 <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& v) const { + 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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct pack<type::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 <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::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>& v) const { + 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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct pack<type::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 <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::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>& v) const { + 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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct pack<type::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 <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::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>& v) const { + 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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct pack<type::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 <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::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>& v) const { + 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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct pack<type::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 <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::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>& v) const { + 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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct pack<type::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 <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::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>& v) const { + 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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct pack<type::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 <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::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>& v) const { + 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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct pack<type::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 <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::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>& v) const { + 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 <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct pack<type::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> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const type::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>& v) const { + 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; + } +}; + +/// @endcond + +template <> +struct object_with_zone<type::tuple<> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::tuple<>&) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } +}; + +/// @cond + +template <typename A0> +struct object_with_zone<type::tuple<A0> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::tuple<A0>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*1)); + o.via.array.size = 1; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + } +}; + +template <typename A0, typename A1> +struct object_with_zone<type::tuple<A0, A1> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::tuple<A0, A1>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*2)); + o.via.array.size = 2; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = clmdep_msgpack::object(v.template get<1>(), o.zone); + } +}; + +template <typename A0, typename A1, typename A2> +struct object_with_zone<type::tuple<A0, A1, A2> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::tuple<A0, A1, A2>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*3)); + o.via.array.size = 3; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = clmdep_msgpack::object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = clmdep_msgpack::object(v.template get<2>(), o.zone); + } +}; + +template <typename A0, typename A1, typename A2, typename A3> +struct object_with_zone<type::tuple<A0, A1, A2, A3> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::tuple<A0, A1, A2, A3>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*4)); + o.via.array.size = 4; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = clmdep_msgpack::object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = clmdep_msgpack::object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = clmdep_msgpack::object(v.template get<3>(), o.zone); + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4> +struct object_with_zone<type::tuple<A0, A1, A2, A3, A4> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::tuple<A0, A1, A2, A3, A4>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*5)); + o.via.array.size = 5; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = clmdep_msgpack::object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = clmdep_msgpack::object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = clmdep_msgpack::object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = clmdep_msgpack::object(v.template get<4>(), o.zone); + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5> +struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::tuple<A0, A1, A2, A3, A4, A5>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*6)); + o.via.array.size = 6; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = clmdep_msgpack::object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = clmdep_msgpack::object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = clmdep_msgpack::object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = clmdep_msgpack::object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = clmdep_msgpack::object(v.template get<5>(), o.zone); + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6> +struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*7)); + o.via.array.size = 7; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = clmdep_msgpack::object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = clmdep_msgpack::object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = clmdep_msgpack::object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = clmdep_msgpack::object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = clmdep_msgpack::object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = clmdep_msgpack::object(v.template get<6>(), o.zone); + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> +struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*8)); + o.via.array.size = 8; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = clmdep_msgpack::object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = clmdep_msgpack::object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = clmdep_msgpack::object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = clmdep_msgpack::object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = clmdep_msgpack::object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = clmdep_msgpack::object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = clmdep_msgpack::object(v.template get<7>(), o.zone); + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> +struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*9)); + o.via.array.size = 9; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = clmdep_msgpack::object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = clmdep_msgpack::object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = clmdep_msgpack::object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = clmdep_msgpack::object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = clmdep_msgpack::object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = clmdep_msgpack::object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = clmdep_msgpack::object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = clmdep_msgpack::object(v.template get<8>(), o.zone); + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> +struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*10)); + o.via.array.size = 10; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = clmdep_msgpack::object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = clmdep_msgpack::object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = clmdep_msgpack::object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = clmdep_msgpack::object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = clmdep_msgpack::object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = clmdep_msgpack::object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = clmdep_msgpack::object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = clmdep_msgpack::object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = clmdep_msgpack::object(v.template get<9>(), o.zone); + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> +struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*11)); + o.via.array.size = 11; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = clmdep_msgpack::object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = clmdep_msgpack::object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = clmdep_msgpack::object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = clmdep_msgpack::object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = clmdep_msgpack::object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = clmdep_msgpack::object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = clmdep_msgpack::object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = clmdep_msgpack::object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = clmdep_msgpack::object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = clmdep_msgpack::object(v.template get<10>(), o.zone); + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> +struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*12)); + o.via.array.size = 12; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = clmdep_msgpack::object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = clmdep_msgpack::object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = clmdep_msgpack::object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = clmdep_msgpack::object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = clmdep_msgpack::object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = clmdep_msgpack::object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = clmdep_msgpack::object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = clmdep_msgpack::object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = clmdep_msgpack::object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = clmdep_msgpack::object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = clmdep_msgpack::object(v.template get<11>(), o.zone); + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> +struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*13)); + o.via.array.size = 13; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = clmdep_msgpack::object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = clmdep_msgpack::object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = clmdep_msgpack::object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = clmdep_msgpack::object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = clmdep_msgpack::object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = clmdep_msgpack::object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = clmdep_msgpack::object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = clmdep_msgpack::object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = clmdep_msgpack::object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = clmdep_msgpack::object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = clmdep_msgpack::object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = clmdep_msgpack::object(v.template get<12>(), o.zone); + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> +struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*14)); + o.via.array.size = 14; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = clmdep_msgpack::object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = clmdep_msgpack::object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = clmdep_msgpack::object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = clmdep_msgpack::object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = clmdep_msgpack::object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = clmdep_msgpack::object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = clmdep_msgpack::object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = clmdep_msgpack::object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = clmdep_msgpack::object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = clmdep_msgpack::object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = clmdep_msgpack::object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = clmdep_msgpack::object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = clmdep_msgpack::object(v.template get<13>(), o.zone); + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> +struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*15)); + o.via.array.size = 15; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = clmdep_msgpack::object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = clmdep_msgpack::object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = clmdep_msgpack::object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = clmdep_msgpack::object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = clmdep_msgpack::object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = clmdep_msgpack::object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = clmdep_msgpack::object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = clmdep_msgpack::object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = clmdep_msgpack::object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = clmdep_msgpack::object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = clmdep_msgpack::object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = clmdep_msgpack::object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = clmdep_msgpack::object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = clmdep_msgpack::object(v.template get<14>(), o.zone); + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> +struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*16)); + o.via.array.size = 16; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = clmdep_msgpack::object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = clmdep_msgpack::object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = clmdep_msgpack::object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = clmdep_msgpack::object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = clmdep_msgpack::object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = clmdep_msgpack::object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = clmdep_msgpack::object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = clmdep_msgpack::object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = clmdep_msgpack::object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = clmdep_msgpack::object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = clmdep_msgpack::object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = clmdep_msgpack::object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = clmdep_msgpack::object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = clmdep_msgpack::object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = clmdep_msgpack::object(v.template get<15>(), o.zone); + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> +struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*17)); + o.via.array.size = 17; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = clmdep_msgpack::object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = clmdep_msgpack::object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = clmdep_msgpack::object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = clmdep_msgpack::object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = clmdep_msgpack::object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = clmdep_msgpack::object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = clmdep_msgpack::object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = clmdep_msgpack::object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = clmdep_msgpack::object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = clmdep_msgpack::object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = clmdep_msgpack::object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = clmdep_msgpack::object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = clmdep_msgpack::object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = clmdep_msgpack::object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = clmdep_msgpack::object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = clmdep_msgpack::object(v.template get<16>(), o.zone); + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> +struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*18)); + o.via.array.size = 18; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = clmdep_msgpack::object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = clmdep_msgpack::object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = clmdep_msgpack::object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = clmdep_msgpack::object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = clmdep_msgpack::object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = clmdep_msgpack::object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = clmdep_msgpack::object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = clmdep_msgpack::object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = clmdep_msgpack::object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = clmdep_msgpack::object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = clmdep_msgpack::object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = clmdep_msgpack::object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = clmdep_msgpack::object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = clmdep_msgpack::object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = clmdep_msgpack::object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = clmdep_msgpack::object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = clmdep_msgpack::object(v.template get<17>(), o.zone); + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> +struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*19)); + o.via.array.size = 19; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = clmdep_msgpack::object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = clmdep_msgpack::object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = clmdep_msgpack::object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = clmdep_msgpack::object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = clmdep_msgpack::object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = clmdep_msgpack::object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = clmdep_msgpack::object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = clmdep_msgpack::object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = clmdep_msgpack::object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = clmdep_msgpack::object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = clmdep_msgpack::object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = clmdep_msgpack::object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = clmdep_msgpack::object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = clmdep_msgpack::object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = clmdep_msgpack::object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = clmdep_msgpack::object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = clmdep_msgpack::object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = clmdep_msgpack::object(v.template get<18>(), o.zone); + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> +struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*20)); + o.via.array.size = 20; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = clmdep_msgpack::object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = clmdep_msgpack::object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = clmdep_msgpack::object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = clmdep_msgpack::object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = clmdep_msgpack::object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = clmdep_msgpack::object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = clmdep_msgpack::object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = clmdep_msgpack::object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = clmdep_msgpack::object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = clmdep_msgpack::object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = clmdep_msgpack::object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = clmdep_msgpack::object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = clmdep_msgpack::object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = clmdep_msgpack::object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = clmdep_msgpack::object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = clmdep_msgpack::object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = clmdep_msgpack::object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = clmdep_msgpack::object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = clmdep_msgpack::object(v.template get<19>(), o.zone); + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> +struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*21)); + o.via.array.size = 21; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = clmdep_msgpack::object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = clmdep_msgpack::object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = clmdep_msgpack::object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = clmdep_msgpack::object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = clmdep_msgpack::object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = clmdep_msgpack::object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = clmdep_msgpack::object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = clmdep_msgpack::object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = clmdep_msgpack::object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = clmdep_msgpack::object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = clmdep_msgpack::object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = clmdep_msgpack::object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = clmdep_msgpack::object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = clmdep_msgpack::object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = clmdep_msgpack::object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = clmdep_msgpack::object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = clmdep_msgpack::object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = clmdep_msgpack::object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = clmdep_msgpack::object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = clmdep_msgpack::object(v.template get<20>(), o.zone); + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> +struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*22)); + o.via.array.size = 22; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = clmdep_msgpack::object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = clmdep_msgpack::object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = clmdep_msgpack::object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = clmdep_msgpack::object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = clmdep_msgpack::object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = clmdep_msgpack::object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = clmdep_msgpack::object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = clmdep_msgpack::object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = clmdep_msgpack::object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = clmdep_msgpack::object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = clmdep_msgpack::object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = clmdep_msgpack::object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = clmdep_msgpack::object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = clmdep_msgpack::object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = clmdep_msgpack::object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = clmdep_msgpack::object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = clmdep_msgpack::object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = clmdep_msgpack::object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = clmdep_msgpack::object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = clmdep_msgpack::object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = clmdep_msgpack::object(v.template get<21>(), o.zone); + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> +struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*23)); + o.via.array.size = 23; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = clmdep_msgpack::object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = clmdep_msgpack::object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = clmdep_msgpack::object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = clmdep_msgpack::object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = clmdep_msgpack::object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = clmdep_msgpack::object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = clmdep_msgpack::object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = clmdep_msgpack::object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = clmdep_msgpack::object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = clmdep_msgpack::object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = clmdep_msgpack::object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = clmdep_msgpack::object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = clmdep_msgpack::object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = clmdep_msgpack::object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = clmdep_msgpack::object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = clmdep_msgpack::object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = clmdep_msgpack::object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = clmdep_msgpack::object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = clmdep_msgpack::object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = clmdep_msgpack::object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = clmdep_msgpack::object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = clmdep_msgpack::object(v.template get<22>(), o.zone); + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> +struct object_with_zone<type::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> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::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>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*24)); + o.via.array.size = 24; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = clmdep_msgpack::object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = clmdep_msgpack::object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = clmdep_msgpack::object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = clmdep_msgpack::object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = clmdep_msgpack::object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = clmdep_msgpack::object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = clmdep_msgpack::object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = clmdep_msgpack::object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = clmdep_msgpack::object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = clmdep_msgpack::object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = clmdep_msgpack::object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = clmdep_msgpack::object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = clmdep_msgpack::object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = clmdep_msgpack::object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = clmdep_msgpack::object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = clmdep_msgpack::object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = clmdep_msgpack::object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = clmdep_msgpack::object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = clmdep_msgpack::object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = clmdep_msgpack::object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = clmdep_msgpack::object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = clmdep_msgpack::object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = clmdep_msgpack::object(v.template get<23>(), o.zone); + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> +struct object_with_zone<type::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> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::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>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*25)); + o.via.array.size = 25; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = clmdep_msgpack::object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = clmdep_msgpack::object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = clmdep_msgpack::object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = clmdep_msgpack::object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = clmdep_msgpack::object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = clmdep_msgpack::object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = clmdep_msgpack::object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = clmdep_msgpack::object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = clmdep_msgpack::object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = clmdep_msgpack::object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = clmdep_msgpack::object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = clmdep_msgpack::object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = clmdep_msgpack::object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = clmdep_msgpack::object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = clmdep_msgpack::object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = clmdep_msgpack::object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = clmdep_msgpack::object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = clmdep_msgpack::object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = clmdep_msgpack::object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = clmdep_msgpack::object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = clmdep_msgpack::object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = clmdep_msgpack::object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = clmdep_msgpack::object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = clmdep_msgpack::object(v.template get<24>(), o.zone); + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> +struct object_with_zone<type::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> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::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>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*26)); + o.via.array.size = 26; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = clmdep_msgpack::object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = clmdep_msgpack::object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = clmdep_msgpack::object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = clmdep_msgpack::object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = clmdep_msgpack::object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = clmdep_msgpack::object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = clmdep_msgpack::object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = clmdep_msgpack::object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = clmdep_msgpack::object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = clmdep_msgpack::object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = clmdep_msgpack::object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = clmdep_msgpack::object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = clmdep_msgpack::object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = clmdep_msgpack::object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = clmdep_msgpack::object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = clmdep_msgpack::object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = clmdep_msgpack::object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = clmdep_msgpack::object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = clmdep_msgpack::object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = clmdep_msgpack::object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = clmdep_msgpack::object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = clmdep_msgpack::object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = clmdep_msgpack::object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = clmdep_msgpack::object(v.template get<24>(), o.zone); + o.via.array.ptr[25] = clmdep_msgpack::object(v.template get<25>(), o.zone); + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> +struct object_with_zone<type::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> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::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>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*27)); + o.via.array.size = 27; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = clmdep_msgpack::object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = clmdep_msgpack::object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = clmdep_msgpack::object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = clmdep_msgpack::object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = clmdep_msgpack::object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = clmdep_msgpack::object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = clmdep_msgpack::object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = clmdep_msgpack::object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = clmdep_msgpack::object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = clmdep_msgpack::object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = clmdep_msgpack::object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = clmdep_msgpack::object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = clmdep_msgpack::object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = clmdep_msgpack::object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = clmdep_msgpack::object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = clmdep_msgpack::object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = clmdep_msgpack::object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = clmdep_msgpack::object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = clmdep_msgpack::object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = clmdep_msgpack::object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = clmdep_msgpack::object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = clmdep_msgpack::object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = clmdep_msgpack::object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = clmdep_msgpack::object(v.template get<24>(), o.zone); + o.via.array.ptr[25] = clmdep_msgpack::object(v.template get<25>(), o.zone); + o.via.array.ptr[26] = clmdep_msgpack::object(v.template get<26>(), o.zone); + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> +struct object_with_zone<type::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> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::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>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*28)); + o.via.array.size = 28; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = clmdep_msgpack::object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = clmdep_msgpack::object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = clmdep_msgpack::object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = clmdep_msgpack::object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = clmdep_msgpack::object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = clmdep_msgpack::object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = clmdep_msgpack::object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = clmdep_msgpack::object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = clmdep_msgpack::object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = clmdep_msgpack::object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = clmdep_msgpack::object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = clmdep_msgpack::object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = clmdep_msgpack::object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = clmdep_msgpack::object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = clmdep_msgpack::object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = clmdep_msgpack::object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = clmdep_msgpack::object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = clmdep_msgpack::object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = clmdep_msgpack::object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = clmdep_msgpack::object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = clmdep_msgpack::object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = clmdep_msgpack::object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = clmdep_msgpack::object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = clmdep_msgpack::object(v.template get<24>(), o.zone); + o.via.array.ptr[25] = clmdep_msgpack::object(v.template get<25>(), o.zone); + o.via.array.ptr[26] = clmdep_msgpack::object(v.template get<26>(), o.zone); + o.via.array.ptr[27] = clmdep_msgpack::object(v.template get<27>(), o.zone); + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> +struct object_with_zone<type::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> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::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>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*29)); + o.via.array.size = 29; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = clmdep_msgpack::object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = clmdep_msgpack::object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = clmdep_msgpack::object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = clmdep_msgpack::object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = clmdep_msgpack::object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = clmdep_msgpack::object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = clmdep_msgpack::object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = clmdep_msgpack::object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = clmdep_msgpack::object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = clmdep_msgpack::object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = clmdep_msgpack::object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = clmdep_msgpack::object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = clmdep_msgpack::object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = clmdep_msgpack::object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = clmdep_msgpack::object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = clmdep_msgpack::object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = clmdep_msgpack::object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = clmdep_msgpack::object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = clmdep_msgpack::object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = clmdep_msgpack::object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = clmdep_msgpack::object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = clmdep_msgpack::object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = clmdep_msgpack::object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = clmdep_msgpack::object(v.template get<24>(), o.zone); + o.via.array.ptr[25] = clmdep_msgpack::object(v.template get<25>(), o.zone); + o.via.array.ptr[26] = clmdep_msgpack::object(v.template get<26>(), o.zone); + o.via.array.ptr[27] = clmdep_msgpack::object(v.template get<27>(), o.zone); + o.via.array.ptr[28] = clmdep_msgpack::object(v.template get<28>(), o.zone); + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> +struct object_with_zone<type::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> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::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>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*30)); + o.via.array.size = 30; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = clmdep_msgpack::object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = clmdep_msgpack::object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = clmdep_msgpack::object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = clmdep_msgpack::object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = clmdep_msgpack::object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = clmdep_msgpack::object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = clmdep_msgpack::object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = clmdep_msgpack::object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = clmdep_msgpack::object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = clmdep_msgpack::object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = clmdep_msgpack::object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = clmdep_msgpack::object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = clmdep_msgpack::object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = clmdep_msgpack::object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = clmdep_msgpack::object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = clmdep_msgpack::object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = clmdep_msgpack::object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = clmdep_msgpack::object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = clmdep_msgpack::object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = clmdep_msgpack::object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = clmdep_msgpack::object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = clmdep_msgpack::object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = clmdep_msgpack::object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = clmdep_msgpack::object(v.template get<24>(), o.zone); + o.via.array.ptr[25] = clmdep_msgpack::object(v.template get<25>(), o.zone); + o.via.array.ptr[26] = clmdep_msgpack::object(v.template get<26>(), o.zone); + o.via.array.ptr[27] = clmdep_msgpack::object(v.template get<27>(), o.zone); + o.via.array.ptr[28] = clmdep_msgpack::object(v.template get<28>(), o.zone); + o.via.array.ptr[29] = clmdep_msgpack::object(v.template get<29>(), o.zone); + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> +struct object_with_zone<type::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> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::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>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*31)); + o.via.array.size = 31; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = clmdep_msgpack::object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = clmdep_msgpack::object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = clmdep_msgpack::object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = clmdep_msgpack::object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = clmdep_msgpack::object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = clmdep_msgpack::object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = clmdep_msgpack::object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = clmdep_msgpack::object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = clmdep_msgpack::object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = clmdep_msgpack::object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = clmdep_msgpack::object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = clmdep_msgpack::object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = clmdep_msgpack::object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = clmdep_msgpack::object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = clmdep_msgpack::object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = clmdep_msgpack::object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = clmdep_msgpack::object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = clmdep_msgpack::object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = clmdep_msgpack::object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = clmdep_msgpack::object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = clmdep_msgpack::object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = clmdep_msgpack::object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = clmdep_msgpack::object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = clmdep_msgpack::object(v.template get<24>(), o.zone); + o.via.array.ptr[25] = clmdep_msgpack::object(v.template get<25>(), o.zone); + o.via.array.ptr[26] = clmdep_msgpack::object(v.template get<26>(), o.zone); + o.via.array.ptr[27] = clmdep_msgpack::object(v.template get<27>(), o.zone); + o.via.array.ptr[28] = clmdep_msgpack::object(v.template get<28>(), o.zone); + o.via.array.ptr[29] = clmdep_msgpack::object(v.template get<29>(), o.zone); + o.via.array.ptr[30] = clmdep_msgpack::object(v.template get<30>(), o.zone); + } +}; + +template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> +struct object_with_zone<type::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> > { + void operator()( + clmdep_msgpack::object::with_zone& o, + const type::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>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*32)); + o.via.array.size = 32; + + o.via.array.ptr[0] = clmdep_msgpack::object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = clmdep_msgpack::object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = clmdep_msgpack::object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = clmdep_msgpack::object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = clmdep_msgpack::object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = clmdep_msgpack::object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = clmdep_msgpack::object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = clmdep_msgpack::object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = clmdep_msgpack::object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = clmdep_msgpack::object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = clmdep_msgpack::object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = clmdep_msgpack::object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = clmdep_msgpack::object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = clmdep_msgpack::object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = clmdep_msgpack::object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = clmdep_msgpack::object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = clmdep_msgpack::object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = clmdep_msgpack::object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = clmdep_msgpack::object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = clmdep_msgpack::object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = clmdep_msgpack::object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = clmdep_msgpack::object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = clmdep_msgpack::object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = clmdep_msgpack::object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = clmdep_msgpack::object(v.template get<24>(), o.zone); + o.via.array.ptr[25] = clmdep_msgpack::object(v.template get<25>(), o.zone); + o.via.array.ptr[26] = clmdep_msgpack::object(v.template get<26>(), o.zone); + o.via.array.ptr[27] = clmdep_msgpack::object(v.template get<27>(), o.zone); + o.via.array.ptr[28] = clmdep_msgpack::object(v.template get<28>(), o.zone); + o.via.array.ptr[29] = clmdep_msgpack::object(v.template get<29>(), o.zone); + o.via.array.ptr[30] = clmdep_msgpack::object(v.template get<30>(), o.zone); + o.via.array.ptr[31] = clmdep_msgpack::object(v.template get<31>(), o.zone); + } +}; + +/// @endcond + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif // MSGPACK_CPP03_MSGPACK_TUPLE_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/detail/cpp11_define_array.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/detail/cpp11_define_array.hpp new file mode 100644 index 000000000..efd474678 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/detail/cpp11_define_array.hpp @@ -0,0 +1,201 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_CPP11_DEFINE_ARRAY_HPP +#define MSGPACK_CPP11_DEFINE_ARRAY_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" + +// for MSGPACK_ADD_ENUM +#include "rpc/msgpack/adaptor/int.hpp" + +#include <type_traits> +#include <tuple> + +#define MSGPACK_DEFINE_ARRAY(...) \ + template <typename Packer> \ + void msgpack_pack(Packer& pk) const \ + { \ + clmdep_msgpack::type::make_define_array(__VA_ARGS__).msgpack_pack(pk); \ + } \ + void msgpack_unpack(clmdep_msgpack::object const& o) \ + { \ + clmdep_msgpack::type::make_define_array(__VA_ARGS__).msgpack_unpack(o); \ + }\ + template <typename MSGPACK_OBJECT> \ + void msgpack_object(MSGPACK_OBJECT* o, clmdep_msgpack::zone& z) const \ + { \ + clmdep_msgpack::type::make_define_array(__VA_ARGS__).msgpack_object(o, z); \ + } + +#define MSGPACK_BASE_ARRAY(base) (*const_cast<base *>(static_cast<base const*>(this))) + +// MSGPACK_ADD_ENUM must be used in the global namespace. +#define MSGPACK_ADD_ENUM(enum_name) \ + namespace clmdep_msgpack { \ + /** @cond */ \ + MSGPACK_API_VERSION_NAMESPACE(v1) { \ + /** @endcond */ \ + namespace adaptor { \ + template<> \ + struct convert<enum_name> { \ + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, enum_name& v) const { \ + std::underlying_type<enum_name>::type tmp; \ + o >> tmp; \ + v = static_cast<enum_name>(tmp); \ + return o; \ + } \ + }; \ + template<> \ + struct object<enum_name> { \ + void operator()(clmdep_msgpack::object& o, const enum_name& v) const { \ + auto tmp = static_cast<std::underlying_type<enum_name>::type>(v); \ + o << tmp; \ + } \ + }; \ + template<> \ + struct object_with_zone<enum_name> { \ + void operator()(clmdep_msgpack::object::with_zone& o, const enum_name& v) const { \ + auto tmp = static_cast<std::underlying_type<enum_name>::type>(v); \ + o << tmp; \ + } \ + }; \ + template <> \ + struct pack<enum_name> { \ + template <typename Stream> \ + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const enum_name& v) const { \ + return o << static_cast<std::underlying_type<enum_name>::type>(v); \ + } \ + }; \ + } \ + /** @cond */ \ + } \ + /** @endcond */ \ + } + +namespace clmdep_msgpack { +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond +namespace type { + +template <typename Tuple, std::size_t N> +struct define_array_imp { + template <typename Packer> + static void pack(Packer& pk, Tuple const& t) { + define_array_imp<Tuple, N-1>::pack(pk, t); + pk.pack(std::get<N-1>(t)); + } + static void unpack(clmdep_msgpack::object const& o, Tuple& t) { + define_array_imp<Tuple, N-1>::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<N-1>(t)); + } + static void object(clmdep_msgpack::object* o, clmdep_msgpack::zone& z, Tuple const& t) { + define_array_imp<Tuple, N-1>::object(o, z, t); + o->via.array.ptr[N-1] = clmdep_msgpack::object(std::get<N-1>(t), z); + } +}; + +template <typename Tuple> +struct define_array_imp<Tuple, 1> { + template <typename Packer> + static void pack(Packer& pk, Tuple const& t) { + pk.pack(std::get<0>(t)); + } + static void unpack(clmdep_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(clmdep_msgpack::object* o, clmdep_msgpack::zone& z, Tuple const& t) { + o->via.array.ptr[0] = clmdep_msgpack::object(std::get<0>(t), z); + } +}; + +template <typename... Args> +struct define_array { + typedef define_array<Args...> value_type; + typedef std::tuple<Args...> tuple_type; + define_array(Args&... args) : + a(args...) {} + template <typename Packer> + void msgpack_pack(Packer& pk) const + { + pk.pack_array(sizeof...(Args)); + + define_array_imp<std::tuple<Args&...>, sizeof...(Args)>::pack(pk, a); + } + void msgpack_unpack(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + + define_array_imp<std::tuple<Args&...>, sizeof...(Args)>::unpack(o, a); + } + void msgpack_object(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = static_cast<clmdep_msgpack::object*>(z.allocate_align(sizeof(clmdep_msgpack::object)*sizeof...(Args))); + o->via.array.size = sizeof...(Args); + + define_array_imp<std::tuple<Args&...>, sizeof...(Args)>::object(o, z, a); + } + + std::tuple<Args&...> a; +}; + +template <> +struct define_array<> { + typedef define_array<> value_type; + typedef std::tuple<> tuple_type; + template <typename Packer> + void msgpack_pack(Packer& pk) const + { + pk.pack_array(0); + } + void msgpack_unpack(clmdep_msgpack::object const& o) + { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + } + void msgpack_object(clmdep_msgpack::object* o, clmdep_msgpack::zone&) const + { + o->type = clmdep_msgpack::type::ARRAY; + o->via.array.ptr = NULL; + o->via.array.size = 0; + } +}; + +inline define_array<> make_define_array() +{ + return define_array<>(); +} + +template <typename... Args> +inline define_array<Args...> make_define_array(Args&... args) +{ + return define_array<Args...>(args...); +} + +} // namespace type +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond +} // namespace clmdep_msgpack + +#endif // MSGPACK_CPP11_DEFINE_ARRAY_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/detail/cpp11_define_map.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/detail/cpp11_define_map.hpp new file mode 100644 index 000000000..1ccadda1b --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/detail/cpp11_define_map.hpp @@ -0,0 +1,171 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_CPP11_DEFINE_MAP_HPP +#define MSGPACK_CPP11_DEFINE_MAP_HPP + +// BOOST_PP_VARIADICS is defined in boost/preprocessor/config/config.hpp +// http://www.boost.org/libs/preprocessor/doc/ref/variadics.html +// However, supporting compiler detection is not complete. msgpack-c requires +// variadic macro arguments support. So BOOST_PP_VARIADICS is defined here explicitly. +#if !defined(MSGPACK_PP_VARIADICS) +#define MSGPACK_PP_VARIADICS +#endif + +#include <rpc/msgpack/preprocessor.hpp> + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" + +// for MSGPACK_ADD_ENUM +#include "rpc/msgpack/adaptor/int.hpp" + +#include <type_traits> +#include <tuple> + +#define MSGPACK_DEFINE_MAP_EACH_PROC(r, data, elem) \ + MSGPACK_PP_IF( \ + MSGPACK_PP_IS_BEGIN_PARENS(elem), \ + elem, \ + (MSGPACK_PP_STRINGIZE(elem))(elem) \ + ) + +#define MSGPACK_DEFINE_MAP_IMPL(...) \ + MSGPACK_PP_SEQ_TO_TUPLE( \ + MSGPACK_PP_SEQ_FOR_EACH( \ + MSGPACK_DEFINE_MAP_EACH_PROC, \ + 0, \ + MSGPACK_PP_VARIADIC_TO_SEQ(__VA_ARGS__) \ + ) \ + ) + +#define MSGPACK_DEFINE_MAP(...) \ + template <typename Packer> \ + void msgpack_pack(Packer& pk) const \ + { \ + clmdep_msgpack::type::make_define_map \ + MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \ + .msgpack_pack(pk); \ + } \ + void msgpack_unpack(clmdep_msgpack::object const& o) \ + { \ + clmdep_msgpack::type::make_define_map \ + MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \ + .msgpack_unpack(o); \ + }\ + template <typename MSGPACK_OBJECT> \ + void msgpack_object(MSGPACK_OBJECT* o, clmdep_msgpack::zone& z) const \ + { \ + clmdep_msgpack::type::make_define_map \ + MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \ + .msgpack_object(o, z); \ + } + +#define MSGPACK_BASE_MAP(base) \ + (MSGPACK_PP_STRINGIZE(base))(*const_cast<base *>(static_cast<base const*>(this))) + +namespace clmdep_msgpack { +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond +namespace type { + +template <typename Tuple, std::size_t N> +struct define_map_imp { + template <typename Packer> + static void pack(Packer& pk, Tuple const& t) { + define_map_imp<Tuple, N-1>::pack(pk, t); + pk.pack(std::get<N-1>(t)); + } + static void unpack( + clmdep_msgpack::object const& o, Tuple const& t, + std::map<std::string, clmdep_msgpack::object const*> const& kvmap) { + define_map_imp<Tuple, N-2>::unpack(o, t, kvmap); + auto it = kvmap.find(std::get<N-2>(t)); + if (it != kvmap.end()) { + it->second->convert(std::get<N-1>(t)); + } + } + static void object(clmdep_msgpack::object* o, clmdep_msgpack::zone& z, Tuple const& t) { + define_map_imp<Tuple, N-2>::object(o, z, t); + o->via.map.ptr[(N-1)/2].key = clmdep_msgpack::object(std::get<N-2>(t), z); + o->via.map.ptr[(N-1)/2].val = clmdep_msgpack::object(std::get<N-1>(t), z); + } +}; + +template <typename Tuple> +struct define_map_imp<Tuple, 0> { + template <typename Packer> + static void pack(Packer&, Tuple const&) {} + static void unpack( + clmdep_msgpack::object const&, Tuple const&, + std::map<std::string, clmdep_msgpack::object const*> const&) {} + static void object(clmdep_msgpack::object*, clmdep_msgpack::zone&, Tuple const&) {} +}; + +template <typename... Args> +struct define_map { + define_map(Args&... args) : + a(args...) {} + template <typename Packer> + void msgpack_pack(Packer& pk) const + { + static_assert(sizeof...(Args) % 2 == 0, ""); + pk.pack_map(sizeof...(Args) / 2); + + define_map_imp<std::tuple<Args&...>, sizeof...(Args)>::pack(pk, a); + } + void msgpack_unpack(clmdep_msgpack::object const& o) const + { + if(o.type != clmdep_msgpack::type::MAP) { throw clmdep_msgpack::type_error(); } + std::map<std::string, clmdep_msgpack::object const*> kvmap; + for (uint32_t i = 0; i < o.via.map.size; ++i) { + kvmap.emplace( + std::string( + o.via.map.ptr[i].key.via.str.ptr, + o.via.map.ptr[i].key.via.str.size), + &o.via.map.ptr[i].val); + } + define_map_imp<std::tuple<Args&...>, sizeof...(Args)>::unpack(o, a, kvmap); + } + void msgpack_object(clmdep_msgpack::object* o, clmdep_msgpack::zone& z) const + { + static_assert(sizeof...(Args) % 2 == 0, ""); + o->type = clmdep_msgpack::type::MAP; + o->via.map.ptr = static_cast<clmdep_msgpack::object_kv*>(z.allocate_align(sizeof(clmdep_msgpack::object_kv)*sizeof...(Args)/2)); + o->via.map.size = sizeof...(Args) / 2; + + define_map_imp<std::tuple<Args&...>, sizeof...(Args)>::object(o, z, a); + } + + std::tuple<Args&...> a; +}; + + +template <typename... Args> +define_map<Args...> make_define_map(Args&... args) +{ + return define_map<Args...>(args...); +} + +} // namespace type +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond +} // namespace clmdep_msgpack + +#endif // MSGPACK_CPP11_DEFINE_MAP_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp new file mode 100644 index 000000000..b98ac66d6 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp @@ -0,0 +1,283 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_CPP11_MSGPACK_TUPLE_HPP +#define MSGPACK_CPP11_MSGPACK_TUPLE_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/object_fwd.hpp" +#include "rpc/msgpack/meta.hpp" + +#include <tuple> + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace type { + // tuple + using std::get; + using std::tuple_size; + using std::tuple_element; + using std::uses_allocator; + using std::ignore; + using std::swap; + + template< class... Types > + class tuple : public std::tuple<Types...> { + public: + using base = std::tuple<Types...>; + + using base::base; + + tuple() = default; + tuple(tuple const&) = default; + tuple(tuple&&) = default; + + template<typename... OtherTypes> + tuple(tuple<OtherTypes...> const& other):base(static_cast<std::tuple<OtherTypes...> const&>(other)) {} + template<typename... OtherTypes> + tuple(tuple<OtherTypes...> && other):base(static_cast<std::tuple<OtherTypes...> &&>(other)) {} + + tuple& operator=(tuple const&) = default; + tuple& operator=(tuple&&) = default; + + template<typename... OtherTypes> + tuple& operator=(tuple<OtherTypes...> const& other) { + *static_cast<base*>(this) = static_cast<std::tuple<OtherTypes...> const&>(other); + return *this; + } + template<typename... OtherTypes> + tuple& operator=(tuple<OtherTypes...> && other) { + *static_cast<base*>(this) = static_cast<std::tuple<OtherTypes...> &&>(other); + return *this; + } + + template< std::size_t I> + typename tuple_element<I, base >::type& + get() & { return std::get<I>(*this); } + + template< std::size_t I> + typename tuple_element<I, base >::type const& + get() const& { return std::get<I>(*this); } + + template< std::size_t I> + typename tuple_element<I, base >::type&& + get() && { return std::get<I>(*this); } + }; + + template <class... Args> + inline tuple<Args...> make_tuple(Args&&... args) { + return tuple<Args...>(args...); + } + + template<class... Args> + inline tuple<Args&&...> forward_as_tuple (Args&&... args) noexcept { + return tuple<Args&&...>(std::forward<Args>(args)...); + } + + template <class... Tuples> + inline auto tuple_cat(Tuples&&... args) -> + decltype( + std::tuple_cat(std::forward<typename std::remove_reference<Tuples>::type::base>(args)...) + ) { + return std::tuple_cat(std::forward<typename std::remove_reference<Tuples>::type::base>(args)...); + } + template <class... Args> + inline tuple<Args&...> tie(Args&... args) { + return tuple<Args&...>(args...); + } +} // namespace type + +// --- Pack from tuple to packer stream --- +template <typename Stream, typename Tuple, std::size_t N> +struct MsgpackTuplePacker { + static void pack( + clmdep_msgpack::packer<Stream>& o, + const Tuple& v) { + MsgpackTuplePacker<Stream, Tuple, N-1>::pack(o, v); + o.pack(type::get<N-1>(v)); + } +}; + +template <typename Stream, typename Tuple> +struct MsgpackTuplePacker<Stream, Tuple, 1> { + static void pack ( + clmdep_msgpack::packer<Stream>& o, + const Tuple& v) { + o.pack(type::get<0>(v)); + } +}; + +template <typename Stream, typename Tuple> +struct MsgpackTuplePacker<Stream, Tuple, 0> { + static void pack ( + clmdep_msgpack::packer<Stream>&, + const Tuple&) { + } +}; + +namespace adaptor { + +template <typename... Args> +struct pack<clmdep_msgpack::type::tuple<Args...>> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()( + clmdep_msgpack::packer<Stream>& o, + const clmdep_msgpack::type::tuple<Args...>& v) const { + o.pack_array(sizeof...(Args)); + MsgpackTuplePacker<Stream, decltype(v), sizeof...(Args)>::pack(o, v); + return o; + } +}; + +} // namespace adaptor + +// --- Convert from tuple to object --- + +template <typename... Args> +struct MsgpackTupleAs; + +template <typename T, typename... Args> +struct MsgpackTupleAsImpl { + static clmdep_msgpack::type::tuple<T, Args...> as(clmdep_msgpack::object const& o) { + return clmdep_msgpack::type::tuple_cat( + clmdep_msgpack::type::make_tuple(o.via.array.ptr[o.via.array.size - sizeof...(Args) - 1].as<T>()), + MsgpackTupleAs<Args...>::as(o)); + } +}; + +template <typename... Args> +struct MsgpackTupleAs { + static clmdep_msgpack::type::tuple<Args...> as(clmdep_msgpack::object const& o) { + return MsgpackTupleAsImpl<Args...>::as(o); + } +}; + +template <> +struct MsgpackTupleAs<> { + static clmdep_msgpack::type::tuple<> as (clmdep_msgpack::object const&) { + return clmdep_msgpack::type::tuple<>(); + } +}; + +template <typename Tuple, std::size_t N> +struct MsgpackTupleConverter { + static void convert( + clmdep_msgpack::object const& o, + Tuple& v) { + MsgpackTupleConverter<Tuple, N-1>::convert(o, v); + o.via.array.ptr[N-1].convert<typename std::remove_reference<decltype(type::get<N-1>(v))>::type>(type::get<N-1>(v)); + } +}; + +template <typename Tuple> +struct MsgpackTupleConverter<Tuple, 1> { + static void convert ( + clmdep_msgpack::object const& o, + Tuple& v) { + o.via.array.ptr[0].convert<typename std::remove_reference<decltype(type::get<0>(v))>::type>(type::get<0>(v)); + } +}; + +template <typename Tuple> +struct MsgpackTupleConverter<Tuple, 0> { + static void convert ( + clmdep_msgpack::object const&, + Tuple&) { + } +}; + +namespace adaptor { + +template <typename... Args> +struct as<clmdep_msgpack::type::tuple<Args...>, typename std::enable_if<clmdep_msgpack::all_of<clmdep_msgpack::has_as, Args...>::value>::type> { + clmdep_msgpack::type::tuple<Args...> operator()( + clmdep_msgpack::object const& o) const { + if (o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if (o.via.array.size < sizeof...(Args)) { throw clmdep_msgpack::type_error(); } + return MsgpackTupleAs<Args...>::as(o); + } +}; + +template <typename... Args> +struct convert<clmdep_msgpack::type::tuple<Args...>> { + clmdep_msgpack::object const& operator()( + clmdep_msgpack::object const& o, + clmdep_msgpack::type::tuple<Args...>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size < sizeof...(Args)) { throw clmdep_msgpack::type_error(); } + MsgpackTupleConverter<decltype(v), sizeof...(Args)>::convert(o, v); + return o; + } +}; + +} // namespace adaptor + +// --- Convert from tuple to object with zone --- +template <typename Tuple, std::size_t N> +struct MsgpackTupleToObjectWithZone { + static void convert( + clmdep_msgpack::object::with_zone& o, + const Tuple& v) { + MsgpackTupleToObjectWithZone<Tuple, N-1>::convert(o, v); + o.via.array.ptr[N-1] = clmdep_msgpack::object(type::get<N-1>(v), o.zone); + } +}; + +template <typename Tuple> +struct MsgpackTupleToObjectWithZone<Tuple, 1> { + static void convert ( + clmdep_msgpack::object::with_zone& o, + const Tuple& v) { + o.via.array.ptr[0] = clmdep_msgpack::object(type::get<0>(v), o.zone); + } +}; + +template <typename Tuple> +struct MsgpackTupleToObjectWithZone<Tuple, 0> { + static void convert ( + clmdep_msgpack::object::with_zone&, + const Tuple&) { + } +}; + +namespace adaptor { + +template <typename... Args> + struct object_with_zone<clmdep_msgpack::type::tuple<Args...>> { + void operator()( + clmdep_msgpack::object::with_zone& o, + clmdep_msgpack::type::tuple<Args...> const& v) const { + o.type = clmdep_msgpack::type::ARRAY; + o.via.array.ptr = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*sizeof...(Args))); + o.via.array.size = sizeof...(Args); + MsgpackTupleToObjectWithZone<decltype(v), sizeof...(Args)>::convert(o, v); + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +///@endcond + +} // namespace clmdep_msgpack + +#endif // MSGPACK_CPP11_MSGPACK_TUPLE_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/ext.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/ext.hpp new file mode 100644 index 000000000..1f1a60408 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/ext.hpp @@ -0,0 +1,245 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2015 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_EXT_HPP +#define MSGPACK_TYPE_EXT_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" +#include <cstring> +#include <string> +#include <cassert> + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace type { +class ext_ref; + +class ext { +public: + ext() : m_data(1, 0) {} + ext(int8_t t, const char* p, uint32_t s) { + detail::check_container_size_for_ext<sizeof(std::size_t)>(s); + m_data.reserve(static_cast<std::size_t>(s) + 1); + m_data.push_back(static_cast<char>(t)); + m_data.insert(m_data.end(), p, p + s); + } + ext(int8_t t, uint32_t s) { + detail::check_container_size_for_ext<sizeof(std::size_t)>(s); + m_data.resize(static_cast<std::size_t>(s) + 1); + m_data[0] = static_cast<char>(t); + } + ext(ext_ref const&); + int8_t type() const { + return static_cast<int8_t>(m_data[0]); + } + const char* data() const { + return &m_data[1]; + } + char* data() { + return &m_data[1]; + } + uint32_t size() const { + return static_cast<uint32_t>(m_data.size()) - 1; + } + bool operator== (const ext& x) const { + return m_data == x.m_data; + } + + bool operator!= (const ext& x) const { + return !(*this == x); + } + + bool operator< (const ext& x) const { + return m_data < x.m_data; + } + + bool operator> (const ext& x) const { + return m_data > x.m_data; + } +private: + std::vector<char> m_data; + friend class ext_ref; +}; + +} // namespace type + +namespace adaptor { + +template <> +struct convert<clmdep_msgpack::type::ext> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, clmdep_msgpack::type::ext& v) const { + if(o.type != clmdep_msgpack::type::EXT) { + throw clmdep_msgpack::type_error(); + } + v = clmdep_msgpack::type::ext(o.via.ext.type(), o.via.ext.data(), o.via.ext.size); + return o; + } +}; + +template <> +struct pack<clmdep_msgpack::type::ext> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const clmdep_msgpack::type::ext& v) const { + // size limit has aleady been checked at ext's constructor + uint32_t size = v.size(); + o.pack_ext(size, v.type()); + o.pack_ext_body(v.data(), size); + return o; + } +}; + +template <> +struct object_with_zone<clmdep_msgpack::type::ext> { + void operator()(clmdep_msgpack::object::with_zone& o, const clmdep_msgpack::type::ext& v) const { + // size limit has aleady been checked at ext's constructor + uint32_t size = v.size(); + o.type = clmdep_msgpack::type::EXT; + char* ptr = static_cast<char*>(o.zone.allocate_align(size + 1)); + o.via.ext.ptr = ptr; + o.via.ext.size = size; + ptr[0] = static_cast<char>(v.type()); + std::memcpy(ptr + 1, v.data(), size); + } +}; + +} // namespace adaptor + +namespace type { + +class ext_ref { +public: + // ext_ref should be default constructible to support 'convert'. + // A default constructed ext_ref object::m_ptr doesn't have the buffer to point to. + // In order to avoid nullptr checking branches, m_ptr points to m_size. + // So type() returns unspecified but valid value. It might be a zero because m_size + // is initialized as zero, but shoudn't assume that. + ext_ref() : m_ptr(static_cast<char*>(static_cast<void*>(&m_size))), m_size(0) {} + ext_ref(const char* p, uint32_t s) : + m_ptr(s == 0 ? static_cast<char*>(static_cast<void*>(&m_size)) : p), + m_size(s == 0 ? 0 : s - 1) { + detail::check_container_size_for_ext<sizeof(std::size_t)>(s); + } + + // size limit has aleady been checked at ext's constructor + ext_ref(ext const& x) : m_ptr(&x.m_data[0]), m_size(x.size()) {} + + const char* data() const { + return m_ptr + 1; + } + + uint32_t size() const { + return m_size; + } + + int8_t type() const { + return static_cast<int8_t>(m_ptr[0]); + } + + std::string str() const { + return std::string(m_ptr + 1, m_size); + } + + bool operator== (const ext_ref& x) const { + return m_size == x.m_size && std::memcmp(m_ptr, x.m_ptr, m_size) == 0; + } + + bool operator!= (const ext_ref& x) const { + return !(*this == x); + } + + bool operator< (const ext_ref& x) const { + if (m_size < x.m_size) return true; + if (m_size > x.m_size) return false; + return std::memcmp(m_ptr, x.m_ptr, m_size) < 0; + } + + bool operator> (const ext_ref& x) const { + if (m_size > x.m_size) return true; + if (m_size < x.m_size) return false; + return std::memcmp(m_ptr, x.m_ptr, m_size) > 0; + } +private: + const char* m_ptr; + uint32_t m_size; + friend struct clmdep_msgpack::adaptor::object<clmdep_msgpack::type::ext_ref>; +}; + +inline ext::ext(ext_ref const& x) { + // size limit has aleady been checked at ext_ref's constructor + m_data.reserve(x.size() + 1); + + m_data.push_back(x.type()); + m_data.insert(m_data.end(), x.data(), x.data() + x.size()); +} + +} // namespace type + +namespace adaptor { + +template <> +struct convert<clmdep_msgpack::type::ext_ref> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, clmdep_msgpack::type::ext_ref& v) const { + if(o.type != clmdep_msgpack::type::EXT) { throw clmdep_msgpack::type_error(); } + v = clmdep_msgpack::type::ext_ref(o.via.ext.ptr, o.via.ext.size + 1); + return o; + } +}; + +template <> +struct pack<clmdep_msgpack::type::ext_ref> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const clmdep_msgpack::type::ext_ref& v) const { + // size limit has aleady been checked at ext_ref's constructor + uint32_t size = v.size(); + o.pack_ext(size, v.type()); + o.pack_ext_body(v.data(), size); + return o; + } +}; + +template <> +struct object<clmdep_msgpack::type::ext_ref> { + void operator()(clmdep_msgpack::object& o, const clmdep_msgpack::type::ext_ref& v) const { + // size limit has aleady been checked at ext_ref's constructor + uint32_t size = v.size(); + o.type = clmdep_msgpack::type::EXT; + o.via.ext.ptr = v.m_ptr; + o.via.ext.size = size; + } +}; + +template <> +struct object_with_zone<clmdep_msgpack::type::ext_ref> { + void operator()(clmdep_msgpack::object::with_zone& o, const clmdep_msgpack::type::ext_ref& v) const { + static_cast<clmdep_msgpack::object&>(o) << v; + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif // MSGPACK_TYPE_EXT_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/fixint.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/fixint.hpp new file mode 100644 index 000000000..b5f5b0957 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/fixint.hpp @@ -0,0 +1,306 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2020 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_FIXINT_HPP +#define MSGPACK_TYPE_FIXINT_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" +#include "rpc/msgpack/adaptor/int.hpp" + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace type { + + +template <typename T> +struct fix_int { + fix_int() : value(0) { } + fix_int(T value) : value(value) { } + + operator T() const { return value; } + + T get() const { return value; } + +private: + T value; +}; + + +typedef fix_int<uint8_t> fix_uint8; +typedef fix_int<uint16_t> fix_uint16; +typedef fix_int<uint32_t> fix_uint32; +typedef fix_int<uint64_t> fix_uint64; + +typedef fix_int<int8_t> fix_int8; +typedef fix_int<int16_t> fix_int16; +typedef fix_int<int32_t> fix_int32; +typedef fix_int<int64_t> fix_int64; + + +} // namespace type + +namespace adaptor { + +template <> +struct convert<type::fix_int8> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, type::fix_int8& v) const + { v = type::detail::convert_integer<int8_t>(o); return o; } +}; + +template <> +struct convert<type::fix_int16> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, type::fix_int16& v) const + { v = type::detail::convert_integer<int16_t>(o); return o; } +}; + +template <> +struct convert<type::fix_int32> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, type::fix_int32& v) const + { v = type::detail::convert_integer<int32_t>(o); return o; } +}; + +template <> +struct convert<type::fix_int64> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, type::fix_int64& v) const + { v = type::detail::convert_integer<int64_t>(o); return o; } +}; + + +template <> +struct convert<type::fix_uint8> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, type::fix_uint8& v) const + { v = type::detail::convert_integer<uint8_t>(o); return o; } +}; + +template <> +struct convert<type::fix_uint16> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, type::fix_uint16& v) const + { v = type::detail::convert_integer<uint16_t>(o); return o; } +}; + +template <> +struct convert<type::fix_uint32> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, type::fix_uint32& v) const + { v = type::detail::convert_integer<uint32_t>(o); return o; } +}; + +template <> +struct convert<type::fix_uint64> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, type::fix_uint64& v) const + { v = type::detail::convert_integer<uint64_t>(o); return o; } +}; + +template <> +struct pack<type::fix_int8> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const type::fix_int8& v) const + { o.pack_fix_int8(v); return o; } +}; + +template <> +struct pack<type::fix_int16> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const type::fix_int16& v) const + { o.pack_fix_int16(v); return o; } +}; + +template <> +struct pack<type::fix_int32> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const type::fix_int32& v) const + { o.pack_fix_int32(v); return o; } +}; + +template <> +struct pack<type::fix_int64> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const type::fix_int64& v) const + { o.pack_fix_int64(v); return o; } +}; + + +template <> +struct pack<type::fix_uint8> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const type::fix_uint8& v) const + { o.pack_fix_uint8(v); return o; } +}; + +template <> +struct pack<type::fix_uint16> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const type::fix_uint16& v) const + { o.pack_fix_uint16(v); return o; } +}; + +template <> +struct pack<type::fix_uint32> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const type::fix_uint32& v) const + { o.pack_fix_uint32(v); return o; } +}; + +template <> +struct pack<type::fix_uint64> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const type::fix_uint64& v) const + { o.pack_fix_uint64(v); return o; } +}; + +template <> +struct object<type::fix_int8> { + void operator()(clmdep_msgpack::object& o, type::fix_int8 v) const { + if (v.get() < 0) { + o.type = clmdep_msgpack::type::NEGATIVE_INTEGER; + o.via.i64 = v.get(); + } + else { + o.type = clmdep_msgpack::type::POSITIVE_INTEGER; + o.via.u64 = v.get(); + } + } +}; + +template <> +struct object<type::fix_int16> { + void operator()(clmdep_msgpack::object& o, type::fix_int16 v) const { + if(v.get() < 0) { + o.type = clmdep_msgpack::type::NEGATIVE_INTEGER; + o.via.i64 = v.get(); + } + else { + o.type = clmdep_msgpack::type::POSITIVE_INTEGER; + o.via.u64 = v.get(); + } + } +}; + +template <> +struct object<type::fix_int32> { + void operator()(clmdep_msgpack::object& o, type::fix_int32 v) const { + if (v.get() < 0) { + o.type = clmdep_msgpack::type::NEGATIVE_INTEGER; + o.via.i64 = v.get(); + } + else { + o.type = clmdep_msgpack::type::POSITIVE_INTEGER; + o.via.u64 = v.get(); + } + } +}; + +template <> +struct object<type::fix_int64> { + void operator()(clmdep_msgpack::object& o, type::fix_int64 v) const { + if (v.get() < 0) { + o.type = clmdep_msgpack::type::NEGATIVE_INTEGER; + o.via.i64 = v.get(); + } + else { + o.type = clmdep_msgpack::type::POSITIVE_INTEGER; + o.via.u64 = v.get(); + } + } +}; + +template <> +struct object<type::fix_uint8> { + void operator()(clmdep_msgpack::object& o, type::fix_uint8 v) const + { o.type = clmdep_msgpack::type::POSITIVE_INTEGER, o.via.u64 = v.get(); } +}; + +template <> +struct object<type::fix_uint16> { + void operator()(clmdep_msgpack::object& o, type::fix_uint16 v) const + { o.type = clmdep_msgpack::type::POSITIVE_INTEGER, o.via.u64 = v.get(); } +}; + +template <> +struct object<type::fix_uint32> { + void operator()(clmdep_msgpack::object& o, type::fix_uint32 v) const + { o.type = clmdep_msgpack::type::POSITIVE_INTEGER, o.via.u64 = v.get(); } +}; + +template <> +struct object<type::fix_uint64> { + void operator()(clmdep_msgpack::object& o, type::fix_uint64 v) const + { o.type = clmdep_msgpack::type::POSITIVE_INTEGER, o.via.u64 = v.get(); } +}; + +template <> +struct object_with_zone<type::fix_int8> { + void operator()(clmdep_msgpack::object::with_zone& o, type::fix_int8 v) const + { static_cast<clmdep_msgpack::object&>(o) << v; } +}; + +template <> +struct object_with_zone<type::fix_int16> { + void operator()(clmdep_msgpack::object::with_zone& o, type::fix_int16 v) const + { static_cast<clmdep_msgpack::object&>(o) << v; } +}; + +template <> +struct object_with_zone<type::fix_int32> { + void operator()(clmdep_msgpack::object::with_zone& o, type::fix_int32 v) const + { static_cast<clmdep_msgpack::object&>(o) << v; } +}; + +template <> +struct object_with_zone<type::fix_int64> { + void operator()(clmdep_msgpack::object::with_zone& o, type::fix_int64 v) const + { static_cast<clmdep_msgpack::object&>(o) << v; } +}; + + +template <> +struct object_with_zone<type::fix_uint8> { + void operator()(clmdep_msgpack::object::with_zone& o, type::fix_uint8 v) const + { static_cast<clmdep_msgpack::object&>(o) << v; } +}; + +template <> +struct object_with_zone<type::fix_uint16> { + void operator()(clmdep_msgpack::object::with_zone& o, type::fix_uint16 v) const + { static_cast<clmdep_msgpack::object&>(o) << v; } +}; + +template <> +struct object_with_zone<type::fix_uint32> { + void operator()(clmdep_msgpack::object::with_zone& o, type::fix_uint32 v) const + { static_cast<clmdep_msgpack::object&>(o) << v; } +}; + +template <> +struct object_with_zone<type::fix_uint64> { + void operator()(clmdep_msgpack::object::with_zone& o, type::fix_uint64 v) const + { static_cast<clmdep_msgpack::object&>(o) << v; } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif /* msgpack/type/fixint.hpp */ diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/float.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/float.hpp new file mode 100644 index 000000000..8967b64d5 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/float.hpp @@ -0,0 +1,131 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2009 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_FLOAT_HPP +#define MSGPACK_TYPE_FLOAT_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/object_fwd.hpp" +#include <vector> + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +// FIXME check overflow, underflow + +namespace adaptor { + +template <> +struct convert<float> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, float& v) const { + if(o.type == clmdep_msgpack::type::FLOAT) { + v = static_cast<float>(o.via.f64); + } + else if (o.type == clmdep_msgpack::type::POSITIVE_INTEGER) { + v = static_cast<float>(o.via.u64); + } + else if (o.type == clmdep_msgpack::type::NEGATIVE_INTEGER) { + v = static_cast<float>(o.via.i64); + } + else { + throw clmdep_msgpack::type_error(); + } + return o; + } +}; + +template <> +struct pack<float> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const float& v) const { + o.pack_float(v); + return o; + } +}; + + +template <> +struct convert<double> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, double& v) const { + if(o.type == clmdep_msgpack::type::FLOAT) { + v = o.via.f64; + } + else if (o.type == clmdep_msgpack::type::POSITIVE_INTEGER) { + v = static_cast<double>(o.via.u64); + } + else if (o.type == clmdep_msgpack::type::NEGATIVE_INTEGER) { + v = static_cast<double>(o.via.i64); + } + else { + throw clmdep_msgpack::type_error(); + } + return o; + } +}; + +template <> +struct pack<double> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const double& v) const { + o.pack_double(v); + return o; + } +}; + + +template <> +struct object<float> { + void operator()(clmdep_msgpack::object& o, float v) const { + o.type = clmdep_msgpack::type::FLOAT; + o.via.f64 = static_cast<double>(v); + } +}; + +template <> +struct object<double> { + void operator()(clmdep_msgpack::object& o, double v) const { + o.type = clmdep_msgpack::type::FLOAT; + o.via.f64 = v; + } +}; + +template <> +struct object_with_zone<float> { + void operator()(clmdep_msgpack::object::with_zone& o, float v) const { + static_cast<clmdep_msgpack::object&>(o) << v; + } +}; + +template <> +struct object_with_zone<double> { + void operator()(clmdep_msgpack::object::with_zone& o, double v) const { + static_cast<clmdep_msgpack::object&>(o) << v; + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif // MSGPACK_TYPE_FLOAT_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/int.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/int.hpp new file mode 100644 index 000000000..68856b235 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/int.hpp @@ -0,0 +1,436 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2009 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_INT_HPP +#define MSGPACK_TYPE_INT_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" +#include <limits> + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1){ +/// @endcond + +namespace type { +namespace detail { + template <typename T, bool Signed> + struct convert_integer_sign; + + template <typename T> + struct convert_integer_sign<T, true> { + static inline T convert(clmdep_msgpack::object const& o) { + if(o.type == clmdep_msgpack::type::POSITIVE_INTEGER) { + if(o.via.u64 > static_cast<uint64_t>(std::numeric_limits<T>::max())) + { throw clmdep_msgpack::type_error(); } + return static_cast<T>(o.via.u64); + } else if(o.type == clmdep_msgpack::type::NEGATIVE_INTEGER) { + if(o.via.i64 < static_cast<int64_t>(std::numeric_limits<T>::min())) + { throw clmdep_msgpack::type_error(); } + return static_cast<T>(o.via.i64); + } + throw clmdep_msgpack::type_error(); + } + }; + + template <typename T> + struct convert_integer_sign<T, false> { + static inline T convert(clmdep_msgpack::object const& o) { + if(o.type == clmdep_msgpack::type::POSITIVE_INTEGER) { + if(o.via.u64 > static_cast<uint64_t>(std::numeric_limits<T>::max())) + { throw clmdep_msgpack::type_error(); } + return static_cast<T>(o.via.u64); + } + throw clmdep_msgpack::type_error(); + } + }; + + template <typename T> + struct is_signed { + static const bool value = std::numeric_limits<T>::is_signed; + }; + + template <typename T> + static inline T convert_integer(clmdep_msgpack::object const& o) + { + return detail::convert_integer_sign<T, is_signed<T>::value>::convert(o); + } + + template <bool Signed> + struct object_char_sign; + + template <> + struct object_char_sign<true> { + static inline void make(clmdep_msgpack::object& o, char v) { + if (v < 0) { + o.type = clmdep_msgpack::type::NEGATIVE_INTEGER; + o.via.i64 = v; + } + else { + o.type = clmdep_msgpack::type::POSITIVE_INTEGER; + o.via.u64 = v; + } + } + }; + + template <> + struct object_char_sign<false> { + static inline void make(clmdep_msgpack::object& o, char v) { + o.type = clmdep_msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; + } + }; + + static inline void object_char(clmdep_msgpack::object& o, char v) { + return object_char_sign<is_signed<char>::value>::make(o, v); + } + +} // namespace detail +} // namespace type + +namespace adaptor { + +template <> +struct convert<char> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, char& v) const + { v = type::detail::convert_integer<char>(o); return o; } +}; + +template <> +struct convert<signed char> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, signed char& v) const + { v = type::detail::convert_integer<signed char>(o); return o; } +}; + +template <> +struct convert<signed short> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, signed short& v) const + { v = type::detail::convert_integer<signed short>(o); return o; } +}; + +template <> +struct convert<signed int> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, signed int& v) const + { v = type::detail::convert_integer<signed int>(o); return o; } +}; + +template <> +struct convert<signed long> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, signed long& v) const + { v = type::detail::convert_integer<signed long>(o); return o; } +}; + +template <> +struct convert<signed long long> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, signed long long& v) const + { v = type::detail::convert_integer<signed long long>(o); return o; } +}; + + +template <> +struct convert<unsigned char> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, unsigned char& v) const + { v = type::detail::convert_integer<unsigned char>(o); return o; } +}; + +template <> +struct convert<unsigned short> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, unsigned short& v) const + { v = type::detail::convert_integer<unsigned short>(o); return o; } +}; + +template <> +struct convert<unsigned int> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, unsigned int& v) const + { v = type::detail::convert_integer<unsigned int>(o); return o; } +}; + +template <> +struct convert<unsigned long> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, unsigned long& v) const + { v = type::detail::convert_integer<unsigned long>(o); return o; } +}; + +template <> +struct convert<unsigned long long> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, unsigned long long& v) const + { v = type::detail::convert_integer<unsigned long long>(o); return o; } +}; + + +template <> +struct pack<char> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, char v) const + { o.pack_char(v); return o; } +}; + +template <> +struct pack<signed char> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, signed char v) const + { o.pack_signed_char(v); return o; } +}; + +template <> +struct pack<signed short> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, signed short v) const + { o.pack_short(v); return o; } +}; + +template <> +struct pack<signed int> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, signed int v) const + { o.pack_int(v); return o; } +}; + +template <> +struct pack<signed long> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, signed long v) const + { o.pack_long(v); return o; } +}; + +template <> +struct pack<signed long long> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, signed long long v) const + { o.pack_long_long(v); return o; } +}; + + +template <> +struct pack<unsigned char> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, unsigned char v) const + { o.pack_unsigned_char(v); return o; } +}; + +template <> +struct pack<unsigned short> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, unsigned short v) const + { o.pack_unsigned_short(v); return o; } +}; + +template <> +struct pack<unsigned int> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, unsigned int v) const + { o.pack_unsigned_int(v); return o; } +}; + +template <> +struct pack<unsigned long> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, unsigned long v) const + { o.pack_unsigned_long(v); return o; } +}; + +template <> +struct pack<unsigned long long> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, unsigned long long v) const + { o.pack_unsigned_long_long(v); return o; } +}; + + +template <> +struct object<char> { + void operator()(clmdep_msgpack::object& o, char v) const + { type::detail::object_char(o, v); } +}; + +template <> +struct object<signed char> { + void operator()(clmdep_msgpack::object& o, signed char v) const { + if (v < 0) { + o.type = clmdep_msgpack::type::NEGATIVE_INTEGER; + o.via.i64 = v; + } + else { + o.type = clmdep_msgpack::type::POSITIVE_INTEGER; + o.via.u64 = v; + } + } +}; + +template <> +struct object<signed short> { + void operator()(clmdep_msgpack::object& o, signed short v) const { + if (v < 0) { + o.type = clmdep_msgpack::type::NEGATIVE_INTEGER; + o.via.i64 = v; + } + else { + o.type = clmdep_msgpack::type::POSITIVE_INTEGER; + o.via.u64 = v; + } + } +}; + +template <> +struct object<signed int> { + void operator()(clmdep_msgpack::object& o, signed int v) const { + if (v < 0) { + o.type = clmdep_msgpack::type::NEGATIVE_INTEGER; + o.via.i64 = v; + } + else { + o.type = clmdep_msgpack::type::POSITIVE_INTEGER; + o.via.u64 = v; + } + } +}; + +template <> +struct object<signed long> { + void operator()(clmdep_msgpack::object& o, signed long v) const { + if (v < 0) { + o.type = clmdep_msgpack::type::NEGATIVE_INTEGER; + o.via.i64 = v; + } + else { + o.type = clmdep_msgpack::type::POSITIVE_INTEGER; + o.via.u64 = v; + } + } +}; + +template <> +struct object<signed long long> { + void operator()(clmdep_msgpack::object& o, signed long long v) const { + if (v < 0) { + o.type = clmdep_msgpack::type::NEGATIVE_INTEGER; + o.via.i64 = v; + } + else{ + o.type = clmdep_msgpack::type::POSITIVE_INTEGER; + o.via.u64 = v; + } + } +}; + +template <> +struct object<unsigned char> { + void operator()(clmdep_msgpack::object& o, unsigned char v) const + { o.type = clmdep_msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; } +}; + +template <> +struct object<unsigned short> { + void operator()(clmdep_msgpack::object& o, unsigned short v) const + { o.type = clmdep_msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; } +}; + +template <> +struct object<unsigned int> { + void operator()(clmdep_msgpack::object& o, unsigned int v) const + { o.type = clmdep_msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; } +}; + +template <> +struct object<unsigned long> { + void operator()(clmdep_msgpack::object& o, unsigned long v) const + { o.type = clmdep_msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; } +}; + +template <> +struct object<unsigned long long> { + void operator()(clmdep_msgpack::object& o, unsigned long long v) const + { o.type = clmdep_msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; } +}; + + +template <> +struct object_with_zone<char> { + void operator()(clmdep_msgpack::object::with_zone& o, char v) const + { static_cast<clmdep_msgpack::object&>(o) << v; } +}; + +template <> +struct object_with_zone<signed char> { + void operator()(clmdep_msgpack::object::with_zone& o, signed char v) const + { static_cast<clmdep_msgpack::object&>(o) << v; } +}; + +template <> +struct object_with_zone<signed short> { + void operator()(clmdep_msgpack::object::with_zone& o, signed short v) const + { static_cast<clmdep_msgpack::object&>(o) << v; } +}; + +template <> +struct object_with_zone<signed int> { + void operator()(clmdep_msgpack::object::with_zone& o, signed int v) const + { static_cast<clmdep_msgpack::object&>(o) << v; } +}; + +template <> +struct object_with_zone<signed long> { + void operator()(clmdep_msgpack::object::with_zone& o, signed long v) const + { static_cast<clmdep_msgpack::object&>(o) << v; } +}; + +template <> +struct object_with_zone<signed long long> { + void operator()(clmdep_msgpack::object::with_zone& o, const signed long long& v) const + { static_cast<clmdep_msgpack::object&>(o) << v; } +}; + +template <> +struct object_with_zone<unsigned char> { + void operator()(clmdep_msgpack::object::with_zone& o, unsigned char v) const + { static_cast<clmdep_msgpack::object&>(o) << v; } +}; + +template <> +struct object_with_zone<unsigned short> { + void operator()(clmdep_msgpack::object::with_zone& o, unsigned short v) const + { static_cast<clmdep_msgpack::object&>(o) << v; } +}; + +template <> +struct object_with_zone<unsigned int> { + void operator()(clmdep_msgpack::object::with_zone& o, unsigned int v) const + { static_cast<clmdep_msgpack::object&>(o) << v; } +}; + +template <> +struct object_with_zone<unsigned long> { + void operator()(clmdep_msgpack::object::with_zone& o, unsigned long v) const + { static_cast<clmdep_msgpack::object&>(o) << v; } +}; + +template <> +struct object_with_zone<unsigned long long> { + void operator()(clmdep_msgpack::object::with_zone& o, const unsigned long long& v) const + { static_cast<clmdep_msgpack::object&>(o) << v; } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif /* msgpack/type/int.hpp */ diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/list.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/list.hpp new file mode 100644 index 000000000..38666cb91 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/list.hpp @@ -0,0 +1,114 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2015 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_LIST_HPP +#define MSGPACK_TYPE_LIST_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" +#include "rpc/msgpack/adaptor/check_container_size.hpp" + +#include <list> + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace adaptor { + +#if !defined(MSGPACK_USE_CPP03) + +template <typename T, typename Alloc> +struct as<std::list<T, Alloc>, typename std::enable_if<clmdep_msgpack::has_as<T>::value>::type> { + std::list<T, Alloc> operator()(clmdep_msgpack::object const& o) const { + if (o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + std::list<T, Alloc> v; + clmdep_msgpack::object* p = o.via.array.ptr; + clmdep_msgpack::object* const pend = o.via.array.ptr + o.via.array.size; + for (; p < pend; ++p) { + v.push_back(p->as<T>()); + } + return v; + } +}; + +#endif // !defined(MSGPACK_USE_CPP03) + +template <typename T, typename Alloc> +struct convert<std::list<T, Alloc> > { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, std::list<T, Alloc>& v) const { + if (o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + v.resize(o.via.array.size); + clmdep_msgpack::object* p = o.via.array.ptr; + clmdep_msgpack::object* const pend = o.via.array.ptr + o.via.array.size; + typename std::list<T, Alloc>::iterator it = v.begin(); + for (; p < pend; ++p, ++it) { + p->convert(*it); + } + return o; + } +}; + +template <typename T, typename Alloc> +struct pack<std::list<T, Alloc> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const std::list<T, Alloc>& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.pack_array(size); + for (typename std::list<T, Alloc>::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(*it); + } + return o; + } +}; + +template <typename T, typename Alloc> +struct object_with_zone<std::list<T, Alloc> > { + void operator()(clmdep_msgpack::object::with_zone& o, const std::list<T, Alloc>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + if (v.empty()) { + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } + else { + uint32_t size = checked_get_container_size(v.size()); + clmdep_msgpack::object* p = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*size)); + clmdep_msgpack::object* const pend = p + size; + o.via.array.ptr = p; + o.via.array.size = size; + typename std::list<T, Alloc>::const_iterator it(v.begin()); + do { + *p = clmdep_msgpack::object(*it, o.zone); + ++p; + ++it; + } while(p < pend); + } + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif // MSGPACK_TYPE_LIST_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/map.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/map.hpp new file mode 100644 index 000000000..7e94223f7 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/map.hpp @@ -0,0 +1,314 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2015 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_MAP_HPP +#define MSGPACK_TYPE_MAP_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/object_fwd.hpp" +#include "rpc/msgpack/adaptor/check_container_size.hpp" + +#include <map> +#include <vector> +#include <algorithm> + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace type { + +template <typename K, typename V, typename Compare = std::less<K>, typename Alloc = std::allocator<std::pair<K, V> > > +class assoc_vector : public std::vector< std::pair<K, V>, Alloc > { +#if !defined(MSGPACK_USE_CPP03) + using std::vector<std::pair<K, V>, Alloc>::vector; +#endif // !defined(MSGPACK_USE_CPP03) +}; + +namespace detail { + template <typename K, typename V, typename Compare, typename Alloc> + struct pair_first_less { + bool operator() (const std::pair<K, V>& x, const std::pair<K, V>& y) const + { return Compare()(x.first, y.first); } + }; +} + +} //namespace type + +namespace adaptor { + +#if !defined(MSGPACK_USE_CPP03) + +template <typename K, typename V, typename Compare, typename Alloc> +struct as< + type::assoc_vector<K, V, Compare, Alloc>, + typename std::enable_if<clmdep_msgpack::has_as<K>::value && clmdep_msgpack::has_as<V>::value>::type> { + type::assoc_vector<K, V, Compare, Alloc> operator()(clmdep_msgpack::object const& o) const { + if (o.type != clmdep_msgpack::type::MAP) { throw clmdep_msgpack::type_error(); } + type::assoc_vector<K, V, Compare, Alloc> v; + v.reserve(o.via.map.size); + clmdep_msgpack::object_kv* p = o.via.map.ptr; + clmdep_msgpack::object_kv* const pend = o.via.map.ptr + o.via.map.size; + for (; p < pend; ++p) { + v.emplace_back(p->key.as<K>(), p->val.as<V>()); + } + std::sort(v.begin(), v.end(), type::detail::pair_first_less<K, V, Compare, Alloc>()); + return v; + } +}; + +#endif // !defined(MSGPACK_USE_CPP03) + +template <typename K, typename V, typename Compare, typename Alloc> +struct convert<type::assoc_vector<K, V, Compare, Alloc> > { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, type::assoc_vector<K, V, Compare, Alloc>& v) const { + if (o.type != clmdep_msgpack::type::MAP) { throw clmdep_msgpack::type_error(); } + v.resize(o.via.map.size); + clmdep_msgpack::object_kv* p = o.via.map.ptr; + clmdep_msgpack::object_kv* const pend = o.via.map.ptr + o.via.map.size; + std::pair<K, V>* 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<K, V, Compare, Alloc>()); + return o; + } +}; + +template <typename K, typename V, typename Compare, typename Alloc> +struct pack<type::assoc_vector<K, V, Compare, Alloc> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const type::assoc_vector<K, V, Compare, Alloc>& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.pack_map(size); + for (typename type::assoc_vector<K, V, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(it->first); + o.pack(it->second); + } + return o; + } +}; + +template <typename K, typename V, typename Compare, typename Alloc> +struct object_with_zone<type::assoc_vector<K, V, Compare, Alloc> > { + void operator()(clmdep_msgpack::object::with_zone& o, const type::assoc_vector<K, V, Compare, Alloc>& v) const { + o.type = clmdep_msgpack::type::MAP; + if (v.empty()) { + o.via.map.ptr = nullptr; + o.via.map.size = 0; + } + else { + uint32_t size = checked_get_container_size(v.size()); + clmdep_msgpack::object_kv* p = static_cast<clmdep_msgpack::object_kv*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object_kv)*size)); + clmdep_msgpack::object_kv* const pend = p + size; + o.via.map.ptr = p; + o.via.map.size = size; + typename type::assoc_vector<K, V, Compare, Alloc>::const_iterator it(v.begin()); + do { + p->key = clmdep_msgpack::object(it->first, o.zone); + p->val = clmdep_msgpack::object(it->second, o.zone); + ++p; + ++it; + } while(p < pend); + } + } +}; + +#if !defined(MSGPACK_USE_CPP03) + +template <typename K, typename V, typename Compare, typename Alloc> +struct as< + std::map<K, V, Compare, Alloc>, + typename std::enable_if<clmdep_msgpack::has_as<K>::value && clmdep_msgpack::has_as<V>::value>::type> { + std::map<K, V, Compare, Alloc> operator()(clmdep_msgpack::object const& o) const { + if (o.type != clmdep_msgpack::type::MAP) { throw clmdep_msgpack::type_error(); } + clmdep_msgpack::object_kv* p(o.via.map.ptr); + clmdep_msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size); + std::map<K, V, Compare, Alloc> v; + for (; p != pend; ++p) { + v.emplace(p->key.as<K>(), p->val.as<V>()); + } + return v; + } +}; + +#endif // !defined(MSGPACK_USE_CPP03) + +template <typename K, typename V, typename Compare, typename Alloc> +struct convert<std::map<K, V, Compare, Alloc> > { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, std::map<K, V, Compare, Alloc>& v) const { + if (o.type != clmdep_msgpack::type::MAP) { throw clmdep_msgpack::type_error(); } + clmdep_msgpack::object_kv* p(o.via.map.ptr); + clmdep_msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size); + std::map<K, V, Compare, Alloc> tmp; + for (; p != pend; ++p) { + K key; + p->key.convert(key); +#if __cplusplus >= 201103L + p->val.convert(tmp[std::move(key)]); +#else + p->val.convert(tmp[key]); +#endif + } +#if __cplusplus >= 201103L + v = std::move(tmp); +#else + tmp.swap(v); +#endif + return o; + } +}; + +template <typename K, typename V, typename Compare, typename Alloc> +struct pack<std::map<K, V, Compare, Alloc> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const std::map<K, V, Compare, Alloc>& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.pack_map(size); + for (typename std::map<K, V, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(it->first); + o.pack(it->second); + } + return o; + } +}; + +template <typename K, typename V, typename Compare, typename Alloc> +struct object_with_zone<std::map<K, V, Compare, Alloc> > { + void operator()(clmdep_msgpack::object::with_zone& o, const std::map<K, V, Compare, Alloc>& v) const { + o.type = clmdep_msgpack::type::MAP; + if (v.empty()) { + o.via.map.ptr = nullptr; + o.via.map.size = 0; + } + else { + uint32_t size = checked_get_container_size(v.size()); + clmdep_msgpack::object_kv* p = static_cast<clmdep_msgpack::object_kv*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object_kv)*size)); + clmdep_msgpack::object_kv* const pend = p + size; + o.via.map.ptr = p; + o.via.map.size = size; + typename std::map<K, V, Compare, Alloc>::const_iterator it(v.begin()); + do { + p->key = clmdep_msgpack::object(it->first, o.zone); + p->val = clmdep_msgpack::object(it->second, o.zone); + ++p; + ++it; + } while(p < pend); + } + } +}; + +#if !defined(MSGPACK_USE_CPP03) + +template <typename K, typename V, typename Compare, typename Alloc> +struct as< + std::multimap<K, V, Compare, Alloc>, + typename std::enable_if<clmdep_msgpack::has_as<K>::value && clmdep_msgpack::has_as<V>::value>::type> { + std::multimap<K, V, Compare, Alloc> operator()(clmdep_msgpack::object const& o) const { + if (o.type != clmdep_msgpack::type::MAP) { throw clmdep_msgpack::type_error(); } + clmdep_msgpack::object_kv* p(o.via.map.ptr); + clmdep_msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size); + std::multimap<K, V, Compare, Alloc> v; + for (; p != pend; ++p) { + v.emplace(p->key.as<K>(), p->val.as<V>()); + } + return v; + } +}; + +#endif // !defined(MSGPACK_USE_CPP03) + +template <typename K, typename V, typename Compare, typename Alloc> +struct convert<std::multimap<K, V, Compare, Alloc> > { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, std::multimap<K, V, Compare, Alloc>& v) const { + if (o.type != clmdep_msgpack::type::MAP) { throw clmdep_msgpack::type_error(); } + clmdep_msgpack::object_kv* p(o.via.map.ptr); + clmdep_msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size); + std::multimap<K, V, Compare, Alloc> tmp; + for (; p != pend; ++p) { + std::pair<K, V> value; + p->key.convert(value.first); + p->val.convert(value.second); +#if __cplusplus >= 201103L + tmp.insert(std::move(value)); +#else + tmp.insert(value); +#endif + } +#if __cplusplus >= 201103L + v = std::move(tmp); +#else + tmp.swap(v); +#endif + return o; + } +}; + +template <typename K, typename V, typename Compare, typename Alloc> +struct pack<std::multimap<K, V, Compare, Alloc> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const std::multimap<K, V, Compare, Alloc>& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.pack_map(size); + for (typename std::multimap<K, V, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(it->first); + o.pack(it->second); + } + return o; + } +}; + +template <typename K, typename V, typename Compare, typename Alloc> +struct object_with_zone<std::multimap<K, V, Compare, Alloc> > { + void operator()(clmdep_msgpack::object::with_zone& o, const std::multimap<K, V, Compare, Alloc>& v) const { + o.type = clmdep_msgpack::type::MAP; + if (v.empty()) { + o.via.map.ptr = nullptr; + o.via.map.size = 0; + } + else { + uint32_t size = checked_get_container_size(v.size()); + clmdep_msgpack::object_kv* p = static_cast<clmdep_msgpack::object_kv*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object_kv)*size)); + clmdep_msgpack::object_kv* const pend = p + size; + o.via.map.ptr = p; + o.via.map.size = size; + typename std::multimap<K, V, Compare, Alloc>::const_iterator it(v.begin()); + do { + p->key = clmdep_msgpack::object(it->first, o.zone); + p->val = clmdep_msgpack::object(it->second, o.zone); + ++p; + ++it; + } while(p < pend); + } + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif // MSGPACK_TYPE_MAP_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/msgpack_tuple.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/msgpack_tuple.hpp new file mode 100644 index 000000000..6ca153df0 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/msgpack_tuple.hpp @@ -0,0 +1,29 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_MSGPACK_TUPLE_HPP +#define MSGPACK_MSGPACK_TUPLE_HPP + +#include "rpc/msgpack/cpp_config.hpp" + +#if defined(MSGPACK_USE_CPP03) +#include "detail/cpp03_msgpack_tuple.hpp" +#else // MSGPACK_USE_CPP03 +#include "detail/cpp11_msgpack_tuple.hpp" +#endif // MSGPACK_USE_CPP03 + +#endif // MSGPACK_MSGPACK_TUPLE_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/nil.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/nil.hpp new file mode 100644 index 000000000..4dca2af19 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/nil.hpp @@ -0,0 +1,92 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2009 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_NIL_HPP +#define MSGPACK_TYPE_NIL_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace type { + +struct nil { }; + +inline bool operator<(nil const& lhs, nil const& rhs) { + return &lhs < &rhs; +} + +inline bool operator==(nil const& lhs, nil const& rhs) { + return &lhs == &rhs; +} + +} // namespace type + +namespace adaptor { + +template <> +struct convert<type::nil> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, type::nil&) const { + if(o.type != clmdep_msgpack::type::NIL) { throw clmdep_msgpack::type_error(); } + return o; + } +}; + +template <> +struct pack<type::nil> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const type::nil&) const { + o.pack_nil(); + return o; + } +}; + +template <> +struct object<type::nil> { + void operator()(clmdep_msgpack::object& o, type::nil) const { + o.type = clmdep_msgpack::type::NIL; + } +}; + +template <> +struct object_with_zone<type::nil> { + void operator()(clmdep_msgpack::object::with_zone& o, type::nil v) const { + static_cast<clmdep_msgpack::object&>(o) << v; + } +}; + +} // namespace adaptror + +template <> +inline void clmdep_msgpack::object::as<void>() const +{ + clmdep_msgpack::type::nil v; + convert(v); +} + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif // MSGPACK_TYPE_NIL_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/pair.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/pair.hpp new file mode 100644 index 000000000..2f6f0c18e --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/pair.hpp @@ -0,0 +1,91 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2009 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_PAIR_HPP +#define MSGPACK_TYPE_PAIR_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" +#include "rpc/msgpack/meta.hpp" + +#include <utility> + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace adaptor { + +#if !defined(MSGPACK_USE_CPP03) + +template <typename T1, typename T2> +struct as<std::pair<T1, T2>, + typename std::enable_if<clmdep_msgpack::all_of<clmdep_msgpack::has_as, T1, T2>::value>::type> { + std::pair<T1, T2> operator()(clmdep_msgpack::object const& o) const { + if (o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if (o.via.array.size != 2) { throw clmdep_msgpack::type_error(); } + return std::make_pair(o.via.array.ptr[0].as<T1>(), o.via.array.ptr[1].as<T2>()); + } +}; + +#endif // !defined(MSGPACK_USE_CPP03) + +template <typename T1, typename T2> +struct convert<std::pair<T1, T2> > { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, std::pair<T1, T2>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if(o.via.array.size != 2) { throw clmdep_msgpack::type_error(); } + o.via.array.ptr[0].convert(v.first); + o.via.array.ptr[1].convert(v.second); + return o; + } +}; + +template <typename T1, typename T2> +struct pack<std::pair<T1, T2> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const std::pair<T1, T2>& v) const { + o.pack_array(2); + o.pack(v.first); + o.pack(v.second); + return o; + } +}; + +template <typename T1, typename T2> +struct object_with_zone<std::pair<T1, T2> > { + void operator()(clmdep_msgpack::object::with_zone& o, const std::pair<T1, T2>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + clmdep_msgpack::object* p = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*2)); + o.via.array.ptr = p; + o.via.array.size = 2; + p[0] = clmdep_msgpack::object(v.first, o.zone); + p[1] = clmdep_msgpack::object(v.second, o.zone); + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif // MSGPACK_TYPE_PAIR_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/raw.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/raw.hpp new file mode 100644 index 000000000..a01340089 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/raw.hpp @@ -0,0 +1,114 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2009 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_RAW_HPP +#define MSGPACK_TYPE_RAW_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" +#include <cstring> +#include <string> + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace type { + +struct raw_ref { + raw_ref() : size(0), ptr(nullptr) {} + raw_ref(const char* p, uint32_t s) : size(s), ptr(p) {} + + uint32_t size; + const char* ptr; + + std::string str() const { return std::string(ptr, size); } + + bool operator== (const raw_ref& x) const + { + return size == x.size && std::memcmp(ptr, x.ptr, size) == 0; + } + + bool operator!= (const raw_ref& x) const + { + return !(*this == x); + } + + bool operator< (const raw_ref& x) const + { + if(size == x.size) { return std::memcmp(ptr, x.ptr, size) < 0; } + else { return size < x.size; } + } + + bool operator> (const raw_ref& x) const + { + if(size == x.size) { return std::memcmp(ptr, x.ptr, size) > 0; } + else { return size > x.size; } + } +}; + +} // namespace type + +namespace adaptor { + +template <> +struct convert<clmdep_msgpack::type::raw_ref> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, clmdep_msgpack::type::raw_ref& v) const { + if(o.type != clmdep_msgpack::type::BIN) { throw clmdep_msgpack::type_error(); } + v.ptr = o.via.bin.ptr; + v.size = o.via.bin.size; + return o; + } +}; + +template <> +struct pack<clmdep_msgpack::type::raw_ref> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const clmdep_msgpack::type::raw_ref& v) const { + o.pack_bin(v.size); + o.pack_bin_body(v.ptr, v.size); + return o; + } +}; + +template <> +struct object<clmdep_msgpack::type::raw_ref> { + void operator()(clmdep_msgpack::object& o, const clmdep_msgpack::type::raw_ref& v) const { + o.type = clmdep_msgpack::type::BIN; + o.via.bin.ptr = v.ptr; + o.via.bin.size = v.size; + } +}; + +template <> +struct object_with_zone<clmdep_msgpack::type::raw_ref> { + void operator()(clmdep_msgpack::object::with_zone& o, const clmdep_msgpack::type::raw_ref& v) const { + static_cast<clmdep_msgpack::object&>(o) << v; + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif // MSGPACK_TYPE_RAW_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/set.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/set.hpp new file mode 100644 index 000000000..405a99272 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/set.hpp @@ -0,0 +1,196 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2015 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_SET_HPP +#define MSGPACK_TYPE_SET_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" +#include "rpc/msgpack/adaptor/check_container_size.hpp" + +#include <set> + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace adaptor { + +#if !defined(MSGPACK_USE_CPP03) + +template <typename T, typename Compare, typename Alloc> +struct as<std::set<T, Compare, Alloc>, typename std::enable_if<clmdep_msgpack::has_as<T>::value>::type> { + std::set<T, Compare, Alloc> operator()(clmdep_msgpack::object const& o) const { + if (o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + clmdep_msgpack::object* p = o.via.array.ptr + o.via.array.size; + clmdep_msgpack::object* const pbegin = o.via.array.ptr; + std::set<T, Compare, Alloc> v; + while (p > pbegin) { + --p; + v.insert(p->as<T>()); + } + return v; + } +}; + +#endif // !defined(MSGPACK_USE_CPP03) + +template <typename T, typename Compare, typename Alloc> +struct convert<std::set<T, Compare, Alloc> > { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, std::set<T, Compare, Alloc>& v) const { + if (o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + clmdep_msgpack::object* p = o.via.array.ptr + o.via.array.size; + clmdep_msgpack::object* const pbegin = o.via.array.ptr; + std::set<T, Compare, Alloc> tmp; + while (p > pbegin) { + --p; + tmp.insert(p->as<T>()); + } +#if __cplusplus >= 201103L + v = std::move(tmp); +#else + tmp.swap(v); +#endif + return o; + } +}; + +template <typename T, typename Compare, typename Alloc> +struct pack<std::set<T, Compare, Alloc> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const std::set<T, Compare, Alloc>& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.pack_array(size); + for (typename std::set<T, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(*it); + } + return o; + } +}; + +template <typename T, typename Compare, typename Alloc> +struct object_with_zone<std::set<T, Compare, Alloc> > { + void operator()(clmdep_msgpack::object::with_zone& o, const std::set<T, Compare, Alloc>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + if (v.empty()) { + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } + else { + uint32_t size = checked_get_container_size(v.size()); + clmdep_msgpack::object* p = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*size)); + clmdep_msgpack::object* const pend = p + size; + o.via.array.ptr = p; + o.via.array.size = size; + typename std::set<T, Compare, Alloc>::const_iterator it(v.begin()); + do { + *p = clmdep_msgpack::object(*it, o.zone); + ++p; + ++it; + } while(p < pend); + } + } +}; + +#if !defined(MSGPACK_USE_CPP03) + +template <typename T, typename Compare, typename Alloc> +struct as<std::multiset<T, Compare, Alloc>, typename std::enable_if<clmdep_msgpack::has_as<T>::value>::type> { + std::multiset<T, Compare, Alloc> operator()(clmdep_msgpack::object const& o) const { + if (o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + clmdep_msgpack::object* p = o.via.array.ptr + o.via.array.size; + clmdep_msgpack::object* const pbegin = o.via.array.ptr; + std::multiset<T, Compare, Alloc> v; + while (p > pbegin) { + --p; + v.insert(p->as<T>()); + } + return v; + } +}; + +#endif // !defined(MSGPACK_USE_CPP03) + +template <typename T, typename Compare, typename Alloc> +struct convert<std::multiset<T, Compare, Alloc> > { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, std::multiset<T, Compare, Alloc>& v) const { + if (o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + clmdep_msgpack::object* p = o.via.array.ptr + o.via.array.size; + clmdep_msgpack::object* const pbegin = o.via.array.ptr; + std::multiset<T, Compare, Alloc> tmp; + while (p > pbegin) { + --p; + tmp.insert(p->as<T>()); + } +#if __cplusplus >= 201103L + v = std::move(tmp); +#else + tmp.swap(v); +#endif + return o; + } +}; + +template <typename T, typename Compare, typename Alloc> +struct pack<std::multiset<T, Compare, Alloc> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const std::multiset<T, Compare, Alloc>& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.pack_array(size); + for (typename std::multiset<T, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(*it); + } + return o; + } +}; + +template <typename T, typename Compare, typename Alloc> +struct object_with_zone<std::multiset<T, Compare, Alloc> > { + void operator()(clmdep_msgpack::object::with_zone& o, const std::multiset<T, Compare, Alloc>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + if (v.empty()) { + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } else { + uint32_t size = checked_get_container_size(v.size()); + clmdep_msgpack::object* p = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*size)); + clmdep_msgpack::object* const pend = p + size; + o.via.array.ptr = p; + o.via.array.size = size; + typename std::multiset<T, Compare, Alloc>::const_iterator it(v.begin()); + do { + *p = clmdep_msgpack::object(*it, o.zone); + ++p; + ++it; + } while(p < pend); + } + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif // MSGPACK_TYPE_SET_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/string.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/string.hpp new file mode 100644 index 000000000..c9c5359f3 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/string.hpp @@ -0,0 +1,94 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2015 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_STRING_HPP +#define MSGPACK_TYPE_STRING_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" +#include "rpc/msgpack/adaptor/check_container_size.hpp" + +#include <string> + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace adaptor { + +template <> +struct convert<std::string> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, std::string& v) const { + switch (o.type) { + case clmdep_msgpack::type::BIN: + v.assign(o.via.bin.ptr, o.via.bin.size); + break; + case clmdep_msgpack::type::STR: + v.assign(o.via.str.ptr, o.via.str.size); + break; + default: + throw clmdep_msgpack::type_error(); + break; + } + return o; + } +}; + +template <> +struct pack<std::string> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const std::string& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.pack_str(size); + o.pack_str_body(v.data(), size); + return o; + } +}; + +template <> +struct object<std::string> { + void operator()(clmdep_msgpack::object& o, const std::string& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.type = clmdep_msgpack::type::STR; + o.via.str.ptr = v.data(); + o.via.str.size = size; + } +}; + +template <> +struct object_with_zone<std::string> { + void operator()(clmdep_msgpack::object::with_zone& o, const std::string& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.type = clmdep_msgpack::type::STR; + char* ptr = static_cast<char*>(o.zone.allocate_align(size)); + o.via.str.ptr = ptr; + o.via.str.size = size; + std::memcpy(ptr, v.data(), v.size()); + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif // MSGPACK_TYPE_STRING_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/tr1/unordered_map.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/tr1/unordered_map.hpp new file mode 100644 index 000000000..4fec3ba68 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/tr1/unordered_map.hpp @@ -0,0 +1,179 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2015 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP +#define MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" +#include "rpc/msgpack/adaptor/check_container_size.hpp" + +#if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) + +#define MSGPACK_HAS_STD_UNORDERED_MAP +#include <unordered_map> +#define MSGPACK_STD_TR1 std + +#else // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) + +#if __GNUC__ >= 4 + +#define MSGPACK_HAS_STD_TR1_UNORDERED_MAP + +#include <tr1/unordered_map> +#define MSGPACK_STD_TR1 std::tr1 + +#endif // __GNUC__ >= 4 + +#endif // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) + +#if defined(MSGPACK_STD_TR1) + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace adaptor { + +template <typename K, typename V, typename Hash, typename Pred, typename Alloc> +struct convert<MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc> > { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc>& v) const { + if(o.type != clmdep_msgpack::type::MAP) { throw clmdep_msgpack::type_error(); } + clmdep_msgpack::object_kv* p(o.via.map.ptr); + clmdep_msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size); + MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc> tmp; + for(; p != pend; ++p) { + K key; + p->key.convert(key); + p->val.convert(tmp[key]); + } + tmp.swap(v); + return o; + } +}; + +template <typename K, typename V, typename Hash, typename Pred, typename Alloc> +struct pack<MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc>& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.pack_map(size); + for(typename MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc>::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(it->first); + o.pack(it->second); + } + return o; + } +}; + +template <typename K, typename V, typename Hash, typename Pred, typename Alloc> +struct object_with_zone<MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc> > { + void operator()(clmdep_msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc>& v) const { + o.type = clmdep_msgpack::type::MAP; + if(v.empty()) { + o.via.map.ptr = nullptr; + o.via.map.size = 0; + } else { + uint32_t size = checked_get_container_size(v.size()); + clmdep_msgpack::object_kv* p = static_cast<clmdep_msgpack::object_kv*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object_kv)*size)); + clmdep_msgpack::object_kv* const pend = p + size; + o.via.map.ptr = p; + o.via.map.size = size; + typename MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc>::const_iterator it(v.begin()); + do { + p->key = clmdep_msgpack::object(it->first, o.zone); + p->val = clmdep_msgpack::object(it->second, o.zone); + ++p; + ++it; + } while(p < pend); + } + } +}; + +template <typename K, typename V, typename Hash, typename Pred, typename Alloc> +struct convert<MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Alloc> > { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Alloc>& v) const { + if(o.type != clmdep_msgpack::type::MAP) { throw clmdep_msgpack::type_error(); } + clmdep_msgpack::object_kv* p(o.via.map.ptr); + clmdep_msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size); + MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Alloc> tmp; + for(; p != pend; ++p) { + std::pair<K, V> value; + p->key.convert(value.first); + p->val.convert(value.second); + tmp.insert(value); + } + tmp.swap(v); + return o; + } +}; + +template <typename K, typename V, typename Hash, typename Pred, typename Alloc> +struct pack<MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Alloc> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Alloc>& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.pack_map(size); + for(typename MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Alloc>::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(it->first); + o.pack(it->second); + } + return o; + } +}; + +template <typename K, typename V, typename Hash, typename Pred, typename Alloc> +struct object_with_zone<MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Alloc> > { + void operator()(clmdep_msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Alloc>& v) const { + o.type = clmdep_msgpack::type::MAP; + if(v.empty()) { + o.via.map.ptr = nullptr; + o.via.map.size = 0; + } else { + uint32_t size = checked_get_container_size(v.size()); + clmdep_msgpack::object_kv* p = static_cast<clmdep_msgpack::object_kv*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object_kv)*size)); + clmdep_msgpack::object_kv* const pend = p + size; + o.via.map.ptr = p; + o.via.map.size = size; + typename MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Alloc>::const_iterator it(v.begin()); + do { + p->key = clmdep_msgpack::object(it->first, o.zone); + p->val = clmdep_msgpack::object(it->second, o.zone); + ++p; + ++it; + } while(p < pend); + } + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#undef MSGPACK_STD_TR1 + +#endif // MSGPACK_STD_TR1 + +#endif // MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/tr1/unordered_set.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/tr1/unordered_set.hpp new file mode 100644 index 000000000..e00b160d2 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/tr1/unordered_set.hpp @@ -0,0 +1,173 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2015 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_TR1_UNORDERED_SET_HPP +#define MSGPACK_TYPE_TR1_UNORDERED_SET_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" +#include "rpc/msgpack/adaptor/check_container_size.hpp" + +#if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) + +#define MSGPACK_HAS_STD_UNORDERED_SET +#include <unordered_set> +#define MSGPACK_STD_TR1 std + +#else // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) + +#if __GNUC__ >= 4 + +#define MSGPACK_HAS_STD_TR1_UNORDERED_SET + +#include <tr1/unordered_set> +#define MSGPACK_STD_TR1 std::tr1 + +#endif // __GNUC__ >= 4 + +#endif // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) + +#if defined(MSGPACK_STD_TR1) + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace adaptor { + +template <typename T, typename Hash, typename Compare, typename Alloc> +struct convert<MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc> > { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + clmdep_msgpack::object* p = o.via.array.ptr + o.via.array.size; + clmdep_msgpack::object* const pbegin = o.via.array.ptr; + MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc> tmp; + while(p > pbegin) { + --p; + tmp.insert(p->as<T>()); + } + tmp.swap(v); + return o; + } +}; + +template <typename T, typename Hash, typename Compare, typename Alloc> +struct pack<MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc>& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.pack_array(size); + for(typename MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(*it); + } + return o; + } +}; + +template <typename T, typename Hash, typename Compare, typename Alloc> +struct object_with_zone<MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc> > { + void operator()(clmdep_msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + if(v.empty()) { + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } else { + uint32_t size = checked_get_container_size(v.size()); + clmdep_msgpack::object* p = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*size)); + clmdep_msgpack::object* const pend = p + size; + o.via.array.ptr = p; + o.via.array.size = size; + typename MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc>::const_iterator it(v.begin()); + do { + *p = clmdep_msgpack::object(*it, o.zone); + ++p; + ++it; + } while(p < pend); + } + } +}; + + +template <typename T, typename Hash, typename Compare, typename Alloc> +struct convert<MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Alloc> > { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Alloc>& v) const { + if(o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + clmdep_msgpack::object* p = o.via.array.ptr + o.via.array.size; + clmdep_msgpack::object* const pbegin = o.via.array.ptr; + MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Alloc> tmp; + while(p > pbegin) { + --p; + tmp.insert(p->as<T>()); + } + tmp.swap(v); + return o; + } +}; + +template <typename T, typename Hash, typename Compare, typename Alloc> +struct pack<MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Alloc> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Alloc>& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.pack_array(size); + for(typename MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(*it); + } + return o; + } +}; + +template <typename T, typename Hash, typename Compare, typename Alloc> +struct object_with_zone<MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Alloc> > { + void operator()(clmdep_msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Alloc>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + if(v.empty()) { + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } else { + uint32_t size = checked_get_container_size(v.size()); + clmdep_msgpack::object* p = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*size)); + clmdep_msgpack::object* const pend = p + size; + o.via.array.ptr = p; + o.via.array.size = size; + typename MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Alloc>::const_iterator it(v.begin()); + do { + *p = clmdep_msgpack::object(*it, o.zone); + ++p; + ++it; + } while(p < pend); + } + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#undef MSGPACK_STD_TR1 + +#endif // MSGPACK_STD_TR1 + +#endif // MSGPACK_TYPE_TR1_UNORDERED_SET_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/v4raw.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/v4raw.hpp new file mode 100644 index 000000000..8ddf786bc --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/v4raw.hpp @@ -0,0 +1,114 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_V4RAW_HPP +#define MSGPACK_TYPE_V4RAW_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" +#include <cstring> +#include <string> + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace type { + +struct v4raw_ref { + v4raw_ref() : size(0), ptr(nullptr) {} + v4raw_ref(const char* p, uint32_t s) : size(s), ptr(p) {} + + uint32_t size; + const char* ptr; + + std::string str() const { return std::string(ptr, size); } + + bool operator== (const v4raw_ref& x) const + { + return size == x.size && std::memcmp(ptr, x.ptr, size) == 0; + } + + bool operator!= (const v4raw_ref& x) const + { + return !(*this == x); + } + + bool operator< (const v4raw_ref& x) const + { + if(size == x.size) { return std::memcmp(ptr, x.ptr, size) < 0; } + else { return size < x.size; } + } + + bool operator> (const v4raw_ref& x) const + { + if(size == x.size) { return std::memcmp(ptr, x.ptr, size) > 0; } + else { return size > x.size; } + } +}; + +} // namespace type + +namespace adaptor { + +template <> +struct convert<clmdep_msgpack::type::v4raw_ref> { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, clmdep_msgpack::type::v4raw_ref& v) const { + if(o.type != clmdep_msgpack::type::STR) { throw clmdep_msgpack::type_error(); } + v.ptr = o.via.str.ptr; + v.size = o.via.str.size; + return o; + } +}; + +template <> +struct pack<clmdep_msgpack::type::v4raw_ref> { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const clmdep_msgpack::type::v4raw_ref& v) const { + o.pack_v4raw(v.size); + o.pack_v4raw_body(v.ptr, v.size); + return o; + } +}; + +template <> +struct object<clmdep_msgpack::type::v4raw_ref> { + void operator()(clmdep_msgpack::object& o, const clmdep_msgpack::type::v4raw_ref& v) const { + o.type = clmdep_msgpack::type::STR; + o.via.str.ptr = v.ptr; + o.via.str.size = v.size; + } +}; + +template <> +struct object_with_zone<clmdep_msgpack::type::v4raw_ref> { + void operator()(clmdep_msgpack::object::with_zone& o, const clmdep_msgpack::type::v4raw_ref& v) const { + static_cast<clmdep_msgpack::object&>(o) << v; + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif // MSGPACK_TYPE_V4RAW_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/vector.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/vector.hpp new file mode 100644 index 000000000..d5a2a12e6 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/vector.hpp @@ -0,0 +1,129 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_VECTOR_HPP +#define MSGPACK_TYPE_VECTOR_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" +#include "rpc/msgpack/adaptor/check_container_size.hpp" + +#include <vector> + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace adaptor { + +#if !defined(MSGPACK_USE_CPP03) + +template <typename T, typename Alloc> +struct as<std::vector<T, Alloc>, typename std::enable_if<clmdep_msgpack::has_as<T>::value>::type> { + std::vector<T, Alloc> operator()(const clmdep_msgpack::object& o) const { + if (o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + std::vector<T, Alloc> v; + v.reserve(o.via.array.size); + if (o.via.array.size > 0) { + clmdep_msgpack::object* p = o.via.array.ptr; + clmdep_msgpack::object* const pend = o.via.array.ptr + o.via.array.size; + do { + v.push_back(p->as<T>()); + ++p; + } while (p < pend); + } + return v; + } +}; + +#endif // !defined(MSGPACK_USE_CPP03) + +template <typename T, typename Alloc> +struct convert<std::vector<T, Alloc> > { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, std::vector<T, Alloc>& v) const { + if (o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + v.resize(o.via.array.size); + if (o.via.array.size > 0) { + clmdep_msgpack::object* p = o.via.array.ptr; + clmdep_msgpack::object* const pend = o.via.array.ptr + o.via.array.size; + typename std::vector<T, Alloc>::iterator it = v.begin(); + do { + p->convert(*it); + ++p; + ++it; + } while(p < pend); + } + return o; + } +}; + +template <typename T, typename Alloc> +struct pack<std::vector<T, Alloc> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const std::vector<T, Alloc>& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.pack_array(size); + for (typename std::vector<T, Alloc>::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(*it); + } + return o; + } +}; + +template <typename T, typename Alloc> +struct object_with_zone<std::vector<T, Alloc> > { + void operator()(clmdep_msgpack::object::with_zone& o, const std::vector<T, Alloc>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + if (v.empty()) { + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } + else { + uint32_t size = checked_get_container_size(v.size()); + clmdep_msgpack::object* p = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*size)); + clmdep_msgpack::object* const pend = p + size; + o.via.array.ptr = p; + o.via.array.size = size; + typename std::vector<T, Alloc>::const_iterator it(v.begin()); + do { +#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wmaybe-uninitialized" +#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__) + *p = clmdep_msgpack::object(*it, o.zone); +#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__) + ++p; + ++it; + } while(p < pend); + } + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif // MSGPACK_TYPE_VECTOR_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/vector_bool.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/vector_bool.hpp new file mode 100644 index 000000000..bfee60e67 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/vector_bool.hpp @@ -0,0 +1,96 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2015 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_VECTOR_BOOL_HPP +#define MSGPACK_TYPE_VECTOR_BOOL_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/object_fwd.hpp" +#include <vector> + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace adaptor { + +template <typename Alloc> +struct convert<std::vector<bool, Alloc> > { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, std::vector<bool, Alloc>& v) const { + if (o.type != clmdep_msgpack::type::ARRAY) { throw clmdep_msgpack::type_error(); } + if (o.via.array.size > 0) { + v.resize(o.via.array.size); + clmdep_msgpack::object* p = o.via.array.ptr; + for (typename std::vector<bool, Alloc>::iterator it = v.begin(), end = v.end(); + it != end; + ++it) { + *it = p->as<bool>(); + ++p; + } + } + return o; + } +}; + +template <typename Alloc> +struct pack<std::vector<bool, Alloc> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const std::vector<bool, Alloc>& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.pack_array(size); + for(typename std::vector<bool, Alloc>::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(static_cast<bool>(*it)); + } + return o; + } +}; + +template <typename Alloc> +struct object_with_zone<std::vector<bool, Alloc> > { + void operator()(clmdep_msgpack::object::with_zone& o, const std::vector<bool, Alloc>& v) const { + o.type = clmdep_msgpack::type::ARRAY; + if(v.empty()) { + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } else { + uint32_t size = checked_get_container_size(v.size()); + clmdep_msgpack::object* p = static_cast<clmdep_msgpack::object*>(o.zone.allocate_align(sizeof(clmdep_msgpack::object)*size)); + clmdep_msgpack::object* const pend = p + size; + o.via.array.ptr = p; + o.via.array.size = size; + typename std::vector<bool, Alloc>::const_iterator it(v.begin()); + do { + *p = clmdep_msgpack::object(static_cast<bool>(*it), o.zone); + ++p; + ++it; + } while(p < pend); + } + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif // MSGPACK_TYPE_VECTOR_BOOL_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/vector_char.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/vector_char.hpp new file mode 100644 index 000000000..a5416e8d2 --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/vector_char.hpp @@ -0,0 +1,97 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2014-2015 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_VECTOR_CHAR_HPP +#define MSGPACK_TYPE_VECTOR_CHAR_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" +#include "rpc/msgpack/adaptor/check_container_size.hpp" + +#include <vector> + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace adaptor { + +template <typename Alloc> +struct convert<std::vector<char, Alloc> > { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, std::vector<char, Alloc>& v) const { + switch (o.type) { + case clmdep_msgpack::type::BIN: + v.resize(o.via.bin.size); + std::memcpy(&v.front(), o.via.bin.ptr, o.via.bin.size); + break; + case clmdep_msgpack::type::STR: + v.resize(o.via.str.size); + std::memcpy(&v.front(), o.via.str.ptr, o.via.str.size); + break; + default: + throw clmdep_msgpack::type_error(); + break; + } + return o; + } +}; + +template <typename Alloc> +struct pack<std::vector<char, Alloc> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const std::vector<char, Alloc>& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.pack_bin(size); + o.pack_bin_body(&v.front(), size); + + return o; + } +}; + +template <typename Alloc> +struct object<std::vector<char, Alloc> > { + void operator()(clmdep_msgpack::object& o, const std::vector<char, Alloc>& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.type = clmdep_msgpack::type::BIN; + o.via.bin.ptr = &v.front(); + o.via.bin.size = size; + } +}; + +template <typename Alloc> +struct object_with_zone<std::vector<char, Alloc> > { + void operator()(clmdep_msgpack::object::with_zone& o, const std::vector<char, Alloc>& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.type = clmdep_msgpack::type::BIN; + char* ptr = static_cast<char*>(o.zone.allocate_align(size)); + o.via.bin.ptr = ptr; + o.via.bin.size = size; + std::memcpy(ptr, &v.front(), size); + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif // MSGPACK_TYPE_VECTOR_CHAR_HPP diff --git a/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/vector_unsigned_char.hpp b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/vector_unsigned_char.hpp new file mode 100644 index 000000000..3321d0d6d --- /dev/null +++ b/host/lib/deps/rpclib/include/rpc/msgpack/adaptor/vector_unsigned_char.hpp @@ -0,0 +1,97 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2014-2015 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_VECTOR_UNSIGNED_CHAR_HPP +#define MSGPACK_TYPE_VECTOR_UNSIGNED_CHAR_HPP + +#include "rpc/msgpack/versioning.hpp" +#include "rpc/msgpack/adaptor/adaptor_base.hpp" +#include "rpc/msgpack/adaptor/check_container_size.hpp" + +#include <vector> + +namespace clmdep_msgpack { + +/// @cond +MSGPACK_API_VERSION_NAMESPACE(v1) { +/// @endcond + +namespace adaptor { + +template <typename Alloc> +struct convert<std::vector<unsigned char, Alloc> > { + clmdep_msgpack::object const& operator()(clmdep_msgpack::object const& o, std::vector<unsigned char, Alloc>& v) const { + switch (o.type) { + case clmdep_msgpack::type::BIN: + v.resize(o.via.bin.size); + std::memcpy(&v.front(), o.via.bin.ptr, o.via.bin.size); + break; + case clmdep_msgpack::type::STR: + v.resize(o.via.str.size); + std::memcpy(&v.front(), o.via.str.ptr, o.via.str.size); + break; + default: + throw clmdep_msgpack::type_error(); + break; + } + return o; + } +}; + +template <typename Alloc> +struct pack<std::vector<unsigned char, Alloc> > { + template <typename Stream> + clmdep_msgpack::packer<Stream>& operator()(clmdep_msgpack::packer<Stream>& o, const std::vector<unsigned char, Alloc>& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.pack_bin(size); + o.pack_bin_body(reinterpret_cast<char const*>(&v.front()), size); + + return o; + } +}; + +template <typename Alloc> +struct object<std::vector<unsigned char, Alloc> > { + void operator()(clmdep_msgpack::object& o, const std::vector<unsigned char, Alloc>& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.type = clmdep_msgpack::type::BIN; + o.via.bin.ptr = reinterpret_cast<char const*>(&v.front()); + o.via.bin.size = size; + } +}; + +template <typename Alloc> +struct object_with_zone<std::vector<unsigned char, Alloc> > { + void operator()(clmdep_msgpack::object::with_zone& o, const std::vector<unsigned char, Alloc>& v) const { + uint32_t size = checked_get_container_size(v.size()); + o.type = clmdep_msgpack::type::BIN; + char* ptr = static_cast<char*>(o.zone.allocate_align(size)); + o.via.bin.ptr = ptr; + o.via.bin.size = size; + std::memcpy(ptr, &v.front(), size); + } +}; + +} // namespace adaptor + +/// @cond +} // MSGPACK_API_VERSION_NAMESPACE(v1) +/// @endcond + +} // namespace clmdep_msgpack + +#endif // MSGPACK_TYPE_VECTOR_UNSIGNED_CHAR_HPP |