diff --git a/.gitignore b/.gitignore index ffc26910..3328fdce 100644 --- a/.gitignore +++ b/.gitignore @@ -19,6 +19,7 @@ Makefile.in /libtool /msgpack.pc /src/msgpack/version.h +/src/msgpack/version.hpp /stamp-h1 Makefile .deps diff --git a/.travis.yml b/.travis.yml index bbaca292..78ea246e 100644 --- a/.travis.yml +++ b/.travis.yml @@ -5,21 +5,30 @@ compiler: - clang - gcc before_install: -# We need this line to have g++4.8 available in apt - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test + - sudo add-apt-repository -y ppa:h-rayflood/llvm - sudo apt-get update -qq - sudo apt-get update - sudo apt-get install valgrind - - sudo apt-get install libgtest-dev - - "cd /usr/src/gtest && sudo cmake . && sudo cmake --build . && sudo mv libg* /usr/local/lib/ ; cd -" install: - - sudo apt-get install -qq gcc-4.8 g++-4.8 -# We want to compile with g++ 4.8 when rather than the default g++ + - sudo apt-get install -qq gcc-4.8-multilib g++-4.8-multilib + - sudo apt-get install --allow-unauthenticated -qq clang-3.4 - sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.8 90 - + - sudo apt-get install -y lib32gcc1 + - sudo apt-get install -y libc6-i386 + - sudo apt-get install -y lib32z1-dev + - sudo apt-get install -y lib32stdc++6 + - wget https://googletest.googlecode.com/files/gtest-1.7.0.zip + - unzip gtest-1.7.0.zip && cd gtest-1.7.0 && sudo cp -r include/gtest /usr/local/include && g++ src/gtest-all.cc -I. -Iinclude -c && g++ src/gtest_main.cc -I. -Iinclude -c && ar -rv libgtest.a gtest-all.o && ar -rv libgtest_main.a gtest_main.o && sudo mv *.a /usr/local/lib && g++ -m32 src/gtest-all.cc -I. -Iinclude -c && g++ -m32 src/gtest_main.cc -I. -Iinclude -c && ar -rv libgtest.a gtest-all.o && ar -rv libgtest_main.a gtest_main.o && sudo mkdir /usr/local/lib32 && sudo mv *.a /usr/local/lib32 && cd .. env: - - ACTION="ci/build_autotools.sh" PARAM="cpp03" - - ACTION="ci/build_cmake.sh" PARAM="cpp03" + - ACTION="ci/build_autotools.sh" VERSION="cpp11" ARCH="64" LIBPATH="/usr/local/lib" + - ACTION="ci/build_autotools.sh" VERSION="cpp11" ARCH="32" LIBPATH="/usr/local/lib32" + - ACTION="ci/build_autotools.sh" VERSION="cpp03" ARCH="64" LIBPATH="/usr/local/lib" + - ACTION="ci/build_autotools.sh" VERSION="cpp03" ARCH="32" LIBPATH="/usr/local/lib32" + - ACTION="ci/build_cmake.sh" VERSION="cpp11" ARCH="64" LIBPATH="/usr/local/lib" + - ACTION="ci/build_cmake.sh" VERSION="cpp11" ARCH="32" LIBPATH="/usr/local/lib32" + - ACTION="ci/build_cmake.sh" VERSION="cpp03" ARCH="64" LIBPATH="/usr/local/lib" + - ACTION="ci/build_cmake.sh" VERSION="cpp03" ARCH="32" LIBPATH="/usr/local/lib32" script: - - git clean -xdf && ${ACTION} ${PARAM} + - git clean -xdf && CMAKE_LIBRARY_PATH=${LIBPATH} ${ACTION} ${VERSION} ${ARCH} diff --git a/CMakeLists.txt b/CMakeLists.txt index 4edddf92..a13939d9 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,20 +1,50 @@ CMAKE_MINIMUM_REQUIRED (VERSION 2.8.6) PROJECT (msgpack) -SET (VERSION 0.5.9) -SET (VERSION_MAJOR 0) -SET (VERSION_MINOR 5) +FILE (READ ${CMAKE_SOURCE_DIR}/include/msgpack/version_master.h contents) +STRING (REGEX MATCH "#define MSGPACK_VERSION_MAJOR *([0-9a-zA-Z_]*)" NULL_OUT ${contents}) +SET (VERSION_MAJOR ${CMAKE_MATCH_1}) +STRING (REGEX MATCH "#define MSGPACK_VERSION_MINOR *([0-9a-zA-Z_]*)" NULL_OUT ${contents}) +SET (VERSION_MINOR ${CMAKE_MATCH_1}) +STRING (REGEX MATCH "#define MSGPACK_VERSION_REVISION *([0-9a-zA-Z_]*)" NULL_OUT ${contents}) +SET (VERSION_REVISION ${CMAKE_MATCH_1}) +SET (VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_REVISION}) SET (prefix ${CMAKE_INSTALL_PREFIX}) SET (exec_prefix "\${prefix}") SET (libdir "\${exec_prefix}/lib") SET (includedir "\${prefix}/include") +OPTION (MSGPACK_CXX11 "Using c++11 compiler" OFF) +OPTION (MSGPACK_32BIT "32bit compile" OFF) + +IF (MSGPACK_CXX11) + IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") + SET (CMAKE_CXX_FLAGS "-std=c++11 ${CMAKE_CXX_FLAGS}") + ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") + SET (CMAKE_CXX_FLAGS "-std=c++11 ${CMAKE_CXX_FLAGS}") + ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") + MESSAGE ( FATAL_ERROR "MSVC doesn't support C++11 yet.") + ENDIF () +ENDIF () + +IF (MSGPACK_32BIT) + IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") + SET (CMAKE_CXX_FLAGS "-m32 ${CMAKE_CXX_FLAGS}") + SET (CMAKE_C_FLAGS "-m32 ${CMAKE_C_FLAGS}") + SET (CMAKE_EXE_LINKER_FLAGS "-m32 ${CMAKE_EXE_LINKER_FLAGS}") + ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") + SET (CMAKE_CXX_FLAGS "-m32 ${CMAKE_CXX_FLAGS}") + SET (CMAKE_C_FLAGS "-m32 ${CMAKE_C_FLAGS}") + SET (CMAKE_EXE_LINKER_FLAGS "-m32 ${CMAKE_EXE_LINKER_FLAGS}") + ENDIF () +ENDIF () + FIND_PACKAGE (GTest) FIND_PACKAGE (ZLIB) FIND_PACKAGE (Threads) IF (GTEST_FOUND AND ZLIB_FOUND AND THREADS_FOUND) - OPTION (MSGPACK_BUILD_TESTS "Build msgpack tests." ON) + OPTION (MSGPACK_BUILD_TESTS "Build msgpack tests." ON) ENDIF () OPTION (MSGPACK_ENABLE_CXX "Enable C++ interface." ON) @@ -26,168 +56,198 @@ int atomic_sub(int i) { return __gnu_cxx::__exchange_and_add(&i, -1) - 1; } int atomic_add(int i) { return __gnu_cxx::__exchange_and_add(&i, 1) + 1; } int main(int argc, char * argv[]) { - atomic_sub(1); - atomic_add(1); + atomic_sub(1); + atomic_add(1); } " MSGPACK_ENABLE_GCC_CXX_ATOMIC) -IF (MSGPACK_ENABLE_CXX) - LIST (APPEND msgpack_SOURCES - src/object.cpp - ) -ENDIF () - IF (MSGPACK_ENABLE_GCC_CXX_ATOMIC) - LIST (APPEND msgpack_SOURCES - src/gcc_atomic.cpp - ) + LIST (APPEND msgpack_SOURCES + src/gcc_atomic.cpp + ) ENDIF () LIST (APPEND msgpack_SOURCES - src/unpack.c - src/objectc.c - src/version.c - src/vrefbuffer.c - src/zone.c + src/unpack.c + src/objectc.c + src/version.c + src/vrefbuffer.c + src/zone.c ) LIST (APPEND msgpack_HEADERS - src/msgpack/pack_define.h - src/msgpack/pack_template.h - src/msgpack/unpack_define.h - src/msgpack/unpack_template.h - src/msgpack/sysdep.h - src/msgpack/sbuffer.h - src/msgpack/version.h - src/msgpack/vrefbuffer.h - src/msgpack/zbuffer.h - src/msgpack/fbuffer.h - src/msgpack/pack.h - src/msgpack/unpack.h - src/msgpack/object.h - src/msgpack/zone.h + include/msgpack/pack_define.h + include/msgpack/pack_template.h + include/msgpack/unpack_define.h + include/msgpack/unpack_template.h + include/msgpack/util.h + include/msgpack/sysdep.h + include/msgpack/sbuffer.h + include/msgpack/version.h + include/msgpack/vrefbuffer.h + include/msgpack/zbuffer.h + include/msgpack/fbuffer.h + include/msgpack/pack.h + include/msgpack/unpack.h + include/msgpack/object.h + include/msgpack/zone.h ) IF (MSGPACK_ENABLE_CXX) - LIST (APPEND msgpack_HEADERS - src/msgpack.hpp - src/msgpack/sbuffer.hpp - src/msgpack/vrefbuffer.hpp - src/msgpack/zbuffer.hpp - src/msgpack/fbuffer.hpp - src/msgpack/pack.hpp - src/msgpack/unpack.hpp - src/msgpack/object.hpp - src/msgpack/zone.hpp - src/msgpack/type.hpp - src/msgpack/type/bool.hpp - src/msgpack/type/deque.hpp - src/msgpack/type/float.hpp - src/msgpack/type/fixint.hpp - src/msgpack/type/int.hpp - src/msgpack/type/list.hpp - src/msgpack/type/map.hpp - src/msgpack/type/nil.hpp - src/msgpack/type/pair.hpp - src/msgpack/type/raw.hpp - src/msgpack/type/set.hpp - src/msgpack/type/string.hpp - src/msgpack/type/vector.hpp - src/msgpack/type/tuple.hpp - src/msgpack/type/define.hpp - src/msgpack/type/tr1/unordered_map.hpp - src/msgpack/type/tr1/unordered_set.hpp - ) + LIST (APPEND msgpack_HEADERS + include/msgpack.hpp + include/msgpack_fwd.hpp + include/msgpack/adaptor/bool.hpp + include/msgpack/adaptor/bool_fwd.hpp + include/msgpack/adaptor/char_ptr.hpp + include/msgpack/adaptor/char_ptr_fwd.hpp + include/msgpack/adaptor/cpp11/array.hpp + include/msgpack/adaptor/cpp11/array_fwd.hpp + include/msgpack/adaptor/cpp11/array_char.hpp + include/msgpack/adaptor/cpp11/array_char_fwd.hpp + include/msgpack/adaptor/cpp11/forward_list.hpp + include/msgpack/adaptor/cpp11/forward_list_fwd.hpp + include/msgpack/adaptor/cpp11/tuple.hpp + include/msgpack/adaptor/cpp11/tuple_fwd.hpp + include/msgpack/adaptor/define.hpp + include/msgpack/adaptor/deque.hpp + include/msgpack/adaptor/deque_fwd.hpp + include/msgpack/adaptor/detail/cpp03_define.hpp + include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp + include/msgpack/adaptor/detail/cpp03_msgpack_tuple_fwd.hpp + include/msgpack/adaptor/detail/cpp11_define.hpp + include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp + include/msgpack/adaptor/detail/cpp11_msgpack_tuple_fwd.hpp + include/msgpack/adaptor/fixint.hpp + include/msgpack/adaptor/fixint_fwd.hpp + include/msgpack/adaptor/float.hpp + include/msgpack/adaptor/float_fwd.hpp + include/msgpack/adaptor/int.hpp + include/msgpack/adaptor/int_fwd.hpp + include/msgpack/adaptor/list.hpp + include/msgpack/adaptor/list_fwd.hpp + include/msgpack/adaptor/map.hpp + include/msgpack/adaptor/map_fwd.hpp + include/msgpack/adaptor/msgpack_tuple.hpp + include/msgpack/adaptor/msgpack_tuple_fwd.hpp + include/msgpack/adaptor/nil.hpp + include/msgpack/adaptor/nil_fwd.hpp + include/msgpack/adaptor/pair.hpp + include/msgpack/adaptor/pair_fwd.hpp + include/msgpack/adaptor/raw.hpp + include/msgpack/adaptor/raw_fwd.hpp + include/msgpack/adaptor/set.hpp + include/msgpack/adaptor/set_fwd.hpp + include/msgpack/adaptor/string.hpp + include/msgpack/adaptor/string_fwd.hpp + include/msgpack/adaptor/tr1/unordered_map.hpp + include/msgpack/adaptor/tr1/unordered_map_fwd.hpp + include/msgpack/adaptor/tr1/unordered_set.hpp + include/msgpack/adaptor/tr1/unordered_set_fwd.hpp + include/msgpack/adaptor/vector.hpp + include/msgpack/adaptor/vector_fwd.hpp + include/msgpack/adaptor/vector_char.hpp + include/msgpack/adaptor/vector_char_fwd.hpp + include/msgpack/cpp_config.hpp + include/msgpack/detail/cpp03_zone.hpp + include/msgpack/detail/cpp11_zone.hpp + include/msgpack/fbuffer.hpp + include/msgpack/object.hpp + include/msgpack/object_fwd.hpp + include/msgpack/pack.hpp + include/msgpack/sbuffer.hpp + include/msgpack/type.hpp + include/msgpack/unpack.hpp + include/msgpack/version.hpp + include/msgpack/versioning.hpp + include/msgpack/vrefbuffer.hpp + include/msgpack/zbuffer.hpp + include/msgpack/zone.hpp + ) ENDIF () EXECUTE_PROCESS ( - COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/src/msgpack + COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/src/msgpack ) CONFIGURE_FILE ( - src/msgpack/version.h.in - ${CMAKE_CURRENT_BINARY_DIR}/src/msgpack/version.h -) - -CONFIGURE_FILE ( - msgpack.pc.in - msgpack.pc - @ONLY + msgpack.pc.in + msgpack.pc + @ONLY ) INCLUDE_DIRECTORIES ( - ./ - src/ - src/msgpack/ - ${CMAKE_CURRENT_BINARY_DIR}/src/ - ${CMAKE_CURRENT_BINARY_DIR}/src/msgpack/ + ./ + include/ + ${CMAKE_CURRENT_BINARY_DIR}/include/ ) ADD_LIBRARY (msgpack SHARED - ${msgpack_SOURCES} - ${msgpack_HEADERS} + ${msgpack_SOURCES} + ${msgpack_HEADERS} ) ADD_LIBRARY (msgpack-static STATIC - ${msgpack_SOURCES} - ${msgpack_HEADERS} + ${msgpack_SOURCES} + ${msgpack_HEADERS} ) SET_TARGET_PROPERTIES (msgpack-static PROPERTIES OUTPUT_NAME "msgpack") SET_TARGET_PROPERTIES (msgpack PROPERTIES IMPORT_SUFFIX "_import.lib") -SET_TARGET_PROPERTIES (msgpack PROPERTIES SOVERSION 3 VERSION 3.0.0) +SET_TARGET_PROPERTIES (msgpack PROPERTIES SOVERSION 3 VERSION 4.0.0) IF (MSGPACK_BUILD_TESTS) - ENABLE_TESTING () - ADD_SUBDIRECTORY (test) + ENABLE_TESTING () + SET(CTEST_MEMORYCHECK_COMMAND "/usr/bin/valgrind") + INCLUDE(Dart) + SET(MEMORYCHECK_COMMAND_OPTIONS "--leak-check=full --error-exitcode=1") + ADD_SUBDIRECTORY (test) ENDIF () IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") - SET_PROPERTY (TARGET msgpack APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -g -O3 -DPIC") - SET_PROPERTY (TARGET msgpack-static APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -g -O3" ) + SET_PROPERTY (TARGET msgpack APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -g -O3 -DPIC") + SET_PROPERTY (TARGET msgpack-static APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -g -O3" ) ENDIF () IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") - IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]") - STRING(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") - ELSE () - SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4") - ENDIF () + IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]") + STRING(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") + ELSE () + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4") + ENDIF () ENDIF () IF (NOT DEFINED CMAKE_INSTALL_LIBDIR) - SET(CMAKE_INSTALL_LIBDIR lib) + SET(CMAKE_INSTALL_LIBDIR lib) ENDIF () INSTALL (TARGETS msgpack msgpack-static DESTINATION ${CMAKE_INSTALL_LIBDIR}) -INSTALL (DIRECTORY src/msgpack DESTINATION include) -INSTALL (DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/src/msgpack DESTINATION include) -INSTALL (FILES src/msgpack.h src/msgpack.hpp DESTINATION include) +INSTALL (DIRECTORY include DESTINATION ${CMAKE_INSTALL_PREFIX}) INSTALL (FILES ${CMAKE_CURRENT_BINARY_DIR}/msgpack.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig) # Doxygen FIND_PACKAGE (Doxygen) IF (DOXYGEN_FOUND) - ADD_CUSTOM_TARGET ( - doxygen_c - COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c - COMMAND ${CMAKE_COMMAND} -E echo "FILE_PATTERNS = *.h" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c - COMMAND ${CMAKE_COMMAND} -E echo "OUTPUT_DIRECTORY = doc_c" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c - COMMAND ${CMAKE_COMMAND} -E echo "PROJECT_NAME = \"MessagePack for C\"" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c - COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c - VERBATIM - ) - ADD_CUSTOM_TARGET ( - doxygen_cpp - COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp - COMMAND ${CMAKE_COMMAND} -E echo "FILE_PATTERNS = *.hpp" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp - COMMAND ${CMAKE_COMMAND} -E echo "OUTPUT_DIRECTORY = doc_cpp" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp - COMMAND ${CMAKE_COMMAND} -E echo "PROJECT_NAME = \"MessagePack for C++\"" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp - COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp - VERBATIM - ) - ADD_CUSTOM_TARGET ( - doxygen - DEPENDS doxygen_c doxygen_cpp - ) + ADD_CUSTOM_TARGET ( + doxygen_c + COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c + COMMAND ${CMAKE_COMMAND} -E echo "FILE_PATTERNS = *.h" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c + COMMAND ${CMAKE_COMMAND} -E echo "OUTPUT_DIRECTORY = doc_c" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c + COMMAND ${CMAKE_COMMAND} -E echo "PROJECT_NAME = \"MessagePack for C\"" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c + COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c + VERBATIM + ) + ADD_CUSTOM_TARGET ( + doxygen_cpp + COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp + COMMAND ${CMAKE_COMMAND} -E echo "FILE_PATTERNS = *.hpp" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp + COMMAND ${CMAKE_COMMAND} -E echo "OUTPUT_DIRECTORY = doc_cpp" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp + COMMAND ${CMAKE_COMMAND} -E echo "PROJECT_NAME = \"MessagePack for C++\"" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp + COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp + VERBATIM + ) + ADD_CUSTOM_TARGET ( + doxygen + DEPENDS doxygen_c doxygen_cpp + ) ENDIF () diff --git a/README.md b/README.md index 9b07ecf7..a1a55fae 100644 --- a/README.md +++ b/README.md @@ -10,7 +10,7 @@ MessagePack is an efficient binary serialization format. It lets you exchange da ## License -Msgpack is Copyright (C) 2008-2010 FURUHASHI Sadayuki and licensed under the Apache License, Version 2.0 (the "License"). For details see the `COPYING` file in this directory. +Msgpack is Copyright (C) 2008-2014 FURUHASHI Sadayuki and licensed under the Apache License, Version 2.0 (the "License"). For details see the `COPYING` file in this directory. ## Contributing @@ -20,10 +20,23 @@ The source for msgpack-c is held at [msgpack-c](https://github.com/msgpack/msgpa To report an issue, use the [msgpack-c issue tracker](https://github.com/msgpack/msgpack-c/issues) at github.com. ## Version +<<<<<<< HEAD 0.5.9 [![Build Status](https://travis-ci.org/msgpack/msgpack-c.svg?branch=master)](https://travis-ci.org/msgpack/msgpack-c) +======= +0.6.0 [![Build Status](https://travis-ci.org/msgpack/msgpack-c.svg?branch=poc/0.6)](https://travis-ci.org/msgpack/msgpack-c) +>>>>>>> 466986b5190ae8e03065e7b614702ec2f43dce1c ## Using Msgpack +### Header only library for C++ +When you use msgpack on C++03 and C++11, you just add msgpack-c/include to your include path. You don't need to link any msgpack libraries. + +e.g.) + + g++ -I msgpack-c/include your_source_file.cpp + +If you want to use C version of msgpack, you need to build it. You can also install C and C++ version of msgpack. + ### Building and Installing #### Install from git repository @@ -31,131 +44,117 @@ To report an issue, use the [msgpack-c issue tracker](https://github.com/msgpack ##### Using autotools You will need gcc (4.1.0 or higher), autotools. -``` -$ git clone https://github.com/msgpack/msgpack-c.git -$ cd msgpack-c -$ ./bootstrap -$ ./configure -$ make -$ sudo make install -``` +For C: +C++03 and C: + + $ git clone https://github.com/redboltz/msgpack-c/tree/cxx_separate + $ cd msgpack-c + $ ./bootstrap + $ ./configure + $ make + $ sudo make install + +For C++11: + + $ git clone https://github.com/msgpack/msgpack-c.git + $ cd msgpack-c + $ ./bootstrap + $ ./configure CXXFLAGS="-std=c++11" + $ make + $ sudo make install + +You need the compiler that fully supports C++11. ##### Using cmake + +###### CUI + You will need gcc (4.1.0 or higher), cmake. -``` -$ git clone https://github.com/msgpack/msgpack-c.git -$ cd msgpack-c -$ cmake . -$ make -``` + $ git clone https://github.com/msgpack/msgpack-c.git + $ cd msgpack-c + $ cmake . + $ make + $ sudo make install -#### Install from package +If you want to setup C++11 version of msgpack, execute the following command: -##### UNIX-like platform with ./configure + $ git clone https://github.com/msgpack/msgpack-c.git + $ cd msgpack-c + $ cmake -DMSGPACK_CXX11=ON . + $ sudo make install -On typical UNIX-like platforms, download source package from [Releases](https://github.com/msgpack/msgpack-c/releases) and run `./configure && make && make install`. Example: +You need the compiler that fully supports C++11. -``` -$ wget https://github.com/msgpack/msgpack-c/releases/download/cpp-0.5.9/msgpack-0.5.9.tar.gz -$ tar zxvf msgpack-0.5.9.tar.gz -$ cd msgpack-0.5.9 -$ ./configure -$ make -$ sudo make install -``` - -##### FreeBSD with Ports Collection - -On FreeBSD, you can use Ports Collection. Install [net/msgpack](http://www.freebsd.org/cgi/cvsweb.cgi/ports/devel/msgpack/) package. - -##### Gentoo Linux with Portage - -On Gentoo Linux, you can use emerge. Install [dev-libs/msgpack](http://gentoo-portage.com/dev-libs/msgpack) package. - -##### Mac OS X with MacPorts - -On Mac OS X, you can install MessagePack for C using MacPorts. - -``` -$ sudo port install msgpack -``` - -You might need to run `sudo port selfupdate` before installing to update the package repository. - -You can also install via Homebrew. - -``` -$ sudo brew install msgpack -``` - - -##### Windows +##### GUI on Windows Clone msgpack-c git repository. -``` -$ git clone https://github.com/msgpack/msgpack-c.git -``` + $ git clone https://github.com/msgpack/msgpack-c.git or using GUI git client. e.g.) tortoise git https://code.google.com/p/tortoisegit/ -Launch cmake GUI client. http://www.cmake.org/cmake/resources/software.html +1. Launch cmake GUI client. http://www.cmake.org/cmake/resources/software.html -Set 'Where is the source code:' text box and 'Where to build the binaries:' text box. +1. Set 'Where is the source code:' text box and 'Where to build the binaries:' text box. -Click 'Configure' button. +1. Click 'Configure' button. -Choose your Visual Studio version. +1. Choose your Visual Studio version. -Click 'Generate' button. +1. Click 'Generate' button. -Open the created msgpack.sln on Visual Studio. +1. Open the created msgpack.sln on Visual Studio. -Build all. +1. Build all. -### Linking with an Application -Include `msgpack.hpp` (or `msgpack.h` for C) in your application and link with libmsgpack. Here is a typical gcc link command: - - g++ myapp.cpp -lmsgpack -o myapp +<<<<<<< HEAD +or using GUI git client. +======= +#### Install from package +>>>>>>> 466986b5190ae8e03065e7b614702ec2f43dce1c +Install from package for this branch (poc/0.6) is not supported yet. ### Code Example -```CPP -#include -#include -#include -#include -int main() { - // This is target object. - std::vector target; - target.push_back("Hello,"); - target.push_back("World!"); + #include + #include + #include + #include - // Serialize it. - msgpack::sbuffer sbuf; // simple buffer - msgpack::pack(&sbuf, target); + int main() { + // This is target object. + std::vector target; + target.push_back("Hello,"); + target.push_back("World!"); - // Deserialize the serialized data. - msgpack::unpacked msg; // includes memory pool and deserialized object - msgpack::unpack(&msg, sbuf.data(), sbuf.size()); - msgpack::object obj = msg.get(); + // Serialize it. + msgpack::sbuffer sbuf; // simple buffer + msgpack::pack(&sbuf, target); - // Print the deserialized object to stdout. - std::cout << obj << std::endl; // ["Hello," "World!"] + // Deserialize the serialized data. + msgpack::unpacked msg; // includes memory pool and deserialized object + msgpack::unpack(msg, sbuf.data(), sbuf.size()); + msgpack::object obj = msg.get(); - // Convert the deserialized object to staticaly typed object. - std::vector result; - obj.convert(&result); + // Print the deserialized object to stdout. + std::cout << obj << std::endl; // ["Hello," "World!"] - // If the type is mismatched, it throws msgpack::type_error. - obj.as(); // type is mismatched, msgpack::type_error is thrown -} -``` -### Quickstart Guides + // Convert the deserialized object to staticaly typed object. + std::vector result; + obj.convert(&result); + + // If the type is mismatched, it throws msgpack::type_error. + obj.as(); // type is mismatched, msgpack::type_error is thrown + } + +### Documents + +You can get addtional information on the wiki: + +https://github.com/msgpack/msgpack-c/wiki/cpp_overview -For more detailed examples see [QuickStart for C](QUICKSTART-C.md) and [QuickStart for C++](QUICKSTART-CPP.md). diff --git a/ci/build_autotools.sh b/ci/build_autotools.sh index a616a0da..a5ac75fd 100755 --- a/ci/build_autotools.sh +++ b/ci/build_autotools.sh @@ -9,9 +9,19 @@ fi if [ $1 = "cpp11" ] then - ./configure CXXFLAGS="-std=c++11" + if [ $2 = "32" ] + then + ./configure CFLAGS="-m32" CXXFLAGS="-std=c++11 -m32" + else + ./configure CXXFLAGS="-std=c++11" + fi else - ./configure + if [ $2 = "32" ] + then + ./configure CFLAGS="-m32" CXXFLAGS="-m32" + else + ./configure + fi fi ret=$? diff --git a/ci/build_cmake.sh b/ci/build_cmake.sh index 24a8afe3..a28780f8 100755 --- a/ci/build_cmake.sh +++ b/ci/build_cmake.sh @@ -1,4 +1,4 @@ -#!/bin/sh +#!/bin/bash mkdir build @@ -18,9 +18,19 @@ fi if [ $1 = "cpp11" ] then - cmake -DMSGPACK_CXX11=ON .. + if [ $2 = "32" ] + then + cmake -DMSGPACK_CXX11=ON -DMSGPACK_32BIT=ON .. + else + cmake -DMSGPACK_CXX11=ON .. + fi else - cmake .. + if [ $2 = "32" ] + then + cmake -DMSGPACK_32BIT=ON .. + else + cmake .. + fi fi ret=$? @@ -53,4 +63,21 @@ then exit $ret fi +if [ $2 != "32" ] +then + ctest -T memcheck | tee memcheck.log + + ret=${PIPESTATUS[0]} + if [ $ret -ne 0 ] + then + exit $ret + fi + cat memcheck.log | grep "Memory Leak" > /dev/null + ret=$? + if [ $ret -eq 0 ] + then + exit 1 + fi +fi + exit 0 diff --git a/configure.in b/configure.in index b22714a8..d53cf534 100644 --- a/configure.in +++ b/configure.in @@ -1,8 +1,7 @@ -AC_INIT(src/object.cpp) +AC_INIT(msgpack, m4_esyscmd([cat include/msgpack/version_master.h | tr -d "\n" | sed -e 's/#define MSGPACK_VERSION_MAJOR\s*\(\w*\)/\1./g' -e 's/#define MSGPACK_VERSION_MINOR\s*\(\w*\)/\1./g' -e 's/#define MSGPACK_VERSION_REVISION\s*\(\w*\)/\1/g'])) AC_CONFIG_AUX_DIR(ac) -AM_INIT_AUTOMAKE(msgpack, 0.5.9) +AM_INIT_AUTOMAKE AC_CONFIG_HEADER(config.h) - AC_SUBST(CFLAGS) CFLAGS="-O3 -Wall $CFLAGS" @@ -85,16 +84,15 @@ fi AM_CONDITIONAL(ENABLE_GCC_CXX_ATOMIC, test "$enable_gcc_cxx_atomic" = "yes") - -major=`echo $VERSION | sed 's/\([[0-9]]*\)\.\([[0-9]]*\).*/\1/'` -minor=`echo $VERSION | sed 's/\([[0-9]]*\)\.\([[0-9]]*\).*/\2/'` +major=`echo $VERSION | sed 's/\([[0-9]]*\)\.\([[0-9]]*\).\([[0-9]]*\).*/\1/'` +minor=`echo $VERSION | sed 's/\([[0-9]]*\)\.\([[0-9]]*\).\([[0-9]]*\).*/\2/'` +revision=`echo $VERSION | sed 's/\([[0-9]]*\)\.\([[0-9]]*\).\([[0-9]]*\).*/\3/'` AC_SUBST(VERSION_MAJOR, $major) AC_SUBST(VERSION_MINOR, $minor) +AC_SUBST(VERSION_REVISION, $revision) AC_OUTPUT([Makefile msgpack.pc src/Makefile - src/msgpack/version.h test/Makefile]) - diff --git a/erb/cpp03_define.hpp.erb b/erb/cpp03_define.hpp.erb new file mode 100644 index 00000000..45a72f93 --- /dev/null +++ b/erb/cpp03_define.hpp.erb @@ -0,0 +1,155 @@ +// +// 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_HPP +#define MSGPACK_CPP03_DEFINE_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/adaptor/msgpack_tuple_fwd.hpp" +#include "msgpack/object_fwd.hpp" + +#define MSGPACK_DEFINE(...) \ + template \ + void msgpack_pack(Packer& pk) const \ + { \ + msgpack::type::make_define(__VA_ARGS__).msgpack_pack(pk); \ + } \ + void msgpack_unpack(msgpack::object const& o) \ + { \ + msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \ + }\ + template \ + void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone& z) const \ + { \ + msgpack::type::make_define(__VA_ARGS__).msgpack_object(o, z); \ + } + +// MSGPACK_ADD_ENUM must be used in the global namespace. +#define MSGPACK_ADD_ENUM(enum) \ + namespace msgpack { \ + MSGPACK_API_VERSION_NAMESPACE(v1) { \ + template <> \ + inline object const& operator>> (object const& o, enum& v) \ + { \ + int tmp; \ + o >> tmp; \ + v = static_cast(tmp); \ + return o; \ + } \ + template <> \ + inline void operator<< (object::with_zone& o, const enum& v) \ + { \ + o << static_cast(v); \ + } \ + namespace detail { \ + template \ + struct packer_serializer { \ + static packer& pack(packer& o, const enum& v) { \ + return o << static_cast(v); \ + } \ + }; \ + } \ + } \ + } + +namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { +namespace type { + + +<% GENERATION_LIMIT = 31 %> +template , typename A<%=i%> = void<%}%>> +struct define; + + +template <> +struct define<> { + typedef define<> value_type; + typedef tuple<> tuple_type; + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(0); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + } + void msgpack_object(msgpack::object* o, msgpack::zone&) const + { + o->type = type::ARRAY; + o->via.array.ptr = nullptr; + o->via.array.size = 0; + } +}; +<%0.upto(GENERATION_LIMIT) {|i|%> +template , typename A<%=j%><%}%>> +struct define, A<%=j%><%}%>> { + typedef define, A<%=j%><%}%>> value_type; + typedef tuple, A<%=j%><%}%>> tuple_type; + define(A0& _a0<%1.upto(i) {|j|%>, A<%=j%>& _a<%=j%><%}%>) : + a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(<%=i+1%>); + <%0.upto(i) {|j|%> + pk.pack(a<%=j%>);<%}%> + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default:<%(i).downto(0) {|j|%> + case <%=j+1%>: ptr[<%=j%>].convert(a<%=j%>);<%}%> + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*<%=i+1%>)); + o->via.array.size = <%=i+1%>; + <%0.upto(i) {|j|%> + o->via.array.ptr[<%=j%>] = object(a<%=j%>, z);<%}%> + } + <%0.upto(i) {|j|%> + A<%=j%>& a<%=j%>;<%}%> +}; +<%}%> + +inline define<> make_define() +{ + return define<>(); +} +<%0.upto(GENERATION_LIMIT) {|i|%> +template , typename A<%=j%><%}%>> +define, A<%=j%><%}%>> make_define(A0& a0<%1.upto(i) {|j|%>, A<%=j%>& a<%=j%><%}%>) +{ + return define, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>); +} +<%}%> + +} // namespace type +} // MSGPACK_API_VERSION_NAMESPACE(v1) +} // namespace msgpack + + +#endif // MSGPACK_CPP03_DEFINE_HPP diff --git a/erb/cpp03_msgpack_tuple.hpp.erb b/erb/cpp03_msgpack_tuple.hpp.erb new file mode 100644 index 00000000..9f3534a8 --- /dev/null +++ b/erb/cpp03_msgpack_tuple.hpp.erb @@ -0,0 +1,216 @@ +// +// 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 "msgpack/versioning.hpp" +#include "msgpack/object.hpp" + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +namespace type { + +// FIXME operator== +// FIXME operator!= +<% GENERATION_LIMIT = 31 %> + +template , typename A<%=i%><%}%>> +struct tuple; + +template +struct tuple_element; + +template +struct const_tuple_element; + +template +struct tuple_type { + typedef T type; + typedef T value_type; + typedef T& reference; + typedef const T& const_reference; + typedef const T& transparent_reference; +}; + +template +struct tuple_type { + typedef T type; + typedef T& value_type; + typedef T& reference; + typedef const T& const_reference; + typedef T& transparent_reference; +}; + +template +struct tuple_type { + typedef T type; + typedef T& value_type; + typedef T& reference; + typedef const T& const_reference; + typedef const T& transparent_reference; +}; + +<%0.upto(GENERATION_LIMIT) {|i|%> +<%0.upto(i) {|j|%> +template , typename A<%=k%><%}%>> +struct tuple_element, A<%=k%><%}%>>, <%=j%>> : tuple_type> { + tuple_element(tuple, A<%=k%> <%}%>>& x) : m_x(x.a<%=j%>) {} + typename tuple_type>::reference get() { return m_x; } + typename tuple_type>::const_reference get() const { return m_x; } +private: + typename tuple_type>::reference m_x; +}; +<%}%> +<%}%> + +<%0.upto(GENERATION_LIMIT) {|i|%> +<%0.upto(i) {|j|%> +template , typename A<%=k%><%}%>> +struct const_tuple_element, A<%=k%><%}%>>, <%=j%>> : tuple_type> { + const_tuple_element(const tuple, A<%=k%><%}%>>& x) : m_x(x.a<%=j%>) {} + typename tuple_type>::const_reference get() const { return m_x; } +private: + typename tuple_type>::const_reference m_x; +}; +<%}%> +<%}%> + +template <> +struct tuple<> { + tuple() {} + tuple(object const& o) { o.convert(*this); } + typedef tuple<> value_type; +}; +<%0.upto(GENERATION_LIMIT) {|i|%> +template , typename A<%=j%><%}%>> +struct tuple, A<%=j%><%}%>> { + typedef tuple, A<%=j%><%}%>> value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0<%1.upto(i) {|j|%>, typename tuple_type>::transparent_reference _a<%=j%><%}%>) : + a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + <%0.upto(i) {|j|%> + A<%=j%> a<%=j%>;<%}%> +}; + +template , typename A<%=j%><%}%>> +inline typename type::tuple_element, A<%=j%><%}%>>, N>::reference get(type::tuple, A<%=j%><%}%>>& t) +{ return t.template get(); } +template , typename A<%=j%><%}%>> +inline typename type::const_tuple_element, A<%=j%><%}%>>, N>::const_reference get(type::tuple, A<%=j%><%}%>> const& t) +{ return t.template get(); } +<%}%> + +inline tuple<> make_tuple() +{ + return tuple<>(); +} +<%0.upto(GENERATION_LIMIT) {|i|%> +template , typename A<%=j%><%}%>> +inline tuple, A<%=j%><%}%>> make_tuple(typename tuple_type::transparent_reference a0<%1.upto(i) {|j|%>, typename tuple_type>::transparent_reference a<%=j%><%}%>) +{ + return tuple, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>); +} +<%}%> + +} // namespace type + +inline object const& operator>> ( + object const& o, + type::tuple<>&) { + if(o.type != type::ARRAY) { throw type_error(); } + return o; +} +<%0.upto(GENERATION_LIMIT) {|i|%> +template , typename A<%=j%><%}%>> +inline object const& operator>> ( + object const& o, + type::tuple, A<%=j%><%}%>>& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < <%=i+1%>) { throw type_error(); } + <%0.upto(i) {|j|%> + o.via.array.ptr[<%=j%>].convert>::type>(v.template get<<%=j%>>());<%}%> + return o; +} +<%}%> + +template +inline const packer& operator<< ( + packer& o, + const type::tuple<>&) { + o.pack_array(0); + return o; +} +<%0.upto(GENERATION_LIMIT) {|i|%> +template , typename A<%=j%><%}%>> +inline const packer& operator<< ( + packer& o, + const type::tuple, A<%=j%><%}%>>& v) { + o.pack_array(<%=i+1%>); + <%0.upto(i) {|j|%> + o.pack(v.template get<<%=j%>>());<%}%> + return o; +} +<%}%> + +inline void operator<< ( + object::with_zone& o, + const type::tuple<>&) { + o.type = type::ARRAY; + o.via.array.ptr = nullptr; + o.via.array.size = 0; +} +<%0.upto(GENERATION_LIMIT) {|i|%> +template , typename A<%=j%><%}%>> +inline void operator<< ( + object::with_zone& o, + const type::tuple, A<%=j%><%}%>>& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*<%=i+1%>)); + o.via.array.size = <%=i+1%>; + <%0.upto(i) {|j|%> + o.via.array.ptr[<%=j%>] = object(v.template get<<%=j%>>(), o.zone);<%}%> +} +<%}%> + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + + +//inline std::ostream& operator<< (std::ostream& o, const msgpack::type::tuple<>& v) { +// return o << "[]"; +//} +//<%0.upto(GENERATION_LIMIT) {|i|%> +//template , typename A<%=j%><%}%>> +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple, A<%=j%><%}%>>& v) { +// return o << "[" +// <%0.upto(i) {|j|%> +// <<<%if j != 0 then%> ", " <<<%end%> v.template get<<%=j%>>()<%}%> +// << "]"; +//} +//<%}%> + +#endif // MSGPACK_CPP03_MSGPACK_TUPLE_HPP diff --git a/erb/cpp03_msgpack_tuple_fwd.hpp.erb b/erb/cpp03_msgpack_tuple_fwd.hpp.erb new file mode 100644 index 00000000..99cefff0 --- /dev/null +++ b/erb/cpp03_msgpack_tuple_fwd.hpp.erb @@ -0,0 +1,125 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_CPP03_MSGPACK_TUPLE_FWD_HPP +#define MSGPACK_CPP03_MSGPACK_TUPLE_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +namespace type { + +// FIXME operator== +// FIXME operator!= +<% GENERATION_LIMIT = 31 %> + +template , typename A<%=i%> = void<%}%>> +struct tuple; + +template +struct tuple_element; + +template +struct const_tuple_element; + +template +struct tuple_type; + +<%0.upto(GENERATION_LIMIT) {|i|%> +<%0.upto(i) {|j|%> +template , typename A<%=k%><%}%>> +struct tuple_element, A<%=k%><%}%>>, <%=j%>>; +<%}%> +<%}%> + +<%0.upto(GENERATION_LIMIT) {|i|%> +<%0.upto(i) {|j|%> +template , typename A<%=k%><%}%>> +struct const_tuple_element, A<%=k%><%}%>>, <%=j%>>; +<%}%> +<%}%> + +template <> +struct tuple<>; +<%0.upto(GENERATION_LIMIT) {|i|%> +template , typename A<%=j%><%}%>> +struct tuple, A<%=j%><%}%>>; + +template , typename A<%=j%><%}%>> +typename type::tuple_element, A<%=j%><%}%>>, N>::reference get(type::tuple, A<%=j%><%}%>>& t); +template , typename A<%=j%><%}%>> +typename type::const_tuple_element, A<%=j%><%}%>>, N>::const_reference get(type::tuple, A<%=j%><%}%>> const& t); +<%}%> + +tuple<> make_tuple(); +<%0.upto(GENERATION_LIMIT) {|i|%> +template , typename A<%=j%><%}%>> +tuple, A<%=j%><%}%>> make_tuple(typename tuple_type::transparent_reference a0<%1.upto(i) {|j|%>, typename tuple_type>::transparent_reference a<%=j%><%}%>); +<%}%> + +} // namespace type + +object const& operator>> ( + object const& o, + type::tuple<>&); + +<%0.upto(GENERATION_LIMIT) {|i|%> +template , typename A<%=j%><%}%>> +object const& operator>> ( + object const& o, + type::tuple, A<%=j%><%}%>>& v); +<%}%> + +template +const packer& operator<< ( + packer& o, + const type::tuple<>&); + +<%0.upto(GENERATION_LIMIT) {|i|%> +template , typename A<%=j%><%}%>> +const packer& operator<< ( + packer& o, + const type::tuple, A<%=j%><%}%>>& v); +<%}%> + +void operator<< ( + object::with_zone& o, + const type::tuple<>&); +<%0.upto(GENERATION_LIMIT) {|i|%> +template , typename A<%=j%><%}%>> +void operator<< ( + object::with_zone& o, + const type::tuple, A<%=j%><%}%>>& v); +<%}%> + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + + +//std::ostream& operator<< (std::ostream& o, const msgpack::type::tuple<>& v); +//<%0.upto(GENERATION_LIMIT) {|i|%> +//template , typename A<%=j%><%}%>> +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple, A<%=j%><%}%>>& v); +//<%}%> + +#endif // MSGPACK_CPP03_MSGPACK_TUPLE_FWD_HPP diff --git a/erb/cpp03_zone.hpp.erb b/erb/cpp03_zone.hpp.erb new file mode 100644 index 00000000..9b16bb65 --- /dev/null +++ b/erb/cpp03_zone.hpp.erb @@ -0,0 +1,310 @@ +// +// MessagePack for C++ memory pool +// +// Copyright (C) 2008-2010 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// 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_ZONE_HPP +#define MSGPACK_CPP03_ZONE_HPP + +#include +#include +#include + +#include "msgpack/versioning.hpp" + +#ifndef MSGPACK_ZONE_CHUNK_SIZE +#define MSGPACK_ZONE_CHUNK_SIZE 8192 +#endif + +#ifndef MSGPACK_ZONE_ALIGN +#define MSGPACK_ZONE_ALIGN sizeof(int) +#endif + +<% GENERATION_LIMIT = 15 %> +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +class zone { + struct finalizer { + finalizer(void (*func)(void*), void* data):m_func(func), m_data(data) {} + void operator()() { m_func(m_data); } + void (*m_func)(void*); + void* m_data; + }; + struct finalizer_array { + finalizer_array():m_tail(nullptr), m_end(nullptr), m_array(nullptr) {} + void call() { + finalizer* fin = m_tail; + for(; fin != m_array; --fin) (*(fin-1))(); + } + ~finalizer_array() { + call(); + ::free(m_array); + } + void clear() { + call(); + m_tail = m_array; + } + void push(void (*func)(void* data), void* data) + { + finalizer* fin = m_tail; + + if(fin == m_end) { + push_expand(func, data); + return; + } + + fin->m_func = func; + fin->m_data = data; + + ++m_tail; + } + void push_expand(void (*func)(void*), void* data) { + const size_t nused = m_end - m_array; + size_t nnext; + if(nused == 0) { + nnext = (sizeof(finalizer) < 72/2) ? + 72 / sizeof(finalizer) : 8; + } else { + nnext = nused * 2; + } + finalizer* tmp = + static_cast(::realloc(m_array, sizeof(finalizer) * nnext)); + if(!tmp) { + throw std::bad_alloc(); + } + m_array = tmp; + m_end = tmp + nnext; + m_tail = tmp + nused; + new (m_tail) finalizer(func, data); + + ++m_tail; + } + finalizer* m_tail; + finalizer* m_end; + finalizer* m_array; + }; + struct chunk { + chunk* m_next; + }; + struct chunk_list { + chunk_list(size_t chunk_size) + { + chunk* c = static_cast(::malloc(sizeof(chunk) + chunk_size)); + if(!c) { + throw std::bad_alloc(); + } + + m_head = c; + m_free = chunk_size; + m_ptr = reinterpret_cast(c) + sizeof(chunk); + c->m_next = nullptr; + } + ~chunk_list() + { + chunk* c = m_head; + while(c) { + chunk* n = c->m_next; + ::free(c); + c = n; + } + } + void clear(size_t chunk_size) + { + chunk* c = m_head; + while(true) { + chunk* n = c->m_next; + if(n) { + ::free(c); + c = n; + } else { + break; + } + } + m_head->m_next = nullptr; + m_free = chunk_size; + m_ptr = reinterpret_cast(m_head) + sizeof(chunk); + } + size_t m_free; + char* m_ptr; + chunk* m_head; + }; + size_t m_chunk_size; + chunk_list m_chunk_list; + finalizer_array m_finalizer_array; + +public: + zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE) /* throw() */; + +public: + void* allocate_align(size_t size); + void* allocate_no_align(size_t size); + + void push_finalizer(void (*func)(void*), void* data); + + template + void push_finalizer(msgpack::unique_ptr obj); + + void clear(); + + void swap(zone& o); + static void* operator new(std::size_t size) throw(std::bad_alloc) + { + void* p = ::malloc(size); + if (!p) throw std::bad_alloc(); + return p; + } + static void operator delete(void *p) throw() + { + ::free(p); + } + static void* operator new(std::size_t size, void* place) throw() + { + return ::operator new(size, place); + } + static void operator delete(void* p, void* place) throw() + { + ::operator delete(p, place); + } + <%0.upto(GENERATION_LIMIT) {|i|%> + template , typename A<%=j%><%}%>> + T* allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>); + <%}%> + +private: + void undo_allocate(size_t size); + + template + static void object_destruct(void* obj); + + template + static void object_delete(void* obj); + + void* allocate_expand(size_t size); +}; + +inline zone::zone(size_t chunk_size) /* throw() */ :m_chunk_size(chunk_size), m_chunk_list(m_chunk_size) +{ +} + +inline void* zone::allocate_align(size_t size) +{ + return allocate_no_align( + ((size)+((MSGPACK_ZONE_ALIGN)-1)) & ~((MSGPACK_ZONE_ALIGN)-1)); +} + +inline void* zone::allocate_no_align(size_t size) +{ + if(m_chunk_list.m_free < size) { + return allocate_expand(size); + } + + char* ptr = m_chunk_list.m_ptr; + m_chunk_list.m_free -= size; + m_chunk_list.m_ptr += size; + + return ptr; +} + +inline void* zone::allocate_expand(size_t size) +{ + chunk_list* const cl = &m_chunk_list; + + size_t sz = m_chunk_size; + + while(sz < size) { + sz *= 2; + } + + chunk* c = static_cast(::malloc(sizeof(chunk) + sz)); + if (!c) throw std::bad_alloc(); + + char* ptr = reinterpret_cast(c) + sizeof(chunk); + + c->m_next = cl->m_head; + cl->m_head = c; + cl->m_free = sz - size; + cl->m_ptr = ptr + size; + + return ptr; +} + +inline void zone::push_finalizer(void (*func)(void*), void* data) +{ + m_finalizer_array.push(func, data); +} + +template +inline void zone::push_finalizer(msgpack::unique_ptr obj) +{ + m_finalizer_array.push(&zone::object_delete, obj.release()); +} + +inline void zone::clear() +{ + m_finalizer_array.clear(); + m_chunk_list.clear(m_chunk_size); +} + +inline void zone::swap(zone& o) +{ + std::swap(*this, o); +} + +template +void zone::object_destruct(void* obj) +{ + static_cast(obj)->~T(); +} + +template +void zone::object_delete(void* obj) +{ + delete static_cast(obj); +} + +inline void zone::undo_allocate(size_t size) +{ + m_chunk_list.m_ptr -= size; + m_chunk_list.m_free += size; +} + +<%0.upto(GENERATION_LIMIT) {|i|%> +template , typename A<%=j%><%}%>> +T* zone::allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>) +{ + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destruct, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(<%=(1..i).map{|j|"a#{j}"}.join(', ')%>); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } +} +<%}%> + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_CPP03_ZONE_HPP diff --git a/example/custom.cc b/example/custom.cc index 835ebed9..63cc4f4b 100644 --- a/example/custom.cc +++ b/example/custom.cc @@ -4,55 +4,55 @@ class old_class { public: - old_class() : value("default") { } + old_class() : value("default") { } - std::string value; + std::string value; - MSGPACK_DEFINE(value); + MSGPACK_DEFINE(value); }; class new_class { public: - new_class() : value("default"), flag(-1) { } + new_class() : value("default"), flag(-1) { } - std::string value; - int flag; + std::string value; + int flag; - MSGPACK_DEFINE(value, flag); + MSGPACK_DEFINE(value, flag); }; int main(void) { - { - old_class oc; - new_class nc; + { + old_class oc; + new_class nc; - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, oc); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, oc); - msgpack::zone zone; - msgpack::object obj; - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &zone, &obj); + msgpack::unpacked result; + msgpack::unpack(result, sbuf.data(), sbuf.size()); + msgpack::object obj = result.get(); - obj.convert(&nc); + obj.convert(&nc); - std::cout << obj << " value=" << nc.value << " flag=" << nc.flag << std::endl; - } + std::cout << obj << " value=" << nc.value << " flag=" << nc.flag << std::endl; + } - { - new_class nc; - old_class oc; + { + new_class nc; + old_class oc; - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, nc); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, nc); - msgpack::zone zone; - msgpack::object obj; - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &zone, &obj); + msgpack::unpacked result; + msgpack::unpack(result, sbuf.data(), sbuf.size()); + msgpack::object obj = result.get(); - obj.convert(&oc); + obj.convert(&oc); - std::cout << obj << " value=" << oc.value << std::endl; - } + std::cout << obj << " value=" << oc.value << std::endl; + } } diff --git a/example/lib_buffer_unpack.c b/example/lib_buffer_unpack.c new file mode 100644 index 00000000..1d6fe39e --- /dev/null +++ b/example/lib_buffer_unpack.c @@ -0,0 +1,119 @@ +#include +#include +#include + + +typedef struct receiver { + msgpack_sbuffer sbuf; + size_t rest; +} receiver; + +receiver r; + +size_t receiver_init(receiver *r) { + msgpack_packer pk; + + msgpack_sbuffer_init(&r->sbuf); + msgpack_packer_init(&pk, &r->sbuf, msgpack_sbuffer_write); + /* 1st object */ + msgpack_pack_array(&pk, 3); + msgpack_pack_int(&pk, 1); + msgpack_pack_true(&pk); + msgpack_pack_str(&pk, 7); + msgpack_pack_str_body(&pk, "example", 7); + /* 2nd object */ + msgpack_pack_str(&pk, 6); + msgpack_pack_str_body(&pk, "second", 6); + /* 3rd object */ + msgpack_pack_array(&pk, 2); + msgpack_pack_int(&pk, 42); + msgpack_pack_false(&pk); + r->rest = r->sbuf.size; +} + +size_t receiver_recv(receiver *r, char* buf, size_t try_size) { + size_t off = r->sbuf.size - r->rest; + + size_t actual_size = try_size; + if (actual_size > r->rest) actual_size = r->rest; + + memcpy(buf, r->sbuf.data + off, actual_size); + r->rest -= actual_size; + + return actual_size; +} + +#define EACH_RECV_SIZE 4 + +void unpack(receiver* r) { + /* buf is allocated by unpacker. */ + msgpack_unpacker* unp = msgpack_unpacker_new(100); + msgpack_unpacked result; + msgpack_unpack_return ret; + char* buf; + size_t recv_len; + + msgpack_unpacked_init(&result); + if (msgpack_unpacker_buffer_capacity(unp) < EACH_RECV_SIZE) { + bool expanded = msgpack_unpacker_reserve_buffer(unp, 100); + assert(expanded); + } + buf = msgpack_unpacker_buffer(unp); + + recv_len = receiver_recv(r, buf, EACH_RECV_SIZE); + msgpack_unpacker_buffer_consumed(unp, recv_len); + + + int recv_count = 0; + while (recv_len > 0) { + int i = 0; + printf("receive count: %d %d bytes received.:\n", recv_count++, recv_len); + ret = msgpack_unpacker_next(unp, &result); + while (ret == MSGPACK_UNPACK_SUCCESS) { + msgpack_object obj = result.data; + + /* Use obj. */ + printf("Object no %d:\n", i++); + msgpack_object_print(stdout, obj); + printf("\n"); + /* If you want to allocate something on the zone, you can use zone. */ + /* msgpack_zone* zone = result.zone; */ + /* The lifetime of the obj and the zone, */ + + ret = msgpack_unpacker_next(unp, &result); + } + if (ret == MSGPACK_UNPACK_PARSE_ERROR) { + printf("The data in the buf is invalid format.\n"); + msgpack_unpacked_destroy(&result); + return; + } + if (msgpack_unpacker_buffer_capacity(unp) < EACH_RECV_SIZE) { + bool expanded = msgpack_unpacker_reserve_buffer(unp, 100); + assert(expanded); + } + buf = msgpack_unpacker_buffer(unp); + recv_len = receiver_recv(r, buf, 4); + msgpack_unpacker_buffer_consumed(unp, recv_len); + } + msgpack_unpacked_destroy(&result); +} + +int main(void) { + receiver r; + receiver_init(&r); + + unpack(&r); + + return 0; +} + +/* Output */ + +/* +Object no 1: +[1, true, "example"] +Object no 2: +"second" +Object no 3: +[42, false] +*/ diff --git a/example/protocol.cc b/example/protocol.cc index ddf785a7..5e08b291 100644 --- a/example/protocol.cc +++ b/example/protocol.cc @@ -4,83 +4,84 @@ #include namespace myprotocol { - using namespace msgpack::type; - using msgpack::define; + using namespace msgpack::type; + using msgpack::define; - struct Get : define< tuple > { - Get() { } - Get(uint32_t f, const std::string& k) : - define_type(msgpack_type(f, k)) { } - uint32_t& flags() { return get<0>(); } - std::string& key() { return get<1>(); } - }; + struct Get : define< tuple > { + Get() { } + Get(uint32_t f, const std::string& k) : + define_type(msgpack_type(f, k)) { } + uint32_t& flags() { return msgpack::type::get<0>(*this); } + std::string& key() { return msgpack::type::get<1>(*this); } + }; - struct Put : define< tuple > { - Put() { } - Put(uint32_t f, const std::string& k, const char* valref, uint32_t vallen) : - define_type(msgpack_type( f, k, raw_ref(valref,vallen) )) { } - uint32_t& flags() { return get<0>(); } - std::string& key() { return get<1>(); } - raw_ref& value() { return get<2>(); } - }; + struct Put : define< tuple > { + Put() { } + Put(uint32_t f, const std::string& k, const char* valref, uint32_t vallen) : + define_type(msgpack_type( f, k, raw_ref(valref,vallen) )) { } + uint32_t& flags() { return msgpack::type::get<0>(*this); } + std::string& key() { return msgpack::type::get<1>(*this); } + raw_ref& value() { return msgpack::type::get<2>(*this); } + }; - struct MultiGet : define< std::vector > { - }; + struct MultiGet : define< std::vector > { + }; } int main(void) { - // send Get request - std::stringstream stream; - { - myprotocol::Get req; - req.flags() = 0; - req.key() = "key0"; - msgpack::pack(stream, req); - } + // send Get request + std::stringstream stream; + { + myprotocol::Get req; + req.flags() = 0; + req.key() = "key0"; + msgpack::pack(stream, req); + } - stream.seekg(0); + stream.seekg(0); - // receive Get request - { - std::string buffer(stream.str()); + // receive Get request + { + std::string buffer(stream.str()); - msgpack::zone mempool; - msgpack::object o = - msgpack::unpack(buffer.data(), buffer.size(), mempool); + msgpack::unpacked result; + msgpack::unpack(result, buffer.data(), buffer.size()); + msgpack::object o = result.get(); - myprotocol::Get req; - msgpack::convert(req, o); - std::cout << "received: " << o << std::endl; - } + myprotocol::Get req; + o.convert(req); + std::cout << "received: " << o << std::endl; + } - stream.str(""); + stream.str(""); - // send MultiGet request - { - myprotocol::MultiGet req; - req.push_back( myprotocol::Get(1, "key1") ); - req.push_back( myprotocol::Get(2, "key2") ); - req.push_back( myprotocol::Get(3, "key3") ); - msgpack::pack(stream, req); - } + // send MultiGet request + { + myprotocol::MultiGet req; + req.push_back( myprotocol::Get(1, "key1") ); + req.push_back( myprotocol::Get(2, "key2") ); + req.push_back( myprotocol::Get(3, "key3") ); + msgpack::pack(stream, req); + } - stream.seekg(0); + stream.seekg(0); - // receive MultiGet request - { - std::string buffer(stream.str()); + // receive MultiGet request + { + std::string buffer(stream.str()); - msgpack::zone mempool; - msgpack::object o = - msgpack::unpack(buffer.data(), buffer.size(), mempool); + msgpack::unpacked result; + msgpack::unpack(result, buffer.data(), buffer.size()); + msgpack::object o = result.get(); - myprotocol::MultiGet req; - msgpack::convert(req, o); - std::cout << "received: " << o << std::endl; - } + + myprotocol::MultiGet req; + o.convert(req); + std::cout << "received: " << o << std::endl; + } } diff --git a/example/simple.c b/example/simple.c index 41d8bb70..39420a80 100644 --- a/example/simple.c +++ b/example/simple.c @@ -3,35 +3,35 @@ int main(void) { - /* msgpack::sbuffer is a simple buffer implementation. */ - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); + /* msgpack::sbuffer is a simple buffer implementation. */ + msgpack_sbuffer sbuf; + msgpack_sbuffer_init(&sbuf); - /* serialize values into the buffer using msgpack_sbuffer_write callback function. */ - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); + /* serialize values into the buffer using msgpack_sbuffer_write callback function. */ + msgpack_packer pk; + msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - msgpack_pack_array(&pk, 3); - msgpack_pack_int(&pk, 1); - msgpack_pack_true(&pk); - msgpack_pack_raw(&pk, 7); - msgpack_pack_raw_body(&pk, "example", 7); + msgpack_pack_array(&pk, 3); + msgpack_pack_int(&pk, 1); + msgpack_pack_true(&pk); + msgpack_pack_str(&pk, 7); + msgpack_pack_str_body(&pk, "example", 7); - /* deserialize the buffer into msgpack_object instance. */ - /* deserialized object is valid during the msgpack_zone instance alive. */ - msgpack_zone mempool; - msgpack_zone_init(&mempool, 2048); + /* deserialize the buffer into msgpack_object instance. */ + /* deserialized object is valid during the msgpack_zone instance alive. */ + msgpack_zone mempool; + msgpack_zone_init(&mempool, 2048); - msgpack_object deserialized; - msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized); + msgpack_object deserialized; + msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized); - /* print the deserialized object. */ - msgpack_object_print(stdout, deserialized); - puts(""); + /* print the deserialized object. */ + msgpack_object_print(stdout, deserialized); + puts(""); - msgpack_zone_destroy(&mempool); - msgpack_sbuffer_destroy(&sbuf); + msgpack_zone_destroy(&mempool); + msgpack_sbuffer_destroy(&sbuf); - return 0; + return 0; } diff --git a/example/simple.cc b/example/simple.cc index 55ecdf92..0dcb9d84 100644 --- a/example/simple.cc +++ b/example/simple.cc @@ -5,33 +5,34 @@ int main(void) { - msgpack::type::tuple src(1, true, "example"); + msgpack::type::tuple src(1, true, "example"); - // serialize the object into the buffer. - // any classes that implements write(const char*,size_t) can be a buffer. - std::stringstream buffer; - msgpack::pack(buffer, src); + // serialize the object into the buffer. + // any classes that implements write(const char*,size_t) can be a buffer. + std::stringstream buffer; + msgpack::pack(buffer, src); - // send the buffer ... - buffer.seekg(0); + // send the buffer ... + buffer.seekg(0); - // deserialize the buffer into msgpack::object instance. - std::string str(buffer.str()); + // deserialize the buffer into msgpack::object instance. + std::string str(buffer.str()); - // deserialized object is valid during the msgpack::zone instance alive. - msgpack::zone mempool; + msgpack::unpacked result; - msgpack::object deserialized; - msgpack::unpack(str.data(), str.size(), NULL, &mempool, &deserialized); + msgpack::unpack(result, str.data(), str.size()); - // msgpack::object supports ostream. - std::cout << deserialized << std::endl; + // deserialized object is valid during the msgpack::unpacked instance alive. + msgpack::object deserialized = result.get(); - // convert msgpack::object instance into the original type. - // if the type is mismatched, it throws msgpack::type_error exception. - msgpack::type::tuple dst; - deserialized.convert(&dst); + // msgpack::object supports ostream. + std::cout << deserialized << std::endl; - return 0; + // convert msgpack::object instance into the original type. + // if the type is mismatched, it throws msgpack::type_error exception. + msgpack::type::tuple dst; + deserialized.convert(&dst); + + return 0; } diff --git a/example/speed_test.cc b/example/speed_test.cc new file mode 100644 index 00000000..d13eb777 --- /dev/null +++ b/example/speed_test.cc @@ -0,0 +1,55 @@ +// g++ -std=c++11 -O3 -g -Ipath_to_msgpack_src -Ipath_to_boost speed_test.cc -Lpath_to_boost_lib -lboost_timer -lboost_system +// export LD_LIBRARY_PATH=path_to_boost_lib + +#include +#include +#include +#include +#include +#include + +void test_map_pack_unpack() { + std::cout << "[TEST][map_pack_unpack]" << std::endl; + // setup + std::cout << "Setting up map data..." << std::endl; + std::map m1; + int const num = 30000000L; + for (int i = 0; i < num; ++i) m1[i] = i; + std::cout << "Start packing..." << std::endl; + std::stringstream buffer; + { + boost::timer::cpu_timer timer; + msgpack::pack(buffer, m1); + std::string result = timer.format(); + std::cout << result << std::endl; + } + std::cout << "Pack finished..." << std::endl; + + buffer.seekg(0); + std::string str(buffer.str()); + + msgpack::unpacked unpacked; + std::cout << "Start unpacking...by void unpack(unpacked& result, const char* data, size_t len)" << std::endl; + { + boost::timer::cpu_timer timer; + msgpack::unpack(unpacked, str.data(), str.size()); + std::string result = timer.format(); + std::cout << result << std::endl; + } + std::cout << "Unpack finished..." << std::endl; + std::map m2; + std::cout << "Start converting..." << std::endl; + { + boost::timer::cpu_timer timer; + unpacked.get().convert(&m2); + std::string result = timer.format(); + std::cout << result << std::endl; + } + std::cout << "Convert finished..." << std::endl; +} + +int main(void) +{ + test_map_pack_unpack(); +} + diff --git a/example/speed_test_nested_array.cc b/example/speed_test_nested_array.cc new file mode 100644 index 00000000..40a87a99 --- /dev/null +++ b/example/speed_test_nested_array.cc @@ -0,0 +1,78 @@ +// g++ -std=c++11 -O3 -g -Ipath_to_msgpack_src -Ipath_to_boost speed_test.cc -Lpath_to_boost_lib -lboost_timer -lboost_system +// export LD_LIBRARY_PATH=path_to_boost_lib + +#include +#include +#include +#include +#include +#include + +template +struct vecvec { + typedef std::vector::type> type; + static void fill(type& v, std::size_t num_of_elems, T const& val) { + for (int elem = 0; elem < num_of_elems; ++elem) { + typename vecvec::type child; + vecvec::fill(child, num_of_elems, val); + v.push_back(child); + } + } +}; + +template +struct vecvec { + typedef std::vector type; + static void fill(type& v, std::size_t num_of_elems, T const& val) { + for (int elem = 0; elem < num_of_elems; ++elem) { + v.push_back(val); + } + } +}; + +void test_array_of_array() { + std::cout << "[TEST][array_of_array]" << std::endl; + // setup + int const depth = 16; + std::cout << "Setting up array data..." << std::endl; + typename vecvec::type v1; + vecvec::fill(v1, 3, 42); + + std::cout << "Start packing..." << std::endl; + std::stringstream buffer; + { + boost::timer::cpu_timer timer; + msgpack::pack(buffer, v1); + std::string result = timer.format(); + std::cout << result << std::endl; + } + std::cout << "Pack finished..." << std::endl; + + buffer.seekg(0); + std::string str(buffer.str()); + + msgpack::unpacked unpacked; + std::cout << "Start unpacking...by void unpack(unpacked& result, const char* data, size_t len)" << std::endl; + { + boost::timer::cpu_timer timer; + msgpack::unpack(unpacked, str.data(), str.size()); + std::string result = timer.format(); + std::cout << result << std::endl; + } + std::cout << "Unpack finished..." << std::endl; + typename vecvec::type v2; + std::cout << "Start converting..." << std::endl; + { + boost::timer::cpu_timer timer; + unpacked.get().convert(&v2); + std::string result = timer.format(); + std::cout << result << std::endl; + } + std::cout << "Convert finished..." << std::endl; +} + +int main(void) +{ + test_array_of_array(); +} + diff --git a/example/speed_test_uint32_array.c b/example/speed_test_uint32_array.c index 9f259082..cc40cc7e 100644 --- a/example/speed_test_uint32_array.c +++ b/example/speed_test_uint32_array.c @@ -3,34 +3,34 @@ void test() { - size_t size = 10000000; - msgpack_sbuffer buf; - msgpack_sbuffer_init(&buf); + size_t size = 10000000; + msgpack_sbuffer buf; + msgpack_sbuffer_init(&buf); - msgpack_packer * pk = msgpack_packer_new(&buf, msgpack_sbuffer_write); + msgpack_packer * pk = msgpack_packer_new(&buf, msgpack_sbuffer_write); - msgpack_pack_array(pk, size); - { - int idx = 0; - for (; idx < size; ++idx) - msgpack_pack_uint32(pk, 1); - } - msgpack_packer_free(pk); + msgpack_pack_array(pk, size); + { + int idx = 0; + for (; idx < size; ++idx) + msgpack_pack_uint32(pk, 1); + } + msgpack_packer_free(pk); - size_t upk_pos = 0; - msgpack_unpacked msg; - msgpack_unpacked_init(&msg); + size_t upk_pos = 0; + msgpack_unpacked msg; + msgpack_unpacked_init(&msg); - while (msgpack_unpack_next(&msg, buf.data, buf.size, &upk_pos)) { - } + while (msgpack_unpack_next(&msg, buf.data, buf.size, &upk_pos)) { + } - msgpack_sbuffer_destroy(&buf); + msgpack_sbuffer_destroy(&buf); } int main(int argc, char **argv) { - int i = 0; - for (; i < 10; ++i) test(); - return 0; + int i = 0; + for (; i < 10; ++i) test(); + return 0; } diff --git a/example/speed_test_uint64_array.c b/example/speed_test_uint64_array.c index e8378dc3..8f3d0dc2 100644 --- a/example/speed_test_uint64_array.c +++ b/example/speed_test_uint64_array.c @@ -3,35 +3,35 @@ void test() { - uint64_t test_u64 = 0xFFF0000000000001LL; - size_t size = 10000000; - msgpack_sbuffer buf; - msgpack_sbuffer_init(&buf); + uint64_t test_u64 = 0xFFF0000000000001LL; + size_t size = 10000000; + msgpack_sbuffer buf; + msgpack_sbuffer_init(&buf); - msgpack_packer * pk = msgpack_packer_new(&buf, msgpack_sbuffer_write); + msgpack_packer * pk = msgpack_packer_new(&buf, msgpack_sbuffer_write); - msgpack_pack_array(pk, size); - { - int idx = 0; - for (; idx < size; ++idx) - msgpack_pack_uint64(pk, test_u64); - } - msgpack_packer_free(pk); + msgpack_pack_array(pk, size); + { + int idx = 0; + for (; idx < size; ++idx) + msgpack_pack_uint64(pk, test_u64); + } + msgpack_packer_free(pk); - size_t upk_pos = 0; - msgpack_unpacked msg; - msgpack_unpacked_init(&msg); + size_t upk_pos = 0; + msgpack_unpacked msg; + msgpack_unpacked_init(&msg); - while (msgpack_unpack_next(&msg, buf.data, buf.size, &upk_pos)) { - } + while (msgpack_unpack_next(&msg, buf.data, buf.size, &upk_pos)) { + } - msgpack_sbuffer_destroy(&buf); + msgpack_sbuffer_destroy(&buf); } int main(int argc, char **argv) { - int i = 0; - for (; i < 10; ++i) test(); - return 0; + int i = 0; + for (; i < 10; ++i) test(); + return 0; } diff --git a/example/stream.cc b/example/stream.cc index 08d72408..326665cf 100644 --- a/example/stream.cc +++ b/example/stream.cc @@ -9,125 +9,125 @@ class Server { public: - Server(int sock) : m_sock(sock) { } + Server(int sock) : m_sock(sock) { } - ~Server() { } + ~Server() { } - typedef std::auto_ptr auto_zone; + typedef msgpack::unique_ptr auto_zone; - void socket_readable() - { - m_pac.reserve_buffer(1024); + void socket_readable() + { + m_pac.reserve_buffer(1024); - ssize_t count = - read(m_sock, m_pac.buffer(), m_pac.buffer_capacity()); + ssize_t count = + read(m_sock, m_pac.buffer(), m_pac.buffer_capacity()); - if(count <= 0) { - if(count == 0) { - throw std::runtime_error("connection closed"); - } - if(errno == EAGAIN || errno == EINTR) { - return; - } - throw std::runtime_error(strerror(errno)); - } + if(count <= 0) { + if(count == 0) { + throw std::runtime_error("connection closed"); + } + if(errno == EAGAIN || errno == EINTR) { + return; + } + throw std::runtime_error(strerror(errno)); + } - m_pac.buffer_consumed(count); + m_pac.buffer_consumed(count); - msgpack::unpacked result; - while (m_pac.next(&result)) { - msgpack::object msg = result.get(); - auto_zone& life = result.zone(); - process_message(msg, life); - } + msgpack::unpacked result; + while (m_pac.next(&result)) { + msgpack::object msg = result.get(); + auto_zone& life = result.zone(); + process_message(msg, life); + } - if(m_pac.message_size() > 10*1024*1024) { - throw std::runtime_error("message is too large"); - } - } + if(m_pac.message_size() > 10*1024*1024) { + throw std::runtime_error("message is too large"); + } + } private: - void process_message(msgpack::object msg, auto_zone& life) - { - std::cout << "message reached: " << msg << std::endl; - } + void process_message(msgpack::object msg, auto_zone& life) + { + std::cout << "message reached: " << msg << std::endl; + } private: - int m_sock; - msgpack::unpacker m_pac; + int m_sock; + msgpack::unpacker m_pac; }; static void* run_server(void* arg) try { - Server* srv = reinterpret_cast(arg); + Server* srv = reinterpret_cast(arg); - while(true) { - srv->socket_readable(); - } - return NULL; + while(true) { + srv->socket_readable(); + } + return NULL; } catch (std::exception& e) { - std::cerr << "error while processing client packet: " - << e.what() << std::endl; - return NULL; + std::cerr << "error while processing client packet: " + << e.what() << std::endl; + return NULL; } catch (...) { - std::cerr << "error while processing client packet: " - << "unknown error" << std::endl; - return NULL; + std::cerr << "error while processing client packet: " + << "unknown error" << std::endl; + return NULL; } struct fwriter { - fwriter(int fd) : m_fp( fdopen(fd, "w") ) { } + fwriter(int fd) : m_fp( fdopen(fd, "w") ) { } - void write(const char* buf, size_t buflen) - { - size_t count = fwrite(buf, buflen, 1, m_fp); - if(count < 1) { - std::cout << buflen << std::endl; - std::cout << count << std::endl; - throw std::runtime_error(strerror(errno)); - } - } + void write(const char* buf, size_t buflen) + { + size_t count = fwrite(buf, buflen, 1, m_fp); + if(count < 1) { + std::cout << buflen << std::endl; + std::cout << count << std::endl; + throw std::runtime_error(strerror(errno)); + } + } - void flush() { fflush(m_fp); } + void flush() { fflush(m_fp); } - void close() { fclose(m_fp); } + void close() { fclose(m_fp); } private: - FILE* m_fp; + FILE* m_fp; }; int main(void) { - int pair[2]; - pipe(pair); + int pair[2]; + pipe(pair); - // run server thread - Server srv(pair[0]); - pthread_t thread; - pthread_create(&thread, NULL, - run_server, reinterpret_cast(&srv)); + // run server thread + Server srv(pair[0]); + pthread_t thread; + pthread_create(&thread, NULL, + run_server, reinterpret_cast(&srv)); - // client thread: - fwriter writer(pair[1]); - msgpack::packer pk(writer); + // client thread: + fwriter writer(pair[1]); + msgpack::packer pk(writer); - typedef msgpack::type::tuple put_t; - typedef msgpack::type::tuple get_t; + typedef msgpack::type::tuple put_t; + typedef msgpack::type::tuple get_t; - put_t req1("put", "apple", "red"); - put_t req2("put", "lemon", "yellow"); - get_t req3("get", "apple"); - pk.pack(req1); - pk.pack(req2); - pk.pack(req3); - writer.flush(); - writer.close(); + put_t req1("put", "apple", "red"); + put_t req2("put", "lemon", "yellow"); + get_t req3("get", "apple"); + pk.pack(req1); + pk.pack(req2); + pk.pack(req3); + writer.flush(); + writer.close(); - pthread_join(thread, NULL); + pthread_join(thread, NULL); } diff --git a/example/user_buffer_unpack.c b/example/user_buffer_unpack.c new file mode 100644 index 00000000..d8b25c2a --- /dev/null +++ b/example/user_buffer_unpack.c @@ -0,0 +1,75 @@ +#include +#include +#include + +void prepare(msgpack_sbuffer* sbuf) { + msgpack_packer pk; + + msgpack_packer_init(&pk, sbuf, msgpack_sbuffer_write); + /* 1st object */ + msgpack_pack_array(&pk, 3); + msgpack_pack_int(&pk, 1); + msgpack_pack_true(&pk); + msgpack_pack_str(&pk, 7); + msgpack_pack_str_body(&pk, "example", 7); + /* 2nd object */ + msgpack_pack_str(&pk, 6); + msgpack_pack_str_body(&pk, "second", 6); + /* 3rd object */ + msgpack_pack_array(&pk, 2); + msgpack_pack_int(&pk, 42); + msgpack_pack_false(&pk); +} + +void unpack(char const* buf, size_t len) { + /* buf is allocated by client. */ + msgpack_unpacked result; + size_t off = 0; + msgpack_unpack_return ret; + int i = 0; + msgpack_unpacked_init(&result); + ret = msgpack_unpack_next(&result, buf, len, &off); + while (ret == MSGPACK_UNPACK_SUCCESS) { + msgpack_object obj = result.data; + + /* Use obj. */ + printf("Object no %d:\n", i++); + msgpack_object_print(stdout, obj); + printf("\n"); + /* If you want to allocate something on the zone, you can use zone. */ + /* msgpack_zone* zone = result.zone; */ + /* The lifetime of the obj and the zone, */ + + ret = msgpack_unpack_next(&result, buf, len, &off); + } + msgpack_unpacked_destroy(&result); + + if (ret == MSGPACK_UNPACK_CONTINUE) { + printf("All msgpack_object in the buffer is consumed.\n"); + } + else if (ret == MSGPACK_UNPACK_PARSE_ERROR) { + printf("The data in the buf is invalid format.\n"); + } +} + +int main(void) { + msgpack_sbuffer sbuf; + msgpack_sbuffer_init(&sbuf); + + prepare(&sbuf); + unpack(sbuf.data, sbuf.size); + + msgpack_sbuffer_destroy(&sbuf); + return 0; +} + +/* Output */ + +/* +Object no 1: +[1, true, "example"] +Object no 2: +"second" +Object no 3: +[42, false] +*/ diff --git a/src/msgpack.h b/include/msgpack.h similarity index 97% rename from src/msgpack.h rename to include/msgpack.h index 082edb84..5bb4494b 100644 --- a/src/msgpack.h +++ b/include/msgpack.h @@ -21,6 +21,7 @@ * @} */ +#include "msgpack/util.h" #include "msgpack/object.h" #include "msgpack/zone.h" #include "msgpack/pack.h" diff --git a/src/msgpack.hpp b/include/msgpack.hpp similarity index 96% rename from src/msgpack.hpp rename to include/msgpack.hpp index e14680dd..62d4b3d3 100644 --- a/src/msgpack.hpp +++ b/include/msgpack.hpp @@ -21,4 +21,4 @@ #include "msgpack/unpack.hpp" #include "msgpack/sbuffer.hpp" #include "msgpack/vrefbuffer.hpp" -#include "msgpack.h" +#include "msgpack/version.hpp" diff --git a/src/msgpack/type/bool.hpp b/include/msgpack/adaptor/bool.hpp similarity index 63% rename from src/msgpack/type/bool.hpp rename to include/msgpack/adaptor/bool.hpp index 9433a982..df7e7ac7 100644 --- a/src/msgpack/type/bool.hpp +++ b/include/msgpack/adaptor/bool.hpp @@ -15,41 +15,44 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_TYPE_BOOL_HPP__ -#define MSGPACK_TYPE_BOOL_HPP__ +#ifndef MSGPACK_TYPE_BOOL_HPP +#define MSGPACK_TYPE_BOOL_HPP -#include "msgpack/object.hpp" +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" #include namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { -inline bool& operator>> (object o, bool& v) +inline object const& operator>> (object const& o, bool& v) { - if(o.type != type::BOOLEAN) { throw type_error(); } - v = o.via.boolean; - return v; + if(o.type != type::BOOLEAN) { throw type_error(); } + v = o.via.boolean; + return o; } template inline packer& operator<< (packer& o, const bool& v) { - if(v) { o.pack_true(); } - else { o.pack_false(); } - return o; + if(v) { o.pack_true(); } + else { o.pack_false(); } + return o; } inline void operator<< (object& o, bool v) { - o.type = type::BOOLEAN; - o.via.boolean = v; + o.type = type::BOOLEAN; + o.via.boolean = v; } inline void operator<< (object::with_zone& o, bool v) - { static_cast(o) << v; } + { static_cast(o) << v; } +} // MSGPACK_API_VERSION_NAMESPACE(v1) + } // namespace msgpack -#endif /* msgpack/type/bool.hpp */ - +#endif // MSGPACK_TYPE_BOOL_HPP diff --git a/include/msgpack/adaptor/bool_fwd.hpp b/include/msgpack/adaptor/bool_fwd.hpp new file mode 100644 index 00000000..aecde517 --- /dev/null +++ b/include/msgpack/adaptor/bool_fwd.hpp @@ -0,0 +1,39 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2009 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_BOOL_FWD_HPP +#define MSGPACK_TYPE_BOOL_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +object const& operator>> (object const& o, bool& v); +template +packer& operator<< (packer& o, const bool& v); +void operator<< (object& o, bool v); +void operator<< (object::with_zone& o, bool v); + + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_BOOL_FWD_HPP diff --git a/include/msgpack/adaptor/char_ptr.hpp b/include/msgpack/adaptor/char_ptr.hpp new file mode 100644 index 00000000..dca1acff --- /dev/null +++ b/include/msgpack/adaptor/char_ptr.hpp @@ -0,0 +1,60 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2014 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_CHAR_PTR_HPP +#define MSGPACK_TYPE_CHAR_PTR_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +inline packer& operator<< (packer& o, const char* v) +{ + std::size_t size = std::strlen(v); + o.pack_str(size); + o.pack_str_body(v, size); + return o; +} + +inline void operator<< (object::with_zone& o, const char* v) +{ + std::size_t size = std::strlen(v); + o.type = type::STR; + char* ptr = static_cast(o.zone.allocate_align(size)); + o.via.str.ptr = ptr; + o.via.str.size = static_cast(size); + memcpy(ptr, v, size); +} + +inline void operator<< (object& o, const char* v) +{ + std::size_t size = std::strlen(v); + o.type = type::STR; + o.via.str.ptr = v; + o.via.str.size = static_cast(size); +} + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_CHAR_PTR_HPP diff --git a/include/msgpack/adaptor/char_ptr_fwd.hpp b/include/msgpack/adaptor/char_ptr_fwd.hpp new file mode 100644 index 00000000..f6290e6a --- /dev/null +++ b/include/msgpack/adaptor/char_ptr_fwd.hpp @@ -0,0 +1,38 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2014 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_CHAR_PTR_FWD_HPP +#define MSGPACK_TYPE_CHAR_PTR_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +packer& operator<< (packer& o, const char* v); +void operator<< (object::with_zone& o, const char* v); +void operator<< (object& o, const char* v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_CHAR_PTR_FWD_HPP diff --git a/include/msgpack/adaptor/cpp11/array.hpp b/include/msgpack/adaptor/cpp11/array.hpp new file mode 100644 index 00000000..6c932adf --- /dev/null +++ b/include/msgpack/adaptor/cpp11/array.hpp @@ -0,0 +1,73 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2014 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#ifndef MSGPACK_CPP11_ARRAY_HPP +#define MSGPACK_CPP11_ARRAY_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +inline object const& operator>> (object const& o, std::array& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size != N) { throw type_error(); } + if(o.via.array.size > 0) { + object* p = o.via.array.ptr; + object* const pend = o.via.array.ptr + o.via.array.size; + T* it = &v[0]; + do { + p->convert(*it); + ++p; + ++it; + } while(p < pend); + } + return o; +} + +template +inline packer& operator<< (packer& o, const std::array& v) { + o.pack_array(v.size()); + for(auto const& e : v) o.pack(e); + return o; +} + +template +inline void operator<< (object::with_zone& o, const std::array& v) { + o.type = type::ARRAY; + if(v.empty()) { + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } else { + object* p = static_cast(o.zone.allocate_align(sizeof(object)*v.size())); + o.via.array.size = v.size(); + o.via.array.ptr = p; + for (auto const& e : v) *p++ = object(e, o.zone); + } +} + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_CPP11_ARRAY_HPP diff --git a/include/msgpack/adaptor/cpp11/array_char.hpp b/include/msgpack/adaptor/cpp11/array_char.hpp new file mode 100644 index 00000000..9df71bb1 --- /dev/null +++ b/include/msgpack/adaptor/cpp11/array_char.hpp @@ -0,0 +1,79 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2014 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_ARRAY_CHAR_HPP +#define MSGPACK_TYPE_ARRAY_CHAR_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack_fwd.hpp" +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +inline object const& operator>> (object const& o, std::array& v) +{ + switch (o.type) { + case type::BIN: + if(o.via.bin.size != N) { throw type_error(); } + std::memcpy(v.data(), o.via.bin.ptr, o.via.bin.size); + break; + case type::STR: + if(o.via.str.size != N) { throw type_error(); } + std::memcpy(v.data(), o.via.str.ptr, N); + break; + default: + throw type_error(); + break; + } + return o; +} + +template +inline packer& operator<< (packer& o, const std::array& v) +{ + o.pack_bin(v.size()); + o.pack_bin_body(v.data(), v.size()); + + return o; +} + +template +inline void operator<< (object& o, const std::array& v) +{ + o.type = type::BIN; + o.via.bin.ptr = v.data(); + o.via.bin.size = static_cast(v.size()); +} + +template +inline void operator<< (object::with_zone& o, const std::array& v) +{ + o.type = type::BIN; + char* ptr = static_cast(o.zone.allocate_align(v.size())); + o.via.bin.ptr = ptr; + o.via.bin.size = static_cast(v.size()); + std::memcpy(ptr, v.data(), v.size()); +} + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_ARRAY_CHAR_HPP diff --git a/include/msgpack/adaptor/cpp11/array_char_fwd.hpp b/include/msgpack/adaptor/cpp11/array_char_fwd.hpp new file mode 100644 index 00000000..5f64e522 --- /dev/null +++ b/include/msgpack/adaptor/cpp11/array_char_fwd.hpp @@ -0,0 +1,45 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2014 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_ARRAY_CHAR_FWD_HPP +#define MSGPACK_TYPE_ARRAY_CHAR_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +object const& operator>> (object const& o, std::array& v); + +template +packer& operator<< (packer& o, const std::array& v); + +template +void operator<< (object& o, const std::array& v); + +template +void operator<< (object::with_zone& o, const std::array& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_ARRAY_CHAR_FWD_HPP diff --git a/include/msgpack/adaptor/cpp11/array_fwd.hpp b/include/msgpack/adaptor/cpp11/array_fwd.hpp new file mode 100644 index 00000000..815694b4 --- /dev/null +++ b/include/msgpack/adaptor/cpp11/array_fwd.hpp @@ -0,0 +1,44 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2014 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#ifndef MSGPACK_CPP11_ARRAY_FWD_HPP +#define MSGPACK_CPP11_ARRAY_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +object const& operator>> (object const& o, std::array& v); + +template +packer& operator<< (packer& o, const std::array& v); + +template +void operator<< (object::with_zone& o, const std::array& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_CPP11_ARRAY_FWD_HPP diff --git a/include/msgpack/adaptor/cpp11/forward_list.hpp b/include/msgpack/adaptor/cpp11/forward_list.hpp new file mode 100644 index 00000000..dd78afd6 --- /dev/null +++ b/include/msgpack/adaptor/cpp11/forward_list.hpp @@ -0,0 +1,73 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2014 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#ifndef MSGPACK_CPP11_FORWARD_LIST_HPP +#define MSGPACK_CPP11_FORWARD_LIST_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +inline object const& operator>> (object const& o, std::forward_list& v) +{ + if(o.type != type::ARRAY) { throw type_error(); } + v.resize(o.via.array.size); + object* p = o.via.array.ptr; + for (auto &e : v) { + p->convert(e); + ++p; + } + return o; +} + +template +inline packer& operator<< (packer& o, const std::forward_list& v) +{ + o.pack_array(std::distance(v.begin(), v.end())); + for(auto const& e : v) o.pack(e); + return o; +} + +template +inline void operator<< (object::with_zone& o, const std::forward_list& v) +{ + o.type = type::ARRAY; + if(v.empty()) { + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } else { + std::size_t size = std::distance(v.begin(), v.end()); + o.via.array.size = size; + object* p = static_cast( + o.zone.allocate_align(sizeof(object)*size)); + o.via.array.ptr = p; + for(auto const& e : v) *p++ = object(e, o.zone); + } +} + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_CPP11_FORWARD_LIST_HPP diff --git a/include/msgpack/adaptor/cpp11/forward_list_fwd.hpp b/include/msgpack/adaptor/cpp11/forward_list_fwd.hpp new file mode 100644 index 00000000..47ca34a2 --- /dev/null +++ b/include/msgpack/adaptor/cpp11/forward_list_fwd.hpp @@ -0,0 +1,44 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2014 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#ifndef MSGPACK_CPP11_FORWARD_LIST_FWD_HPP +#define MSGPACK_CPP11_FORWARD_LIST_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +object const& operator>> (object const& o, std::forward_list& v); + +template +packer& operator<< (packer& o, const std::forward_list& v); + +template +void operator<< (object::with_zone& o, const std::forward_list& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_CPP11_FORWARD_LIST_FWD_HPP diff --git a/include/msgpack/adaptor/cpp11/tuple.hpp b/include/msgpack/adaptor/cpp11/tuple.hpp new file mode 100644 index 00000000..b917360a --- /dev/null +++ b/include/msgpack/adaptor/cpp11/tuple.hpp @@ -0,0 +1,149 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_CPP11_TUPLE_HPP +#define MSGPACK_CPP11_TUPLE_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +// --- Pack ( from tuple to packer stream --- +template +struct StdTuplePacker { + static void pack( + packer& o, + const Tuple& v) { + StdTuplePacker::pack(o, v); + o.pack(std::get(v)); + } +}; + +template +struct StdTuplePacker { + static void pack ( + packer& o, + const Tuple& v) { + o.pack(std::get<0>(v)); + } +}; + +template +struct StdTuplePacker { + static void pack ( + packer&, + const Tuple&) { + } +}; + + +template +inline const packer& operator<< ( + packer& o, + const std::tuple& v) { + o.pack_array(sizeof...(Args)); + StdTuplePacker::pack(o, v); + return o; +} + +// --- Convert from tuple to object --- + +template +struct StdTupleConverter { + static void convert( + object const& o, + Tuple& v) { + StdTupleConverter::convert(o, v); + o.via.array.ptr[N-1].convert(v))>::type>(std::get(v)); + } +}; + +template +struct StdTupleConverter { + static void convert ( + object const& o, + Tuple& v) { + o.via.array.ptr[0].convert(v))>::type>(std::get<0>(v)); + } +}; + +template +struct StdTupleConverter { + static void convert ( + object const&, + Tuple&) { + } +}; + +template +inline object const& operator>> ( + object const& o, + std::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < sizeof...(Args)) { throw type_error(); } + StdTupleConverter::convert(o, v); + return o; +} + +// --- Convert from tuple to object with zone --- +template +struct StdTupleToObjectWithZone { + static void convert( + object::with_zone& o, + const Tuple& v) { + StdTupleToObjectWithZone::convert(o, v); + o.via.array.ptr[N-1] = object(std::get(v), o.zone); + } +}; + +template +struct StdTupleToObjectWithZone { + static void convert ( + object::with_zone& o, + const Tuple& v) { + o.via.array.ptr[0] = object(std::get<0>(v), o.zone); + } +}; + +template +struct StdTupleToObjectWithZone { + static void convert ( + object::with_zone&, + const Tuple&) { + } +}; + +template +inline void operator<< ( + object::with_zone& o, + std::tuple const& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*sizeof...(Args))); + o.via.array.size = sizeof...(Args); + StdTupleToObjectWithZone::convert(o, v); +} + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_CPP11_TUPLE_HPP diff --git a/include/msgpack/adaptor/cpp11/tuple_fwd.hpp b/include/msgpack/adaptor/cpp11/tuple_fwd.hpp new file mode 100644 index 00000000..f17ac289 --- /dev/null +++ b/include/msgpack/adaptor/cpp11/tuple_fwd.hpp @@ -0,0 +1,62 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_CPP11_TUPLE_FWD_HPP +#define MSGPACK_CPP11_TUPLE_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +// --- Pack ( from tuple to packer stream --- +template +struct StdTuplePacker; + +template +const packer& operator<< ( + packer& o, + const std::tuple& v); + +// --- Convert from tuple to object --- + +template +struct StdTupleConverter; + +template +object const& operator>> ( + object const& o, + std::tuple& v); + +// --- Convert from tuple to object with zone --- +template +struct StdTupleToObjectWithZone; + +template +void operator<< ( + object::with_zone& o, + std::tuple const& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_CPP11_TUPLE_FWD_HPP diff --git a/include/msgpack/adaptor/define.hpp b/include/msgpack/adaptor/define.hpp new file mode 100644 index 00000000..bf0b6195 --- /dev/null +++ b/include/msgpack/adaptor/define.hpp @@ -0,0 +1,29 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_DEFINE_HPP +#define MSGPACK_DEFINE_HPP + +#include "msgpack/cpp_config.hpp" + +#if defined(MSGPACK_USE_CPP03) +#include "detail/cpp03_define.hpp" +#else // MSGPACK_USE_CPP03 +#include "detail/cpp11_define.hpp" +#endif // MSGPACK_USE_CPP03 + +#endif // MSGPACK_DEFINE_HPP diff --git a/include/msgpack/adaptor/deque.hpp b/include/msgpack/adaptor/deque.hpp new file mode 100644 index 00000000..94bac923 --- /dev/null +++ b/include/msgpack/adaptor/deque.hpp @@ -0,0 +1,79 @@ +// +// 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_DEQUE_HPP +#define MSGPACK_TYPE_DEQUE_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +inline object const& operator>> (object const& o, std::deque& v) +{ + if(o.type != type::ARRAY) { throw type_error(); } + v.resize(o.via.array.size); + object* p = o.via.array.ptr; + object* const pend = o.via.array.ptr + o.via.array.size; + typename std::deque::iterator it = v.begin(); + for(; p < pend; ++p, ++it) { + p->convert(*it); + } + return o; +} + +template +inline packer& operator<< (packer& o, const std::deque& v) +{ + o.pack_array(v.size()); + for(typename std::deque::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(*it); + } + return o; +} + +template +inline void operator<< (object::with_zone& o, const std::deque& v) +{ + o.type = type::ARRAY; + if(v.empty()) { + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } else { + object* p = static_cast(o.zone.allocate_align(sizeof(object)*v.size())); + object* const pend = p + v.size(); + o.via.array.ptr = p; + o.via.array.size = v.size(); + typename std::deque::const_iterator it(v.begin()); + do { + *p = object(*it, o.zone); + ++p; + ++it; + } while(p < pend); + } +} + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif /* msgpack/type/deque.hpp */ diff --git a/include/msgpack/adaptor/deque_fwd.hpp b/include/msgpack/adaptor/deque_fwd.hpp new file mode 100644 index 00000000..81a88189 --- /dev/null +++ b/include/msgpack/adaptor/deque_fwd.hpp @@ -0,0 +1,40 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_DEQUE_FWD_HPP +#define MSGPACK_TYPE_DEQUE_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +object const& operator>> (object const& o, std::deque& v); +template +packer& operator<< (packer& o, const std::deque& v); +template +void operator<< (object::with_zone& o, const std::deque& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_DEQUE_FWD_HPP diff --git a/include/msgpack/adaptor/detail/cpp03_define.hpp b/include/msgpack/adaptor/detail/cpp03_define.hpp new file mode 100644 index 00000000..3673da88 --- /dev/null +++ b/include/msgpack/adaptor/detail/cpp03_define.hpp @@ -0,0 +1,3472 @@ +// +// 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_HPP +#define MSGPACK_CPP03_DEFINE_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/adaptor/msgpack_tuple_fwd.hpp" +#include "msgpack/object_fwd.hpp" + +#define MSGPACK_DEFINE(...) \ + template \ + void msgpack_pack(Packer& pk) const \ + { \ + msgpack::type::make_define(__VA_ARGS__).msgpack_pack(pk); \ + } \ + void msgpack_unpack(msgpack::object const& o) \ + { \ + msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \ + }\ + template \ + void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone& z) const \ + { \ + msgpack::type::make_define(__VA_ARGS__).msgpack_object(o, z); \ + } + +// MSGPACK_ADD_ENUM must be used in the global namespace. +#define MSGPACK_ADD_ENUM(enum) \ + namespace msgpack { \ + MSGPACK_API_VERSION_NAMESPACE(v1) { \ + template <> \ + inline object const& operator>> (object const& o, enum& v) \ + { \ + int tmp; \ + o >> tmp; \ + v = static_cast(tmp); \ + return o; \ + } \ + template <> \ + inline void operator<< (object::with_zone& o, const enum& v) \ + { \ + o << static_cast(v); \ + } \ + namespace detail { \ + template \ + struct packer_serializer { \ + static packer& pack(packer& o, const enum& v) { \ + return o << static_cast(v); \ + } \ + }; \ + } \ + } \ + } + +namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { +namespace type { + + + +template +struct define; + + +template <> +struct define<> { + typedef define<> value_type; + typedef tuple<> tuple_type; + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(0); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + } + void msgpack_object(msgpack::object* o, msgpack::zone&) const + { + o->type = type::ARRAY; + o->via.array.ptr = nullptr; + o->via.array.size = 0; + } +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0) : + a0(_a0) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(1); + + pk.pack(a0); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*1)); + o->via.array.size = 1; + + o->via.array.ptr[0] = object(a0, z); + } + + A0& a0; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1) : + a0(_a0), a1(_a1) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(2); + + pk.pack(a0); + pk.pack(a1); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*2)); + o->via.array.size = 2; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + } + + A0& a0; + A1& a1; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2) : + a0(_a0), a1(_a1), a2(_a2) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(3); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*3)); + o->via.array.size = 3; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + } + + A0& a0; + A1& a1; + A2& a2; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(4); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*4)); + o->via.array.size = 4; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(5); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*5)); + o->via.array.size = 5; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(6); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*6)); + o->via.array.size = 6; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(7); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*7)); + o->via.array.size = 7; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(8); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*8)); + o->via.array.size = 8; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(9); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*9)); + o->via.array.size = 9; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(10); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*10)); + o->via.array.size = 10; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(11); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*11)); + o->via.array.size = 11; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(12); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*12)); + o->via.array.size = 12; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(13); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*13)); + o->via.array.size = 13; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(14); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*14)); + o->via.array.size = 14; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(15); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*15)); + o->via.array.size = 15; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(16); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*16)); + o->via.array.size = 16; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(17); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*17)); + o->via.array.size = 17; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(18); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 18: ptr[17].convert(a17); + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*18)); + o->via.array.size = 18; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; + A17& a17; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(19); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 19: ptr[18].convert(a18); + case 18: ptr[17].convert(a17); + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*19)); + o->via.array.size = 19; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; + A17& a17; + A18& a18; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(20); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 20: ptr[19].convert(a19); + case 19: ptr[18].convert(a18); + case 18: ptr[17].convert(a17); + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*20)); + o->via.array.size = 20; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; + A17& a17; + A18& a18; + A19& a19; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(21); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 21: ptr[20].convert(a20); + case 20: ptr[19].convert(a19); + case 19: ptr[18].convert(a18); + case 18: ptr[17].convert(a17); + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*21)); + o->via.array.size = 21; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; + A17& a17; + A18& a18; + A19& a19; + A20& a20; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(22); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 22: ptr[21].convert(a21); + case 21: ptr[20].convert(a20); + case 20: ptr[19].convert(a19); + case 19: ptr[18].convert(a18); + case 18: ptr[17].convert(a17); + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*22)); + o->via.array.size = 22; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; + A17& a17; + A18& a18; + A19& a19; + A20& a20; + A21& a21; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(23); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + pk.pack(a22); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 23: ptr[22].convert(a22); + case 22: ptr[21].convert(a21); + case 21: ptr[20].convert(a20); + case 20: ptr[19].convert(a19); + case 19: ptr[18].convert(a18); + case 18: ptr[17].convert(a17); + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*23)); + o->via.array.size = 23; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + o->via.array.ptr[22] = object(a22, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; + A17& a17; + A18& a18; + A19& a19; + A20& a20; + A21& a21; + A22& a22; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(24); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + pk.pack(a22); + pk.pack(a23); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 24: ptr[23].convert(a23); + case 23: ptr[22].convert(a22); + case 22: ptr[21].convert(a21); + case 21: ptr[20].convert(a20); + case 20: ptr[19].convert(a19); + case 19: ptr[18].convert(a18); + case 18: ptr[17].convert(a17); + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*24)); + o->via.array.size = 24; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + o->via.array.ptr[22] = object(a22, z); + o->via.array.ptr[23] = object(a23, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; + A17& a17; + A18& a18; + A19& a19; + A20& a20; + A21& a21; + A22& a22; + A23& a23; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(25); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + pk.pack(a22); + pk.pack(a23); + pk.pack(a24); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 25: ptr[24].convert(a24); + case 24: ptr[23].convert(a23); + case 23: ptr[22].convert(a22); + case 22: ptr[21].convert(a21); + case 21: ptr[20].convert(a20); + case 20: ptr[19].convert(a19); + case 19: ptr[18].convert(a18); + case 18: ptr[17].convert(a17); + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*25)); + o->via.array.size = 25; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + o->via.array.ptr[22] = object(a22, z); + o->via.array.ptr[23] = object(a23, z); + o->via.array.ptr[24] = object(a24, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; + A17& a17; + A18& a18; + A19& a19; + A20& a20; + A21& a21; + A22& a22; + A23& a23; + A24& a24; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(26); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + pk.pack(a22); + pk.pack(a23); + pk.pack(a24); + pk.pack(a25); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 26: ptr[25].convert(a25); + case 25: ptr[24].convert(a24); + case 24: ptr[23].convert(a23); + case 23: ptr[22].convert(a22); + case 22: ptr[21].convert(a21); + case 21: ptr[20].convert(a20); + case 20: ptr[19].convert(a19); + case 19: ptr[18].convert(a18); + case 18: ptr[17].convert(a17); + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*26)); + o->via.array.size = 26; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + o->via.array.ptr[22] = object(a22, z); + o->via.array.ptr[23] = object(a23, z); + o->via.array.ptr[24] = object(a24, z); + o->via.array.ptr[25] = object(a25, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; + A17& a17; + A18& a18; + A19& a19; + A20& a20; + A21& a21; + A22& a22; + A23& a23; + A24& a24; + A25& a25; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(27); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + pk.pack(a22); + pk.pack(a23); + pk.pack(a24); + pk.pack(a25); + pk.pack(a26); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 27: ptr[26].convert(a26); + case 26: ptr[25].convert(a25); + case 25: ptr[24].convert(a24); + case 24: ptr[23].convert(a23); + case 23: ptr[22].convert(a22); + case 22: ptr[21].convert(a21); + case 21: ptr[20].convert(a20); + case 20: ptr[19].convert(a19); + case 19: ptr[18].convert(a18); + case 18: ptr[17].convert(a17); + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*27)); + o->via.array.size = 27; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + o->via.array.ptr[22] = object(a22, z); + o->via.array.ptr[23] = object(a23, z); + o->via.array.ptr[24] = object(a24, z); + o->via.array.ptr[25] = object(a25, z); + o->via.array.ptr[26] = object(a26, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; + A17& a17; + A18& a18; + A19& a19; + A20& a20; + A21& a21; + A22& a22; + A23& a23; + A24& a24; + A25& a25; + A26& a26; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(28); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + pk.pack(a22); + pk.pack(a23); + pk.pack(a24); + pk.pack(a25); + pk.pack(a26); + pk.pack(a27); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 28: ptr[27].convert(a27); + case 27: ptr[26].convert(a26); + case 26: ptr[25].convert(a25); + case 25: ptr[24].convert(a24); + case 24: ptr[23].convert(a23); + case 23: ptr[22].convert(a22); + case 22: ptr[21].convert(a21); + case 21: ptr[20].convert(a20); + case 20: ptr[19].convert(a19); + case 19: ptr[18].convert(a18); + case 18: ptr[17].convert(a17); + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*28)); + o->via.array.size = 28; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + o->via.array.ptr[22] = object(a22, z); + o->via.array.ptr[23] = object(a23, z); + o->via.array.ptr[24] = object(a24, z); + o->via.array.ptr[25] = object(a25, z); + o->via.array.ptr[26] = object(a26, z); + o->via.array.ptr[27] = object(a27, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; + A17& a17; + A18& a18; + A19& a19; + A20& a20; + A21& a21; + A22& a22; + A23& a23; + A24& a24; + A25& a25; + A26& a26; + A27& a27; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27, A28& _a28) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(29); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + pk.pack(a22); + pk.pack(a23); + pk.pack(a24); + pk.pack(a25); + pk.pack(a26); + pk.pack(a27); + pk.pack(a28); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 29: ptr[28].convert(a28); + case 28: ptr[27].convert(a27); + case 27: ptr[26].convert(a26); + case 26: ptr[25].convert(a25); + case 25: ptr[24].convert(a24); + case 24: ptr[23].convert(a23); + case 23: ptr[22].convert(a22); + case 22: ptr[21].convert(a21); + case 21: ptr[20].convert(a20); + case 20: ptr[19].convert(a19); + case 19: ptr[18].convert(a18); + case 18: ptr[17].convert(a17); + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*29)); + o->via.array.size = 29; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + o->via.array.ptr[22] = object(a22, z); + o->via.array.ptr[23] = object(a23, z); + o->via.array.ptr[24] = object(a24, z); + o->via.array.ptr[25] = object(a25, z); + o->via.array.ptr[26] = object(a26, z); + o->via.array.ptr[27] = object(a27, z); + o->via.array.ptr[28] = object(a28, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; + A17& a17; + A18& a18; + A19& a19; + A20& a20; + A21& a21; + A22& a22; + A23& a23; + A24& a24; + A25& a25; + A26& a26; + A27& a27; + A28& a28; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27, A28& _a28, A29& _a29) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28), a29(_a29) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(30); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + pk.pack(a22); + pk.pack(a23); + pk.pack(a24); + pk.pack(a25); + pk.pack(a26); + pk.pack(a27); + pk.pack(a28); + pk.pack(a29); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 30: ptr[29].convert(a29); + case 29: ptr[28].convert(a28); + case 28: ptr[27].convert(a27); + case 27: ptr[26].convert(a26); + case 26: ptr[25].convert(a25); + case 25: ptr[24].convert(a24); + case 24: ptr[23].convert(a23); + case 23: ptr[22].convert(a22); + case 22: ptr[21].convert(a21); + case 21: ptr[20].convert(a20); + case 20: ptr[19].convert(a19); + case 19: ptr[18].convert(a18); + case 18: ptr[17].convert(a17); + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*30)); + o->via.array.size = 30; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + o->via.array.ptr[22] = object(a22, z); + o->via.array.ptr[23] = object(a23, z); + o->via.array.ptr[24] = object(a24, z); + o->via.array.ptr[25] = object(a25, z); + o->via.array.ptr[26] = object(a26, z); + o->via.array.ptr[27] = object(a27, z); + o->via.array.ptr[28] = object(a28, z); + o->via.array.ptr[29] = object(a29, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; + A17& a17; + A18& a18; + A19& a19; + A20& a20; + A21& a21; + A22& a22; + A23& a23; + A24& a24; + A25& a25; + A26& a26; + A27& a27; + A28& a28; + A29& a29; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27, A28& _a28, A29& _a29, A30& _a30) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28), a29(_a29), a30(_a30) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(31); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + pk.pack(a22); + pk.pack(a23); + pk.pack(a24); + pk.pack(a25); + pk.pack(a26); + pk.pack(a27); + pk.pack(a28); + pk.pack(a29); + pk.pack(a30); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 31: ptr[30].convert(a30); + case 30: ptr[29].convert(a29); + case 29: ptr[28].convert(a28); + case 28: ptr[27].convert(a27); + case 27: ptr[26].convert(a26); + case 26: ptr[25].convert(a25); + case 25: ptr[24].convert(a24); + case 24: ptr[23].convert(a23); + case 23: ptr[22].convert(a22); + case 22: ptr[21].convert(a21); + case 21: ptr[20].convert(a20); + case 20: ptr[19].convert(a19); + case 19: ptr[18].convert(a18); + case 18: ptr[17].convert(a17); + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*31)); + o->via.array.size = 31; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + o->via.array.ptr[22] = object(a22, z); + o->via.array.ptr[23] = object(a23, z); + o->via.array.ptr[24] = object(a24, z); + o->via.array.ptr[25] = object(a25, z); + o->via.array.ptr[26] = object(a26, z); + o->via.array.ptr[27] = object(a27, z); + o->via.array.ptr[28] = object(a28, z); + o->via.array.ptr[29] = object(a29, z); + o->via.array.ptr[30] = object(a30, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; + A17& a17; + A18& a18; + A19& a19; + A20& a20; + A21& a21; + A22& a22; + A23& a23; + A24& a24; + A25& a25; + A26& a26; + A27& a27; + A28& a28; + A29& a29; + A30& a30; +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27, A28& _a28, A29& _a29, A30& _a30, A31& _a31) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28), a29(_a29), a30(_a30), a31(_a31) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(32); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + pk.pack(a22); + pk.pack(a23); + pk.pack(a24); + pk.pack(a25); + pk.pack(a26); + pk.pack(a27); + pk.pack(a28); + pk.pack(a29); + pk.pack(a30); + pk.pack(a31); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 32: ptr[31].convert(a31); + case 31: ptr[30].convert(a30); + case 30: ptr[29].convert(a29); + case 29: ptr[28].convert(a28); + case 28: ptr[27].convert(a27); + case 27: ptr[26].convert(a26); + case 26: ptr[25].convert(a25); + case 25: ptr[24].convert(a24); + case 24: ptr[23].convert(a23); + case 23: ptr[22].convert(a22); + case 22: ptr[21].convert(a21); + case 21: ptr[20].convert(a20); + case 20: ptr[19].convert(a19); + case 19: ptr[18].convert(a18); + case 18: ptr[17].convert(a17); + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*32)); + o->via.array.size = 32; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + o->via.array.ptr[22] = object(a22, z); + o->via.array.ptr[23] = object(a23, z); + o->via.array.ptr[24] = object(a24, z); + o->via.array.ptr[25] = object(a25, z); + o->via.array.ptr[26] = object(a26, z); + o->via.array.ptr[27] = object(a27, z); + o->via.array.ptr[28] = object(a28, z); + o->via.array.ptr[29] = object(a29, z); + o->via.array.ptr[30] = object(a30, z); + o->via.array.ptr[31] = object(a31, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; + A12& a12; + A13& a13; + A14& a14; + A15& a15; + A16& a16; + A17& a17; + A18& a18; + A19& a19; + A20& a20; + A21& a21; + A22& a22; + A23& a23; + A24& a24; + A25& a25; + A26& a26; + A27& a27; + A28& a28; + A29& a29; + A30& a30; + A31& a31; +}; + + +inline define<> make_define() +{ + return define<>(); +} + +template +define make_define(A0& a0) +{ + return define(a0); +} + +template +define make_define(A0& a0, A1& a1) +{ + return define(a0, a1); +} + +template +define make_define(A0& a0, A1& a1, A2& a2) +{ + return define(a0, a1, a2); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3) +{ + return define(a0, a1, a2, a3); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4) +{ + return define(a0, a1, a2, a3, a4); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) +{ + return define(a0, a1, a2, a3, a4, a5); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) +{ + return define(a0, a1, a2, a3, a4, a5, a6); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28, A29& a29) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28, A29& a29, A30& a30) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30); +} + +template +define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28, A29& a29, A30& a30, A31& a31) +{ + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31); +} + + +} // namespace type +} // MSGPACK_API_VERSION_NAMESPACE(v1) +} // namespace msgpack + + +#endif // MSGPACK_CPP03_DEFINE_HPP diff --git a/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp b/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp new file mode 100644 index 00000000..70346189 --- /dev/null +++ b/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp @@ -0,0 +1,13918 @@ +// +// 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 "msgpack/versioning.hpp" +#include "msgpack/object.hpp" + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +namespace type { + +// FIXME operator== +// FIXME operator!= + + +template +struct tuple; + +template +struct tuple_element; + +template +struct const_tuple_element; + +template +struct tuple_type { + typedef T type; + typedef T value_type; + typedef T& reference; + typedef const T& const_reference; + typedef const T& transparent_reference; +}; + +template +struct tuple_type { + typedef T type; + typedef T& value_type; + typedef T& reference; + typedef const T& const_reference; + typedef T& transparent_reference; +}; + +template +struct tuple_type { + typedef T type; + typedef T& value_type; + typedef T& reference; + typedef const T& const_reference; + typedef const T& transparent_reference; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 17> : tuple_type { + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 17> : tuple_type { + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 18> : tuple_type { + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 17> : tuple_type { + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 18> : tuple_type { + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 19> : tuple_type { + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 17> : tuple_type { + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 18> : tuple_type { + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 19> : tuple_type { + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 20> : tuple_type { + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 17> : tuple_type { + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 18> : tuple_type { + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 19> : tuple_type { + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 20> : tuple_type { + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 21> : tuple_type { + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 17> : tuple_type { + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 18> : tuple_type { + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 19> : tuple_type { + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 20> : tuple_type { + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 21> : tuple_type { + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 22> : tuple_type { + tuple_element(tuple& x) : m_x(x.a22) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 17> : tuple_type { + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 18> : tuple_type { + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 19> : tuple_type { + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 20> : tuple_type { + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 21> : tuple_type { + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 22> : tuple_type { + tuple_element(tuple& x) : m_x(x.a22) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 23> : tuple_type { + tuple_element(tuple& x) : m_x(x.a23) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 17> : tuple_type { + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 18> : tuple_type { + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 19> : tuple_type { + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 20> : tuple_type { + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 21> : tuple_type { + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 22> : tuple_type { + tuple_element(tuple& x) : m_x(x.a22) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 23> : tuple_type { + tuple_element(tuple& x) : m_x(x.a23) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 24> : tuple_type { + tuple_element(tuple& x) : m_x(x.a24) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 17> : tuple_type { + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 18> : tuple_type { + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 19> : tuple_type { + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 20> : tuple_type { + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 21> : tuple_type { + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 22> : tuple_type { + tuple_element(tuple& x) : m_x(x.a22) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 23> : tuple_type { + tuple_element(tuple& x) : m_x(x.a23) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 24> : tuple_type { + tuple_element(tuple& x) : m_x(x.a24) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 25> : tuple_type { + tuple_element(tuple& x) : m_x(x.a25) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 17> : tuple_type { + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 18> : tuple_type { + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 19> : tuple_type { + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 20> : tuple_type { + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 21> : tuple_type { + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 22> : tuple_type { + tuple_element(tuple& x) : m_x(x.a22) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 23> : tuple_type { + tuple_element(tuple& x) : m_x(x.a23) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 24> : tuple_type { + tuple_element(tuple& x) : m_x(x.a24) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 25> : tuple_type { + tuple_element(tuple& x) : m_x(x.a25) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 26> : tuple_type { + tuple_element(tuple& x) : m_x(x.a26) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 17> : tuple_type { + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 18> : tuple_type { + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 19> : tuple_type { + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 20> : tuple_type { + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 21> : tuple_type { + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 22> : tuple_type { + tuple_element(tuple& x) : m_x(x.a22) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 23> : tuple_type { + tuple_element(tuple& x) : m_x(x.a23) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 24> : tuple_type { + tuple_element(tuple& x) : m_x(x.a24) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 25> : tuple_type { + tuple_element(tuple& x) : m_x(x.a25) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 26> : tuple_type { + tuple_element(tuple& x) : m_x(x.a26) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 27> : tuple_type { + tuple_element(tuple& x) : m_x(x.a27) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 17> : tuple_type { + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 18> : tuple_type { + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 19> : tuple_type { + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 20> : tuple_type { + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 21> : tuple_type { + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 22> : tuple_type { + tuple_element(tuple& x) : m_x(x.a22) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 23> : tuple_type { + tuple_element(tuple& x) : m_x(x.a23) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 24> : tuple_type { + tuple_element(tuple& x) : m_x(x.a24) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 25> : tuple_type { + tuple_element(tuple& x) : m_x(x.a25) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 26> : tuple_type { + tuple_element(tuple& x) : m_x(x.a26) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 27> : tuple_type { + tuple_element(tuple& x) : m_x(x.a27) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 28> : tuple_type { + tuple_element(tuple& x) : m_x(x.a28) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 17> : tuple_type { + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 18> : tuple_type { + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 19> : tuple_type { + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 20> : tuple_type { + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 21> : tuple_type { + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 22> : tuple_type { + tuple_element(tuple& x) : m_x(x.a22) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 23> : tuple_type { + tuple_element(tuple& x) : m_x(x.a23) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 24> : tuple_type { + tuple_element(tuple& x) : m_x(x.a24) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 25> : tuple_type { + tuple_element(tuple& x) : m_x(x.a25) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 26> : tuple_type { + tuple_element(tuple& x) : m_x(x.a26) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 27> : tuple_type { + tuple_element(tuple& x) : m_x(x.a27) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 28> : tuple_type { + tuple_element(tuple& x) : m_x(x.a28) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 29> : tuple_type { + tuple_element(tuple& x) : m_x(x.a29) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 17> : tuple_type { + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 18> : tuple_type { + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 19> : tuple_type { + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 20> : tuple_type { + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 21> : tuple_type { + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 22> : tuple_type { + tuple_element(tuple& x) : m_x(x.a22) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 23> : tuple_type { + tuple_element(tuple& x) : m_x(x.a23) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 24> : tuple_type { + tuple_element(tuple& x) : m_x(x.a24) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 25> : tuple_type { + tuple_element(tuple& x) : m_x(x.a25) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 26> : tuple_type { + tuple_element(tuple& x) : m_x(x.a26) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 27> : tuple_type { + tuple_element(tuple& x) : m_x(x.a27) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 28> : tuple_type { + tuple_element(tuple& x) : m_x(x.a28) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 29> : tuple_type { + tuple_element(tuple& x) : m_x(x.a29) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 30> : tuple_type { + tuple_element(tuple& x) : m_x(x.a30) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + +template +struct tuple_element, 0> : tuple_type { + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 1> : tuple_type { + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 2> : tuple_type { + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 3> : tuple_type { + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 4> : tuple_type { + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 5> : tuple_type { + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 6> : tuple_type { + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 7> : tuple_type { + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 8> : tuple_type { + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 9> : tuple_type { + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 10> : tuple_type { + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 11> : tuple_type { + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 12> : tuple_type { + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 13> : tuple_type { + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 14> : tuple_type { + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 15> : tuple_type { + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 16> : tuple_type { + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 17> : tuple_type { + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 18> : tuple_type { + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 19> : tuple_type { + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 20> : tuple_type { + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 21> : tuple_type { + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 22> : tuple_type { + tuple_element(tuple& x) : m_x(x.a22) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 23> : tuple_type { + tuple_element(tuple& x) : m_x(x.a23) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 24> : tuple_type { + tuple_element(tuple& x) : m_x(x.a24) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 25> : tuple_type { + tuple_element(tuple& x) : m_x(x.a25) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 26> : tuple_type { + tuple_element(tuple& x) : m_x(x.a26) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 27> : tuple_type { + tuple_element(tuple& x) : m_x(x.a27) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 28> : tuple_type { + tuple_element(tuple& x) : m_x(x.a28) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 29> : tuple_type { + tuple_element(tuple& x) : m_x(x.a29) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 30> : tuple_type { + tuple_element(tuple& x) : m_x(x.a30) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + +template +struct tuple_element, 31> : tuple_type { + tuple_element(tuple& x) : m_x(x.a31) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::reference m_x; +}; + + + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 17> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 17> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 18> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 17> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 18> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 19> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 17> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 18> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 19> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 20> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 17> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 18> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 19> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 20> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 21> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 17> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 18> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 19> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 20> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 21> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 22> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a22) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 17> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 18> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 19> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 20> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 21> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 22> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a22) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 23> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a23) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 17> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 18> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 19> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 20> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 21> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 22> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a22) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 23> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a23) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 24> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a24) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 17> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 18> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 19> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 20> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 21> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 22> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a22) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 23> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a23) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 24> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a24) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 25> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a25) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 17> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 18> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 19> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 20> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 21> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 22> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a22) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 23> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a23) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 24> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a24) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 25> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a25) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 26> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a26) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 17> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 18> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 19> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 20> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 21> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 22> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a22) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 23> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a23) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 24> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a24) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 25> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a25) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 26> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a26) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 27> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a27) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 17> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 18> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 19> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 20> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 21> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 22> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a22) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 23> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a23) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 24> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a24) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 25> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a25) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 26> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a26) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 27> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a27) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 28> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a28) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 17> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 18> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 19> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 20> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 21> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 22> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a22) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 23> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a23) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 24> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a24) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 25> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a25) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 26> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a26) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 27> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a27) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 28> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a28) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 29> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a29) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 17> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 18> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 19> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 20> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 21> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 22> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a22) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 23> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a23) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 24> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a24) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 25> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a25) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 26> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a26) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 27> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a27) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 28> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a28) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 29> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a29) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 30> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a30) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template +struct const_tuple_element, 0> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 1> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 2> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 3> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 4> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 5> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 6> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 7> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 8> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 9> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 10> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 11> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 12> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 13> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 14> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 15> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 16> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 17> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 18> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 19> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 20> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 21> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 22> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a22) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 23> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a23) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 24> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a24) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 25> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a25) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 26> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a26) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 27> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a27) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 28> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a28) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 29> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a29) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 30> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a30) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + +template +struct const_tuple_element, 31> : tuple_type { + const_tuple_element(const tuple& x) : m_x(x.a31) {} + typename tuple_type::const_reference get() const { return m_x; } +private: + typename tuple_type::const_reference m_x; +}; + + + +template <> +struct tuple<> { + tuple() {} + tuple(object const& o) { o.convert(*this); } + typedef tuple<> value_type; +}; + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0) : + a0(_a0) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1) : + a0(_a0), a1(_a1) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2) : + a0(_a0), a1(_a1), a2(_a2) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; + A17 a17; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; + A17 a17; + A18 a18; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; + A17 a17; + A18 a18; + A19 a19; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; + A17 a17; + A18 a18; + A19 a19; + A20 a20; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; + A17 a17; + A18 a18; + A19 a19; + A20 a20; + A21 a21; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; + A17 a17; + A18 a18; + A19 a19; + A20 a20; + A21 a21; + A22 a22; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; + A17 a17; + A18 a18; + A19 a19; + A20 a20; + A21 a21; + A22 a22; + A23 a23; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; + A17 a17; + A18 a18; + A19 a19; + A20 a20; + A21 a21; + A22 a22; + A23 a23; + A24 a24; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; + A17 a17; + A18 a18; + A19 a19; + A20 a20; + A21 a21; + A22 a22; + A23 a23; + A24 a24; + A25 a25; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; + A17 a17; + A18 a18; + A19 a19; + A20 a20; + A21 a21; + A22 a22; + A23 a23; + A24 a24; + A25 a25; + A26 a26; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; + A17 a17; + A18 a18; + A19 a19; + A20 a20; + A21 a21; + A22 a22; + A23 a23; + A24 a24; + A25 a25; + A26 a26; + A27 a27; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27, typename tuple_type::transparent_reference _a28) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; + A17 a17; + A18 a18; + A19 a19; + A20 a20; + A21 a21; + A22 a22; + A23 a23; + A24 a24; + A25 a25; + A26 a26; + A27 a27; + A28 a28; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27, typename tuple_type::transparent_reference _a28, typename tuple_type::transparent_reference _a29) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28), a29(_a29) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; + A17 a17; + A18 a18; + A19 a19; + A20 a20; + A21 a21; + A22 a22; + A23 a23; + A24 a24; + A25 a25; + A26 a26; + A27 a27; + A28 a28; + A29 a29; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27, typename tuple_type::transparent_reference _a28, typename tuple_type::transparent_reference _a29, typename tuple_type::transparent_reference _a30) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28), a29(_a29), a30(_a30) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; + A17 a17; + A18 a18; + A19 a19; + A20 a20; + A21 a21; + A22 a22; + A23 a23; + A24 a24; + A25 a25; + A26 a26; + A27 a27; + A28 a28; + A29 a29; + A30 a30; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + +template +struct tuple { + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27, typename tuple_type::transparent_reference _a28, typename tuple_type::transparent_reference _a29, typename tuple_type::transparent_reference _a30, typename tuple_type::transparent_reference _a31) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28), a29(_a29), a30(_a30), a31(_a31) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; + A12 a12; + A13 a13; + A14 a14; + A15 a15; + A16 a16; + A17 a17; + A18 a18; + A19 a19; + A20 a20; + A21 a21; + A22 a22; + A23 a23; + A24 a24; + A25 a25; + A26 a26; + A27 a27; + A28 a28; + A29 a29; + A30 a30; + A31 a31; +}; + +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + + +inline tuple<> make_tuple() +{ + return tuple<>(); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0) +{ + return tuple(a0); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1) +{ + return tuple(a0, a1); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2) +{ + return tuple(a0, a1, a2); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3) +{ + return tuple(a0, a1, a2, a3); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4) +{ + return tuple(a0, a1, a2, a3, a4); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5) +{ + return tuple(a0, a1, a2, a3, a4, a5); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28, typename tuple_type::transparent_reference a29) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28, typename tuple_type::transparent_reference a29, typename tuple_type::transparent_reference a30) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30); +} + +template +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28, typename tuple_type::transparent_reference a29, typename tuple_type::transparent_reference a30, typename tuple_type::transparent_reference a31) +{ + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31); +} + + +} // namespace type + +inline object const& operator>> ( + object const& o, + type::tuple<>&) { + if(o.type != type::ARRAY) { throw type_error(); } + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 1) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 2) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 3) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 4) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 5) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 6) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 7) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 8) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 9) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 10) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 11) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 12) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 13) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 14) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 15) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 16) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 17) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 18) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 19) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 20) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 21) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 22) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 23) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + o.via.array.ptr[22].convert::type>(v.template get<22>()); + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 24) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + o.via.array.ptr[22].convert::type>(v.template get<22>()); + o.via.array.ptr[23].convert::type>(v.template get<23>()); + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 25) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + o.via.array.ptr[22].convert::type>(v.template get<22>()); + o.via.array.ptr[23].convert::type>(v.template get<23>()); + o.via.array.ptr[24].convert::type>(v.template get<24>()); + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 26) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + o.via.array.ptr[22].convert::type>(v.template get<22>()); + o.via.array.ptr[23].convert::type>(v.template get<23>()); + o.via.array.ptr[24].convert::type>(v.template get<24>()); + o.via.array.ptr[25].convert::type>(v.template get<25>()); + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 27) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + o.via.array.ptr[22].convert::type>(v.template get<22>()); + o.via.array.ptr[23].convert::type>(v.template get<23>()); + o.via.array.ptr[24].convert::type>(v.template get<24>()); + o.via.array.ptr[25].convert::type>(v.template get<25>()); + o.via.array.ptr[26].convert::type>(v.template get<26>()); + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 28) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + o.via.array.ptr[22].convert::type>(v.template get<22>()); + o.via.array.ptr[23].convert::type>(v.template get<23>()); + o.via.array.ptr[24].convert::type>(v.template get<24>()); + o.via.array.ptr[25].convert::type>(v.template get<25>()); + o.via.array.ptr[26].convert::type>(v.template get<26>()); + o.via.array.ptr[27].convert::type>(v.template get<27>()); + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 29) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + o.via.array.ptr[22].convert::type>(v.template get<22>()); + o.via.array.ptr[23].convert::type>(v.template get<23>()); + o.via.array.ptr[24].convert::type>(v.template get<24>()); + o.via.array.ptr[25].convert::type>(v.template get<25>()); + o.via.array.ptr[26].convert::type>(v.template get<26>()); + o.via.array.ptr[27].convert::type>(v.template get<27>()); + o.via.array.ptr[28].convert::type>(v.template get<28>()); + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 30) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + o.via.array.ptr[22].convert::type>(v.template get<22>()); + o.via.array.ptr[23].convert::type>(v.template get<23>()); + o.via.array.ptr[24].convert::type>(v.template get<24>()); + o.via.array.ptr[25].convert::type>(v.template get<25>()); + o.via.array.ptr[26].convert::type>(v.template get<26>()); + o.via.array.ptr[27].convert::type>(v.template get<27>()); + o.via.array.ptr[28].convert::type>(v.template get<28>()); + o.via.array.ptr[29].convert::type>(v.template get<29>()); + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 31) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + o.via.array.ptr[22].convert::type>(v.template get<22>()); + o.via.array.ptr[23].convert::type>(v.template get<23>()); + o.via.array.ptr[24].convert::type>(v.template get<24>()); + o.via.array.ptr[25].convert::type>(v.template get<25>()); + o.via.array.ptr[26].convert::type>(v.template get<26>()); + o.via.array.ptr[27].convert::type>(v.template get<27>()); + o.via.array.ptr[28].convert::type>(v.template get<28>()); + o.via.array.ptr[29].convert::type>(v.template get<29>()); + o.via.array.ptr[30].convert::type>(v.template get<30>()); + return o; +} + +template +inline object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 32) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + o.via.array.ptr[22].convert::type>(v.template get<22>()); + o.via.array.ptr[23].convert::type>(v.template get<23>()); + o.via.array.ptr[24].convert::type>(v.template get<24>()); + o.via.array.ptr[25].convert::type>(v.template get<25>()); + o.via.array.ptr[26].convert::type>(v.template get<26>()); + o.via.array.ptr[27].convert::type>(v.template get<27>()); + o.via.array.ptr[28].convert::type>(v.template get<28>()); + o.via.array.ptr[29].convert::type>(v.template get<29>()); + o.via.array.ptr[30].convert::type>(v.template get<30>()); + o.via.array.ptr[31].convert::type>(v.template get<31>()); + return o; +} + + +template +inline const packer& operator<< ( + packer& o, + const type::tuple<>&) { + o.pack_array(0); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(1); + + o.pack(v.template get<0>()); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(2); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(3); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(4); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(5); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(6); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(7); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(8); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(9); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(10); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(11); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(12); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(13); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(14); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(15); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(16); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(17); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(18); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(19); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(20); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(21); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(22); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(23); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + o.pack(v.template get<22>()); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(24); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + o.pack(v.template get<22>()); + o.pack(v.template get<23>()); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(25); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + o.pack(v.template get<22>()); + o.pack(v.template get<23>()); + o.pack(v.template get<24>()); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(26); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + o.pack(v.template get<22>()); + o.pack(v.template get<23>()); + o.pack(v.template get<24>()); + o.pack(v.template get<25>()); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(27); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + o.pack(v.template get<22>()); + o.pack(v.template get<23>()); + o.pack(v.template get<24>()); + o.pack(v.template get<25>()); + o.pack(v.template get<26>()); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(28); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + o.pack(v.template get<22>()); + o.pack(v.template get<23>()); + o.pack(v.template get<24>()); + o.pack(v.template get<25>()); + o.pack(v.template get<26>()); + o.pack(v.template get<27>()); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(29); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + o.pack(v.template get<22>()); + o.pack(v.template get<23>()); + o.pack(v.template get<24>()); + o.pack(v.template get<25>()); + o.pack(v.template get<26>()); + o.pack(v.template get<27>()); + o.pack(v.template get<28>()); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(30); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + o.pack(v.template get<22>()); + o.pack(v.template get<23>()); + o.pack(v.template get<24>()); + o.pack(v.template get<25>()); + o.pack(v.template get<26>()); + o.pack(v.template get<27>()); + o.pack(v.template get<28>()); + o.pack(v.template get<29>()); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(31); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + o.pack(v.template get<22>()); + o.pack(v.template get<23>()); + o.pack(v.template get<24>()); + o.pack(v.template get<25>()); + o.pack(v.template get<26>()); + o.pack(v.template get<27>()); + o.pack(v.template get<28>()); + o.pack(v.template get<29>()); + o.pack(v.template get<30>()); + return o; +} + +template +inline const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(32); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + o.pack(v.template get<22>()); + o.pack(v.template get<23>()); + o.pack(v.template get<24>()); + o.pack(v.template get<25>()); + o.pack(v.template get<26>()); + o.pack(v.template get<27>()); + o.pack(v.template get<28>()); + o.pack(v.template get<29>()); + o.pack(v.template get<30>()); + o.pack(v.template get<31>()); + return o; +} + + +inline void operator<< ( + object::with_zone& o, + const type::tuple<>&) { + o.type = type::ARRAY; + o.via.array.ptr = nullptr; + o.via.array.size = 0; +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*1)); + o.via.array.size = 1; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*2)); + o.via.array.size = 2; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*3)); + o.via.array.size = 3; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*4)); + o.via.array.size = 4; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*5)); + o.via.array.size = 5; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*6)); + o.via.array.size = 6; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*7)); + o.via.array.size = 7; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*8)); + o.via.array.size = 8; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*9)); + o.via.array.size = 9; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*10)); + o.via.array.size = 10; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*11)); + o.via.array.size = 11; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*12)); + o.via.array.size = 12; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*13)); + o.via.array.size = 13; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*14)); + o.via.array.size = 14; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*15)); + o.via.array.size = 15; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*16)); + o.via.array.size = 16; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*17)); + o.via.array.size = 17; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*18)); + o.via.array.size = 18; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*19)); + o.via.array.size = 19; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*20)); + o.via.array.size = 20; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*21)); + o.via.array.size = 21; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*22)); + o.via.array.size = 22; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*23)); + o.via.array.size = 23; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = object(v.template get<22>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*24)); + o.via.array.size = 24; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = object(v.template get<23>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*25)); + o.via.array.size = 25; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = object(v.template get<24>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*26)); + o.via.array.size = 26; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = object(v.template get<24>(), o.zone); + o.via.array.ptr[25] = object(v.template get<25>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*27)); + o.via.array.size = 27; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = object(v.template get<24>(), o.zone); + o.via.array.ptr[25] = object(v.template get<25>(), o.zone); + o.via.array.ptr[26] = object(v.template get<26>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*28)); + o.via.array.size = 28; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = object(v.template get<24>(), o.zone); + o.via.array.ptr[25] = object(v.template get<25>(), o.zone); + o.via.array.ptr[26] = object(v.template get<26>(), o.zone); + o.via.array.ptr[27] = object(v.template get<27>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*29)); + o.via.array.size = 29; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = object(v.template get<24>(), o.zone); + o.via.array.ptr[25] = object(v.template get<25>(), o.zone); + o.via.array.ptr[26] = object(v.template get<26>(), o.zone); + o.via.array.ptr[27] = object(v.template get<27>(), o.zone); + o.via.array.ptr[28] = object(v.template get<28>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*30)); + o.via.array.size = 30; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = object(v.template get<24>(), o.zone); + o.via.array.ptr[25] = object(v.template get<25>(), o.zone); + o.via.array.ptr[26] = object(v.template get<26>(), o.zone); + o.via.array.ptr[27] = object(v.template get<27>(), o.zone); + o.via.array.ptr[28] = object(v.template get<28>(), o.zone); + o.via.array.ptr[29] = object(v.template get<29>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*31)); + o.via.array.size = 31; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = object(v.template get<24>(), o.zone); + o.via.array.ptr[25] = object(v.template get<25>(), o.zone); + o.via.array.ptr[26] = object(v.template get<26>(), o.zone); + o.via.array.ptr[27] = object(v.template get<27>(), o.zone); + o.via.array.ptr[28] = object(v.template get<28>(), o.zone); + o.via.array.ptr[29] = object(v.template get<29>(), o.zone); + o.via.array.ptr[30] = object(v.template get<30>(), o.zone); +} + +template +inline void operator<< ( + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*32)); + o.via.array.size = 32; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = object(v.template get<24>(), o.zone); + o.via.array.ptr[25] = object(v.template get<25>(), o.zone); + o.via.array.ptr[26] = object(v.template get<26>(), o.zone); + o.via.array.ptr[27] = object(v.template get<27>(), o.zone); + o.via.array.ptr[28] = object(v.template get<28>(), o.zone); + o.via.array.ptr[29] = object(v.template get<29>(), o.zone); + o.via.array.ptr[30] = object(v.template get<30>(), o.zone); + o.via.array.ptr[31] = object(v.template get<31>(), o.zone); +} + + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + + +//inline std::ostream& operator<< (std::ostream& o, const msgpack::type::tuple<>& v) { +// return o << "[]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << ", " << v.template get<22>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << ", " << v.template get<22>() +// << ", " << v.template get<23>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << ", " << v.template get<22>() +// << ", " << v.template get<23>() +// << ", " << v.template get<24>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << ", " << v.template get<22>() +// << ", " << v.template get<23>() +// << ", " << v.template get<24>() +// << ", " << v.template get<25>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << ", " << v.template get<22>() +// << ", " << v.template get<23>() +// << ", " << v.template get<24>() +// << ", " << v.template get<25>() +// << ", " << v.template get<26>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << ", " << v.template get<22>() +// << ", " << v.template get<23>() +// << ", " << v.template get<24>() +// << ", " << v.template get<25>() +// << ", " << v.template get<26>() +// << ", " << v.template get<27>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << ", " << v.template get<22>() +// << ", " << v.template get<23>() +// << ", " << v.template get<24>() +// << ", " << v.template get<25>() +// << ", " << v.template get<26>() +// << ", " << v.template get<27>() +// << ", " << v.template get<28>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << ", " << v.template get<22>() +// << ", " << v.template get<23>() +// << ", " << v.template get<24>() +// << ", " << v.template get<25>() +// << ", " << v.template get<26>() +// << ", " << v.template get<27>() +// << ", " << v.template get<28>() +// << ", " << v.template get<29>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << ", " << v.template get<22>() +// << ", " << v.template get<23>() +// << ", " << v.template get<24>() +// << ", " << v.template get<25>() +// << ", " << v.template get<26>() +// << ", " << v.template get<27>() +// << ", " << v.template get<28>() +// << ", " << v.template get<29>() +// << ", " << v.template get<30>() +// << "]"; +//} +// +//template +//inline std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << ", " << v.template get<22>() +// << ", " << v.template get<23>() +// << ", " << v.template get<24>() +// << ", " << v.template get<25>() +// << ", " << v.template get<26>() +// << ", " << v.template get<27>() +// << ", " << v.template get<28>() +// << ", " << v.template get<29>() +// << ", " << v.template get<30>() +// << ", " << v.template get<31>() +// << "]"; +//} +// + +#endif // MSGPACK_CPP03_MSGPACK_TUPLE_HPP diff --git a/include/msgpack/adaptor/detail/cpp03_msgpack_tuple_fwd.hpp b/include/msgpack/adaptor/detail/cpp03_msgpack_tuple_fwd.hpp new file mode 100644 index 00000000..da8a9f26 --- /dev/null +++ b/include/msgpack/adaptor/detail/cpp03_msgpack_tuple_fwd.hpp @@ -0,0 +1,4341 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_CPP03_MSGPACK_TUPLE_FWD_HPP +#define MSGPACK_CPP03_MSGPACK_TUPLE_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +namespace type { + +// FIXME operator== +// FIXME operator!= + + +template +struct tuple; + +template +struct tuple_element; + +template +struct const_tuple_element; + +template +struct tuple_type; + + + +template +struct tuple_element, 0>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + +template +struct tuple_element, 17>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + +template +struct tuple_element, 17>; + +template +struct tuple_element, 18>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + +template +struct tuple_element, 17>; + +template +struct tuple_element, 18>; + +template +struct tuple_element, 19>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + +template +struct tuple_element, 17>; + +template +struct tuple_element, 18>; + +template +struct tuple_element, 19>; + +template +struct tuple_element, 20>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + +template +struct tuple_element, 17>; + +template +struct tuple_element, 18>; + +template +struct tuple_element, 19>; + +template +struct tuple_element, 20>; + +template +struct tuple_element, 21>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + +template +struct tuple_element, 17>; + +template +struct tuple_element, 18>; + +template +struct tuple_element, 19>; + +template +struct tuple_element, 20>; + +template +struct tuple_element, 21>; + +template +struct tuple_element, 22>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + +template +struct tuple_element, 17>; + +template +struct tuple_element, 18>; + +template +struct tuple_element, 19>; + +template +struct tuple_element, 20>; + +template +struct tuple_element, 21>; + +template +struct tuple_element, 22>; + +template +struct tuple_element, 23>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + +template +struct tuple_element, 17>; + +template +struct tuple_element, 18>; + +template +struct tuple_element, 19>; + +template +struct tuple_element, 20>; + +template +struct tuple_element, 21>; + +template +struct tuple_element, 22>; + +template +struct tuple_element, 23>; + +template +struct tuple_element, 24>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + +template +struct tuple_element, 17>; + +template +struct tuple_element, 18>; + +template +struct tuple_element, 19>; + +template +struct tuple_element, 20>; + +template +struct tuple_element, 21>; + +template +struct tuple_element, 22>; + +template +struct tuple_element, 23>; + +template +struct tuple_element, 24>; + +template +struct tuple_element, 25>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + +template +struct tuple_element, 17>; + +template +struct tuple_element, 18>; + +template +struct tuple_element, 19>; + +template +struct tuple_element, 20>; + +template +struct tuple_element, 21>; + +template +struct tuple_element, 22>; + +template +struct tuple_element, 23>; + +template +struct tuple_element, 24>; + +template +struct tuple_element, 25>; + +template +struct tuple_element, 26>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + +template +struct tuple_element, 17>; + +template +struct tuple_element, 18>; + +template +struct tuple_element, 19>; + +template +struct tuple_element, 20>; + +template +struct tuple_element, 21>; + +template +struct tuple_element, 22>; + +template +struct tuple_element, 23>; + +template +struct tuple_element, 24>; + +template +struct tuple_element, 25>; + +template +struct tuple_element, 26>; + +template +struct tuple_element, 27>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + +template +struct tuple_element, 17>; + +template +struct tuple_element, 18>; + +template +struct tuple_element, 19>; + +template +struct tuple_element, 20>; + +template +struct tuple_element, 21>; + +template +struct tuple_element, 22>; + +template +struct tuple_element, 23>; + +template +struct tuple_element, 24>; + +template +struct tuple_element, 25>; + +template +struct tuple_element, 26>; + +template +struct tuple_element, 27>; + +template +struct tuple_element, 28>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + +template +struct tuple_element, 17>; + +template +struct tuple_element, 18>; + +template +struct tuple_element, 19>; + +template +struct tuple_element, 20>; + +template +struct tuple_element, 21>; + +template +struct tuple_element, 22>; + +template +struct tuple_element, 23>; + +template +struct tuple_element, 24>; + +template +struct tuple_element, 25>; + +template +struct tuple_element, 26>; + +template +struct tuple_element, 27>; + +template +struct tuple_element, 28>; + +template +struct tuple_element, 29>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + +template +struct tuple_element, 17>; + +template +struct tuple_element, 18>; + +template +struct tuple_element, 19>; + +template +struct tuple_element, 20>; + +template +struct tuple_element, 21>; + +template +struct tuple_element, 22>; + +template +struct tuple_element, 23>; + +template +struct tuple_element, 24>; + +template +struct tuple_element, 25>; + +template +struct tuple_element, 26>; + +template +struct tuple_element, 27>; + +template +struct tuple_element, 28>; + +template +struct tuple_element, 29>; + +template +struct tuple_element, 30>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + +template +struct tuple_element, 17>; + +template +struct tuple_element, 18>; + +template +struct tuple_element, 19>; + +template +struct tuple_element, 20>; + +template +struct tuple_element, 21>; + +template +struct tuple_element, 22>; + +template +struct tuple_element, 23>; + +template +struct tuple_element, 24>; + +template +struct tuple_element, 25>; + +template +struct tuple_element, 26>; + +template +struct tuple_element, 27>; + +template +struct tuple_element, 28>; + +template +struct tuple_element, 29>; + +template +struct tuple_element, 30>; + +template +struct tuple_element, 31>; + + + + + +template +struct const_tuple_element, 0>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + +template +struct const_tuple_element, 17>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + +template +struct const_tuple_element, 17>; + +template +struct const_tuple_element, 18>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + +template +struct const_tuple_element, 17>; + +template +struct const_tuple_element, 18>; + +template +struct const_tuple_element, 19>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + +template +struct const_tuple_element, 17>; + +template +struct const_tuple_element, 18>; + +template +struct const_tuple_element, 19>; + +template +struct const_tuple_element, 20>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + +template +struct const_tuple_element, 17>; + +template +struct const_tuple_element, 18>; + +template +struct const_tuple_element, 19>; + +template +struct const_tuple_element, 20>; + +template +struct const_tuple_element, 21>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + +template +struct const_tuple_element, 17>; + +template +struct const_tuple_element, 18>; + +template +struct const_tuple_element, 19>; + +template +struct const_tuple_element, 20>; + +template +struct const_tuple_element, 21>; + +template +struct const_tuple_element, 22>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + +template +struct const_tuple_element, 17>; + +template +struct const_tuple_element, 18>; + +template +struct const_tuple_element, 19>; + +template +struct const_tuple_element, 20>; + +template +struct const_tuple_element, 21>; + +template +struct const_tuple_element, 22>; + +template +struct const_tuple_element, 23>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + +template +struct const_tuple_element, 17>; + +template +struct const_tuple_element, 18>; + +template +struct const_tuple_element, 19>; + +template +struct const_tuple_element, 20>; + +template +struct const_tuple_element, 21>; + +template +struct const_tuple_element, 22>; + +template +struct const_tuple_element, 23>; + +template +struct const_tuple_element, 24>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + +template +struct const_tuple_element, 17>; + +template +struct const_tuple_element, 18>; + +template +struct const_tuple_element, 19>; + +template +struct const_tuple_element, 20>; + +template +struct const_tuple_element, 21>; + +template +struct const_tuple_element, 22>; + +template +struct const_tuple_element, 23>; + +template +struct const_tuple_element, 24>; + +template +struct const_tuple_element, 25>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + +template +struct const_tuple_element, 17>; + +template +struct const_tuple_element, 18>; + +template +struct const_tuple_element, 19>; + +template +struct const_tuple_element, 20>; + +template +struct const_tuple_element, 21>; + +template +struct const_tuple_element, 22>; + +template +struct const_tuple_element, 23>; + +template +struct const_tuple_element, 24>; + +template +struct const_tuple_element, 25>; + +template +struct const_tuple_element, 26>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + +template +struct const_tuple_element, 17>; + +template +struct const_tuple_element, 18>; + +template +struct const_tuple_element, 19>; + +template +struct const_tuple_element, 20>; + +template +struct const_tuple_element, 21>; + +template +struct const_tuple_element, 22>; + +template +struct const_tuple_element, 23>; + +template +struct const_tuple_element, 24>; + +template +struct const_tuple_element, 25>; + +template +struct const_tuple_element, 26>; + +template +struct const_tuple_element, 27>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + +template +struct const_tuple_element, 17>; + +template +struct const_tuple_element, 18>; + +template +struct const_tuple_element, 19>; + +template +struct const_tuple_element, 20>; + +template +struct const_tuple_element, 21>; + +template +struct const_tuple_element, 22>; + +template +struct const_tuple_element, 23>; + +template +struct const_tuple_element, 24>; + +template +struct const_tuple_element, 25>; + +template +struct const_tuple_element, 26>; + +template +struct const_tuple_element, 27>; + +template +struct const_tuple_element, 28>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + +template +struct const_tuple_element, 17>; + +template +struct const_tuple_element, 18>; + +template +struct const_tuple_element, 19>; + +template +struct const_tuple_element, 20>; + +template +struct const_tuple_element, 21>; + +template +struct const_tuple_element, 22>; + +template +struct const_tuple_element, 23>; + +template +struct const_tuple_element, 24>; + +template +struct const_tuple_element, 25>; + +template +struct const_tuple_element, 26>; + +template +struct const_tuple_element, 27>; + +template +struct const_tuple_element, 28>; + +template +struct const_tuple_element, 29>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + +template +struct const_tuple_element, 17>; + +template +struct const_tuple_element, 18>; + +template +struct const_tuple_element, 19>; + +template +struct const_tuple_element, 20>; + +template +struct const_tuple_element, 21>; + +template +struct const_tuple_element, 22>; + +template +struct const_tuple_element, 23>; + +template +struct const_tuple_element, 24>; + +template +struct const_tuple_element, 25>; + +template +struct const_tuple_element, 26>; + +template +struct const_tuple_element, 27>; + +template +struct const_tuple_element, 28>; + +template +struct const_tuple_element, 29>; + +template +struct const_tuple_element, 30>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + +template +struct const_tuple_element, 17>; + +template +struct const_tuple_element, 18>; + +template +struct const_tuple_element, 19>; + +template +struct const_tuple_element, 20>; + +template +struct const_tuple_element, 21>; + +template +struct const_tuple_element, 22>; + +template +struct const_tuple_element, 23>; + +template +struct const_tuple_element, 24>; + +template +struct const_tuple_element, 25>; + +template +struct const_tuple_element, 26>; + +template +struct const_tuple_element, 27>; + +template +struct const_tuple_element, 28>; + +template +struct const_tuple_element, 29>; + +template +struct const_tuple_element, 30>; + +template +struct const_tuple_element, 31>; + + + +template <> +struct tuple<>; + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + + +tuple<> make_tuple(); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28, typename tuple_type::transparent_reference a29); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28, typename tuple_type::transparent_reference a29, typename tuple_type::transparent_reference a30); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28, typename tuple_type::transparent_reference a29, typename tuple_type::transparent_reference a30, typename tuple_type::transparent_reference a31); + + +} // namespace type + +object const& operator>> ( + object const& o, + type::tuple<>&); + + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + + +template +const packer& operator<< ( + packer& o, + const type::tuple<>&); + + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + + +void operator<< ( + object::with_zone& o, + const type::tuple<>&); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + + +//std::ostream& operator<< (std::ostream& o, const msgpack::type::tuple<>& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// + +#endif // MSGPACK_CPP03_MSGPACK_TUPLE_FWD_HPP diff --git a/include/msgpack/adaptor/detail/cpp11_define.hpp b/include/msgpack/adaptor/detail/cpp11_define.hpp new file mode 100644 index 00000000..6e29b4ad --- /dev/null +++ b/include/msgpack/adaptor/detail/cpp11_define.hpp @@ -0,0 +1,181 @@ +// +// 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_HPP +#define MSGPACK_CPP11_DEFINE_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +// for MSGPACK_ADD_ENUM +#include "msgpack/adaptor/int_fwd.hpp" + +#include +#include + +#define MSGPACK_DEFINE(...) \ + template \ + void msgpack_pack(Packer& pk) const \ + { \ + msgpack::type::make_define(__VA_ARGS__).msgpack_pack(pk); \ + } \ + void msgpack_unpack(msgpack::object const& o) \ + { \ + msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \ + }\ + template \ + void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone& z) const \ + { \ + msgpack::type::make_define(__VA_ARGS__).msgpack_object(o, z); \ + } + +// MSGPACK_ADD_ENUM must be used in the global namespace. +#define MSGPACK_ADD_ENUM(enum) \ + namespace msgpack { \ + MSGPACK_API_VERSION_NAMESPACE(v1) { \ + template <> \ + inline object const& operator>> (object const& o, enum& v) \ + { \ + int tmp; \ + o >> tmp; \ + v = static_cast(tmp); \ + return o; \ + } \ + template <> \ + inline void operator<< (object::with_zone& o, const enum& v) \ + { \ + int tmp = static_cast::type>(v); \ + o << tmp; \ + } \ + namespace detail { \ + template \ + struct packer_serializer { \ + static packer& pack(packer& o, const enum& v) { \ + return o << static_cast::type>(v); \ + } \ + }; \ + } \ + } \ + } + +namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { +namespace type { + +template +struct define_imp { + template + static void pack(Packer& pk, Tuple const& t) { + define_imp::pack(pk, t); + pk.pack(std::get(t)); + } + static void unpack(msgpack::object const& o, Tuple& t) { + define_imp::unpack(o, t); + const size_t size = o.via.array.size; + if(size <= N-1) { return; } + o.via.array.ptr[N-1].convert(std::get(t)); + } + static void object(msgpack::object* o, msgpack::zone& z, Tuple const& t) { + define_imp::object(o, z, t); + o->via.array.ptr[N-1] = msgpack::object(std::get(t), z); + } +}; + +template +struct define_imp { + template + static void pack(Packer& pk, Tuple const& t) { + pk.pack(std::get<0>(t)); + } + static void unpack(msgpack::object const& o, Tuple& t) { + const size_t size = o.via.array.size; + if(size <= 0) { return; } + o.via.array.ptr[0].convert(std::get<0>(t)); + } + static void object(msgpack::object* o, msgpack::zone& z, Tuple const& t) { + o->via.array.ptr[0] = msgpack::object(std::get<0>(t), z); + } +}; + +template +struct define { + typedef define value_type; + typedef std::tuple tuple_type; + define(Args&... args) : + a(args...) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(sizeof...(Args)); + + define_imp, sizeof...(Args)>::pack(pk, a); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + + define_imp, sizeof...(Args)>::unpack(o, a); + } + void msgpack_object(msgpack::object* o, msgpack::zone& z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*sizeof...(Args))); + o->via.array.size = sizeof...(Args); + + define_imp, sizeof...(Args)>::object(o, z, a); + } + + std::tuple a; +}; + +template <> +struct define<> { + typedef define<> value_type; + typedef std::tuple<> tuple_type; + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(0); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + } + void msgpack_object(msgpack::object* o, msgpack::zone&) const + { + o->type = type::ARRAY; + o->via.array.ptr = NULL; + o->via.array.size = 0; + } +}; + +inline define<> make_define() +{ + return define<>(); +} + +template +define make_define(Args&... args) +{ + return define(args...); +} + +} // namespace type +} // MSGPACK_API_VERSION_NAMESPACE(v1) +} // namespace msgpack + +#endif // MSGPACK_CPP11_DEFINE_HPP diff --git a/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp b/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp new file mode 100644 index 00000000..3b532d87 --- /dev/null +++ b/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp @@ -0,0 +1,212 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_CPP11_MSGPACK_TUPLE_HPP +#define MSGPACK_CPP11_MSGPACK_TUPLE_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +namespace type { + // tuple + using std::get; + using std::tuple_size; + using std::tuple_element; + using std::uses_allocator; + using std::ignore; + using std::make_tuple; + using std::tie; + using std::forward_as_tuple; + using std::swap; + + template< class... Types > + class tuple : public std::tuple { + public: + using base = std::tuple; + + using base::tuple; + + tuple() = default; + tuple(tuple const&) = default; + tuple(tuple&&) = default; + + template + tuple(tuple const& other):base(static_cast const&>(other)) {} + template + tuple(tuple && other):base(static_cast &&>(other)) {} + + tuple& operator=(tuple const&) = default; + tuple& operator=(tuple&&) = default; + + template + tuple& operator=(tuple const& other) { + *static_cast(this) = static_cast const&>(other); + return *this; + } + template + tuple& operator=(tuple && other) { + *static_cast(this) = static_cast &&>(other); + return *this; + } + + template< std::size_t I> + typename tuple_element::type& + get() { return std::get(*this); } + + template< std::size_t I> + typename tuple_element::type const& + get() const { return std::get(*this); } + + template< std::size_t I> + typename tuple_element::type&& + get() && { return std::get(*this); } + }; + + template< class... Tuples > + auto tuple_cat(Tuples&&... args) -> + decltype( + std::tuple_cat(std::forward::type::base>(args)...) + ) { + return std::tuple_cat(std::forward::type::base>(args)...); + } +} // namespace type + +// --- Pack ( from tuple to packer stream --- +template +struct MsgpackTuplePacker { + static void pack( + packer& o, + const Tuple& v) { + MsgpackTuplePacker::pack(o, v); + o.pack(type::get(v)); + } +}; + +template +struct MsgpackTuplePacker { + static void pack ( + packer& o, + const Tuple& v) { + o.pack(type::get<0>(v)); + } +}; + +template +struct MsgpackTuplePacker { + static void pack ( + packer&, + const Tuple&) { + } +}; + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(sizeof...(Args)); + MsgpackTuplePacker::pack(o, v); + return o; +} + +// --- Convert from tuple to object --- + +template +struct MsgpackTupleConverter { + static void convert( + object const& o, + Tuple& v) { + MsgpackTupleConverter::convert(o, v); + o.via.array.ptr[N-1].convert(v))>::type>(type::get(v)); + } +}; + +template +struct MsgpackTupleConverter { + static void convert ( + object const& o, + Tuple& v) { + o.via.array.ptr[0].convert(v))>::type>(type::get<0>(v)); + } +}; + +template +struct MsgpackTupleConverter { + static void convert ( + object const&, + Tuple&) { + } +}; + +template +object const& operator>> ( + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < sizeof...(Args)) { throw type_error(); } + MsgpackTupleConverter::convert(o, v); + return o; +} + +// --- Convert from tuple to object with zone --- +template +struct MsgpackTupleToObjectWithZone { + static void convert( + object::with_zone& o, + const Tuple& v) { + MsgpackTupleToObjectWithZone::convert(o, v); + o.via.array.ptr[N-1] = object(type::get(v), o.zone); + } +}; + +template +struct MsgpackTupleToObjectWithZone { + static void convert ( + object::with_zone& o, + const Tuple& v) { + o.via.array.ptr[0] = object(type::get<0>(v), o.zone); + } +}; + +template +struct MsgpackTupleToObjectWithZone { + static void convert ( + object::with_zone&, + const Tuple&) { + } +}; + +template +inline void operator<< ( + object::with_zone& o, + type::tuple const& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*sizeof...(Args))); + o.via.array.size = sizeof...(Args); + MsgpackTupleToObjectWithZone::convert(o, v); +} + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_CPP11_MSGPACK_TUPLE_HPP diff --git a/include/msgpack/adaptor/detail/cpp11_msgpack_tuple_fwd.hpp b/include/msgpack/adaptor/detail/cpp11_msgpack_tuple_fwd.hpp new file mode 100644 index 00000000..b9f148ef --- /dev/null +++ b/include/msgpack/adaptor/detail/cpp11_msgpack_tuple_fwd.hpp @@ -0,0 +1,84 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_CPP11_MSGPACK_TUPLE_FWD_HPP +#define MSGPACK_CPP11_MSGPACK_TUPLE_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +namespace type { + // tuple + using std::get; + using std::tuple_size; + using std::tuple_element; + using std::uses_allocator; + using std::ignore; + using std::make_tuple; + using std::tie; + using std::forward_as_tuple; + using std::swap; + + template< class... Types > + class tuple; + + template< class... Tuples > + auto tuple_cat(Tuples&&... args) -> + decltype( + std::tuple_cat(std::forward::type::base>(args)...) + ); +} // namespace type + +// --- Pack ( from tuple to packer stream --- +template +struct MsgpackTuplePacker; + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +// --- Convert from tuple to object --- + +template +struct MsgpackTupleConverter; + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +// --- Convert from tuple to object with zone --- +template +struct MsgpackTupleToObjectWithZone; + +template +void operator<< ( + object::with_zone& o, + type::tuple const& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_CPP11_MSGPACK_TUPLE_FWD_HPP diff --git a/include/msgpack/adaptor/fixint.hpp b/include/msgpack/adaptor/fixint.hpp new file mode 100644 index 00000000..eb7f7a8a --- /dev/null +++ b/include/msgpack/adaptor/fixint.hpp @@ -0,0 +1,212 @@ +// +// 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 "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include "msgpack/adaptor/int.hpp" + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +namespace type { + + +template +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 fix_uint8; +typedef fix_int fix_uint16; +typedef fix_int fix_uint32; +typedef fix_int fix_uint64; + +typedef fix_int fix_int8; +typedef fix_int fix_int16; +typedef fix_int fix_int32; +typedef fix_int fix_int64; + + +} // namespace type + + +inline object const& operator>> (object const& o, type::fix_int8& v) + { v = type::detail::convert_integer(o); return o; } + +inline object const& operator>> (object const& o, type::fix_int16& v) + { v = type::detail::convert_integer(o); return o; } + +inline object const& operator>> (object const& o, type::fix_int32& v) + { v = type::detail::convert_integer(o); return o; } + +inline object const& operator>> (object const& o, type::fix_int64& v) + { v = type::detail::convert_integer(o); return o; } + + +inline object const& operator>> (object const& o, type::fix_uint8& v) + { v = type::detail::convert_integer(o); return o; } + +inline object const& operator>> (object const& o, type::fix_uint16& v) + { v = type::detail::convert_integer(o); return o; } + +inline object const& operator>> (object const& o, type::fix_uint32& v) + { v = type::detail::convert_integer(o); return o; } + +inline object const& operator>> (object const& o, type::fix_uint64& v) + { v = type::detail::convert_integer(o); return o; } + + +template +inline packer& operator<< (packer& o, const type::fix_int8& v) + { o.pack_fix_int8(v); return o; } + +template +inline packer& operator<< (packer& o, const type::fix_int16& v) + { o.pack_fix_int16(v); return o; } + +template +inline packer& operator<< (packer& o, const type::fix_int32& v) + { o.pack_fix_int32(v); return o; } + +template +inline packer& operator<< (packer& o, const type::fix_int64& v) + { o.pack_fix_int64(v); return o; } + + +template +inline packer& operator<< (packer& o, const type::fix_uint8& v) + { o.pack_fix_uint8(v); return o; } + +template +inline packer& operator<< (packer& o, const type::fix_uint16& v) + { o.pack_fix_uint16(v); return o; } + +template +inline packer& operator<< (packer& o, const type::fix_uint32& v) + { o.pack_fix_uint32(v); return o; } + +template +inline packer& operator<< (packer& o, const type::fix_uint64& v) + { o.pack_fix_uint64(v); return o; } + + +inline void operator<< (object& o, type::fix_int8 v) +{ + if (v.get() < 0) { + o.type = type::NEGATIVE_INTEGER; + o.via.i64 = v.get(); + } + else { + o.type = type::POSITIVE_INTEGER; + o.via.u64 = v.get(); + } +} + +inline void operator<< (object& o, type::fix_int16 v) +{ + if(v.get() < 0) { + o.type = type::NEGATIVE_INTEGER; + o.via.i64 = v.get(); + } + else { + o.type = type::POSITIVE_INTEGER; + o.via.u64 = v.get(); + } +} + +inline void operator<< (object& o, type::fix_int32 v) +{ + if (v.get() < 0) { + o.type = type::NEGATIVE_INTEGER; + o.via.i64 = v.get(); + } + else { + o.type = type::POSITIVE_INTEGER; + o.via.u64 = v.get(); + } +} + +inline void operator<< (object& o, type::fix_int64 v) +{ + if (v.get() < 0) { + o.type = type::NEGATIVE_INTEGER; + o.via.i64 = v.get(); + } + else { + o.type = type::POSITIVE_INTEGER; + o.via.u64 = v.get(); + } +} + + +inline void operator<< (object& o, type::fix_uint8 v) + { o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); } + +inline void operator<< (object& o, type::fix_uint16 v) + { o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); } + +inline void operator<< (object& o, type::fix_uint32 v) + { o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); } + +inline void operator<< (object& o, type::fix_uint64 v) + { o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); } + + +inline void operator<< (object::with_zone& o, type::fix_int8 v) + { static_cast(o) << v; } + +inline void operator<< (object::with_zone& o, type::fix_int16 v) + { static_cast(o) << v; } + +inline void operator<< (object::with_zone& o, type::fix_int32 v) + { static_cast(o) << v; } + +inline void operator<< (object::with_zone& o, type::fix_int64 v) + { static_cast(o) << v; } + + +inline void operator<< (object::with_zone& o, type::fix_uint8 v) + { static_cast(o) << v; } + +inline void operator<< (object::with_zone& o, type::fix_uint16 v) + { static_cast(o) << v; } + +inline void operator<< (object::with_zone& o, type::fix_uint32 v) + { static_cast(o) << v; } + +inline void operator<< (object::with_zone& o, type::fix_uint64 v) + { static_cast(o) << v; } + + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif /* msgpack/type/fixint.hpp */ diff --git a/include/msgpack/adaptor/fixint_fwd.hpp b/include/msgpack/adaptor/fixint_fwd.hpp new file mode 100644 index 00000000..cad85ebe --- /dev/null +++ b/include/msgpack/adaptor/fixint_fwd.hpp @@ -0,0 +1,100 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_FIXINT_FWD_HPP +#define MSGPACK_TYPE_FIXINT_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +namespace type { + + +template +struct fix_int; + +typedef fix_int fix_uint8; +typedef fix_int fix_uint16; +typedef fix_int fix_uint32; +typedef fix_int fix_uint64; + +typedef fix_int fix_int8; +typedef fix_int fix_int16; +typedef fix_int fix_int32; +typedef fix_int fix_int64; + + +} // namespace type + + +object const& operator>> (object const& o, type::fix_int8& v); +object const& operator>> (object const& o, type::fix_int16& v); +object const& operator>> (object const& o, type::fix_int32& v); +object const& operator>> (object const& o, type::fix_int64& v); + +object const& operator>> (object const& o, type::fix_uint8& v); +object const& operator>> (object const& o, type::fix_uint16& v); +object const& operator>> (object const& o, type::fix_uint32& v); +object const& operator>> (object const& o, type::fix_uint64& v); + +template +packer& operator<< (packer& o, const type::fix_int8& v); +template +packer& operator<< (packer& o, const type::fix_int16& v); +template +packer& operator<< (packer& o, const type::fix_int32& v); +template +packer& operator<< (packer& o, const type::fix_int64& v); + +template +packer& operator<< (packer& o, const type::fix_uint8& v); +template +packer& operator<< (packer& o, const type::fix_uint16& v); +template +packer& operator<< (packer& o, const type::fix_uint32& v); +template +packer& operator<< (packer& o, const type::fix_uint64& v); + +void operator<< (object& o, type::fix_int8 v); +void operator<< (object& o, type::fix_int16 v); +void operator<< (object& o, type::fix_int32 v); +void operator<< (object& o, type::fix_int64 v); + +void operator<< (object& o, type::fix_uint8 v); +void operator<< (object& o, type::fix_uint16 v); +void operator<< (object& o, type::fix_uint32 v); +void operator<< (object& o, type::fix_uint64 v); + +void operator<< (object::with_zone& o, type::fix_int8 v); +void operator<< (object::with_zone& o, type::fix_int16 v); +void operator<< (object::with_zone& o, type::fix_int32 v); +void operator<< (object::with_zone& o, type::fix_int64 v); + +void operator<< (object::with_zone& o, type::fix_uint8 v); +void operator<< (object::with_zone& o, type::fix_uint16 v); +void operator<< (object::with_zone& o, type::fix_uint32 v); +void operator<< (object::with_zone& o, type::fix_uint64 v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_FIXINT_FWD_HPP diff --git a/include/msgpack/adaptor/float.hpp b/include/msgpack/adaptor/float.hpp new file mode 100644 index 00000000..8191db91 --- /dev/null +++ b/include/msgpack/adaptor/float.hpp @@ -0,0 +1,105 @@ +// +// 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 "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +// FIXME check overflow, underflow + + +inline object const& operator>> (object const& o, float& v) +{ + if(o.type == type::DOUBLE) { + v = static_cast(o.via.dec); + } + else if (o.type == type::POSITIVE_INTEGER) { + v = static_cast(o.via.u64); + } + else if (o.type == type::NEGATIVE_INTEGER) { + v = static_cast(o.via.i64); + } + else { + throw type_error(); + } + return o; +} + +template +inline packer& operator<< (packer& o, const float& v) +{ + o.pack_float(v); + return o; +} + + +inline object const& operator>> (object const& o, double& v) +{ + if(o.type == type::DOUBLE) { + v = o.via.dec; + } + else if (o.type == type::POSITIVE_INTEGER) { + v = static_cast(o.via.u64); + } + else if (o.type == type::NEGATIVE_INTEGER) { + v = static_cast(o.via.i64); + } + else { + throw type_error(); + } + return o; +} + +template +inline packer& operator<< (packer& o, const double& v) +{ + o.pack_double(v); + return o; +} + + +inline void operator<< (object& o, float v) +{ + o.type = type::DOUBLE; + o.via.dec = static_cast(v); +} + +inline void operator<< (object& o, double v) +{ + o.type = type::DOUBLE; + o.via.dec = v; +} + +inline void operator<< (object::with_zone& o, float v) + { static_cast(o) << v; } + +inline void operator<< (object::with_zone& o, double v) + { static_cast(o) << v; } + + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_FLOAT_HPP diff --git a/include/msgpack/adaptor/float_fwd.hpp b/include/msgpack/adaptor/float_fwd.hpp new file mode 100644 index 00000000..5eb9bafb --- /dev/null +++ b/include/msgpack/adaptor/float_fwd.hpp @@ -0,0 +1,44 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_FLOAT_FWD_HPP +#define MSGPACK_TYPE_FLOAT_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +object const& operator>> (object const& o, float& v); +template +packer& operator<< (packer& o, const float& v); +object const& operator>> (object const& o, double& v); +template +packer& operator<< (packer& o, const double& v); +void operator<< (object& o, float v); +void operator<< (object& o, double v); +void operator<< (object::with_zone& o, float v); +void operator<< (object::with_zone& o, double v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_FLOAT_FWD_HPP diff --git a/include/msgpack/adaptor/int.hpp b/include/msgpack/adaptor/int.hpp new file mode 100644 index 00000000..51c0021e --- /dev/null +++ b/include/msgpack/adaptor/int.hpp @@ -0,0 +1,332 @@ +// +// 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 "msgpack/versioning.hpp" +#include "msgpack_fwd.hpp" +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1){ + +namespace type { +namespace detail { + template + struct convert_integer_sign; + + template + struct convert_integer_sign { + static inline T convert(object const& o) { + if(o.type == type::POSITIVE_INTEGER) { + if(o.via.u64 > static_cast(std::numeric_limits::max())) + { throw type_error(); } + return static_cast(o.via.u64); + } else if(o.type == type::NEGATIVE_INTEGER) { + if(o.via.i64 < static_cast(std::numeric_limits::min())) + { throw type_error(); } + return static_cast(o.via.i64); + } + throw type_error(); + } + }; + + template + struct convert_integer_sign { + static inline T convert(object const& o) { + if(o.type == type::POSITIVE_INTEGER) { + if(o.via.u64 > static_cast(std::numeric_limits::max())) + { throw type_error(); } + return static_cast(o.via.u64); + } + throw type_error(); + } + }; + + template + struct is_signed { + static const bool value = std::numeric_limits::is_signed; + }; + + template + static inline T convert_integer(object const& o) + { + return detail::convert_integer_sign::value>::convert(o); + } + + template + struct pack_char_sign; + + template <> + struct pack_char_sign { + template + static inline packer& pack(packer& o, char v) { + o.pack_int8(v); return o; + } + }; + + template <> + struct pack_char_sign { + template + static inline packer& pack(packer& o, char v) { + o.pack_uint8(v); return o; + } + }; + + template + static inline packer& pack_char(packer& o, char v) { + return pack_char_sign::value>::pack(o, v); + } + + template + struct object_char_sign; + + template <> + struct object_char_sign { + static inline void make(object& o, char v) { + if (v < 0) { + o.type = type::NEGATIVE_INTEGER; + o.via.i64 = v; + } + else { + o.type = type::POSITIVE_INTEGER; + o.via.u64 = v; + } + } + }; + + template <> + struct object_char_sign { + static inline void make(object& o, char v) { + o.type = type::POSITIVE_INTEGER, o.via.u64 = v; + } + }; + + static inline void object_char(object& o, char v) { + return object_char_sign::value>::make(o, v); + } + +} // namespace detail +} // namespace type + +inline object const& operator>> (object const& o, char& v) + { v = type::detail::convert_integer(o); return o; } + + +inline object const& operator>> (object const& o, signed char& v) + { v = type::detail::convert_integer(o); return o; } + +inline object const& operator>> (object const& o, signed short& v) + { v = type::detail::convert_integer(o); return o; } + +inline object const& operator>> (object const& o, signed int& v) + { v = type::detail::convert_integer(o); return o; } + +inline object const& operator>> (object const& o, signed long& v) + { v = type::detail::convert_integer(o); return o; } + +inline object const& operator>> (object const& o, signed long long& v) + { v = type::detail::convert_integer(o); return o; } + + +inline object const& operator>> (object const& o, unsigned char& v) + { v = type::detail::convert_integer(o); return o; } + +inline object const& operator>> (object const& o, unsigned short& v) + { v = type::detail::convert_integer(o); return o; } + +inline object const& operator>> (object const& o, unsigned int& v) + { v = type::detail::convert_integer(o); return o; } + +inline object const& operator>> (object const& o, unsigned long& v) + { v = type::detail::convert_integer(o); return o; } + +inline object const& operator>> (object const& o, unsigned long long& v) + { v = type::detail::convert_integer(o); return o; } + + +template +inline packer& operator<< (packer& o, char v) + { return type::detail::pack_char(o, v); } + + +template +inline packer& operator<< (packer& o, signed char v) + { o.pack_int8(v); return o; } + +template +inline packer& operator<< (packer& o, signed short v) + { o.pack_short(v); return o; } + +template +inline packer& operator<< (packer& o, signed int v) + { o.pack_int(v); return o; } + +template +inline packer& operator<< (packer& o, signed long v) + { o.pack_long(v); return o; } + +template +inline packer& operator<< (packer& o, signed long long v) + { o.pack_long_long(v); return o; } + + +template +inline packer& operator<< (packer& o, unsigned char v) + { o.pack_uint8(v); return o; } + +template +inline packer& operator<< (packer& o, unsigned short v) + { o.pack_unsigned_short(v); return o; } + +template +inline packer& operator<< (packer& o, unsigned int v) + { o.pack_unsigned_int(v); return o; } + +template +inline packer& operator<< (packer& o, unsigned long v) + { o.pack_unsigned_long(v); return o; } + +template +inline packer& operator<< (packer& o, unsigned long long v) + { o.pack_unsigned_long_long(v); return o; } + + +inline void operator<< (object& o, char v) + { type::detail::object_char(o, v); } + + +inline void operator<< (object& o, signed char v) +{ + if (v < 0) { + o.type = type::NEGATIVE_INTEGER; + o.via.i64 = v; + } + else { + o.type = type::POSITIVE_INTEGER; + o.via.u64 = v; + } +} + +inline void operator<< (object& o, signed short v) +{ + if (v < 0) { + o.type = type::NEGATIVE_INTEGER; + o.via.i64 = v; + } + else { + o.type = type::POSITIVE_INTEGER; + o.via.u64 = v; + } +} + +inline void operator<< (object& o, signed int v) +{ + if (v < 0) { + o.type = type::NEGATIVE_INTEGER; + o.via.i64 = v; + } + else { + o.type = type::POSITIVE_INTEGER; + o.via.u64 = v; + } +} + +inline void operator<< (object& o, signed long v) +{ + if (v < 0) { + o.type = type::NEGATIVE_INTEGER; + o.via.i64 = v; + } + else { + o.type = type::POSITIVE_INTEGER; + o.via.u64 = v; + } +} + +inline void operator<< (object& o, signed long long v) +{ + if (v < 0) { + o.type = type::NEGATIVE_INTEGER; + o.via.i64 = v; + } + else{ + o.type = type::POSITIVE_INTEGER; + o.via.u64 = v; + } +} + +inline void operator<< (object& o, unsigned char v) + { o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } + +inline void operator<< (object& o, unsigned short v) + { o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } + +inline void operator<< (object& o, unsigned int v) + { o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } + +inline void operator<< (object& o, unsigned long v) + { o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } + +inline void operator<< (object& o, unsigned long long v) + { o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } + + + +inline void operator<< (object::with_zone& o, char v) + { static_cast(o) << v; } + + +inline void operator<< (object::with_zone& o, signed char v) + { static_cast(o) << v; } + +inline void operator<< (object::with_zone& o, signed short v) + { static_cast(o) << v; } + +inline void operator<< (object::with_zone& o, signed int v) + { static_cast(o) << v; } + +inline void operator<< (object::with_zone& o, signed long v) + { static_cast(o) << v; } + +inline void operator<< (object::with_zone& o, const signed long long& v) + { static_cast(o) << v; } + + +inline void operator<< (object::with_zone& o, unsigned char v) + { static_cast(o) << v; } + +inline void operator<< (object::with_zone& o, unsigned short v) + { static_cast(o) << v; } + +inline void operator<< (object::with_zone& o, unsigned int v) + { static_cast(o) << v; } + +inline void operator<< (object::with_zone& o, unsigned long v) + { static_cast(o) << v; } + +inline void operator<< (object::with_zone& o, const unsigned long long& v) + { static_cast(o) << v; } + + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif /* msgpack/type/int.hpp */ diff --git a/include/msgpack/adaptor/int_fwd.hpp b/include/msgpack/adaptor/int_fwd.hpp new file mode 100644 index 00000000..682f6b8e --- /dev/null +++ b/include/msgpack/adaptor/int_fwd.hpp @@ -0,0 +1,100 @@ +// +// MessagePack for C++ forward declaration +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_INT_FWD_HPP +#define MSGPACK_TYPE_INT_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1){ + +object const& operator>> (object const& o, char& v); + +object const& operator>> (object const& o, signed char& v); +object const& operator>> (object const& o, signed short& v); +object const& operator>> (object const& o, signed int& v); +object const& operator>> (object const& o, signed long& v); +object const& operator>> (object const& o, signed long long& v); + +object const& operator>> (object const& o, unsigned char& v); +object const& operator>> (object const& o, unsigned short& v); +object const& operator>> (object const& o, unsigned int& v); +object const& operator>> (object const& o, unsigned long& v); +object const& operator>> (object const& o, unsigned long long& v); + +template +packer& operator<< (packer& o, char v); + +template +packer& operator<< (packer& o, signed char v); +template +packer& operator<< (packer& o, signed short v); +template +packer& operator<< (packer& o, signed int v); +template +packer& operator<< (packer& o, signed long v); +template +packer& operator<< (packer& o, signed long long v); + +template +packer& operator<< (packer& o, unsigned char v); +template +packer& operator<< (packer& o, unsigned short v); +template +packer& operator<< (packer& o, unsigned int v); +template +packer& operator<< (packer& o, unsigned long v); +template +packer& operator<< (packer& o, unsigned long long v); + + +void operator<< (object& o, char v); + +void operator<< (object& o, signed char v); +void operator<< (object& o, signed short v); +void operator<< (object& o, signed int v); +void operator<< (object& o, signed long v); +void operator<< (object& o, signed long long v); + +void operator<< (object& o, unsigned char v); +void operator<< (object& o, unsigned short v); +void operator<< (object& o, unsigned int v); +void operator<< (object& o, unsigned long v); +void operator<< (object& o, unsigned long long v); + +void operator<< (object::with_zone& o, char v); + +void operator<< (object::with_zone& o, signed char v); +void operator<< (object::with_zone& o, signed short v); +void operator<< (object::with_zone& o, signed int v); +void operator<< (object::with_zone& o, signed long v); +void operator<< (object::with_zone& o, const signed long long& v); + +void operator<< (object::with_zone& o, unsigned char v); +void operator<< (object::with_zone& o, unsigned short v); +void operator<< (object::with_zone& o, unsigned int v); +void operator<< (object::with_zone& o, unsigned long v); +void operator<< (object::with_zone& o, const unsigned long long& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_INT_FWD_HPP diff --git a/include/msgpack/adaptor/list.hpp b/include/msgpack/adaptor/list.hpp new file mode 100644 index 00000000..321f531b --- /dev/null +++ b/include/msgpack/adaptor/list.hpp @@ -0,0 +1,79 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2009 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_LIST_HPP +#define MSGPACK_TYPE_LIST_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +inline object const& operator>> (object const& o, std::list& v) +{ + if(o.type != type::ARRAY) { throw type_error(); } + v.resize(o.via.array.size); + object* p = o.via.array.ptr; + object* const pend = o.via.array.ptr + o.via.array.size; + typename std::list::iterator it = v.begin(); + for(; p < pend; ++p, ++it) { + p->convert(*it); + } + return o; +} + +template +inline packer& operator<< (packer& o, const std::list& v) +{ + o.pack_array(v.size()); + for(typename std::list::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(*it); + } + return o; +} + +template +inline void operator<< (object::with_zone& o, const std::list& v) +{ + o.type = type::ARRAY; + if(v.empty()) { + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } else { + object* p = static_cast(o.zone.allocate_align(sizeof(object)*v.size())); + object* const pend = p + v.size(); + o.via.array.ptr = p; + o.via.array.size = v.size(); + typename std::list::const_iterator it(v.begin()); + do { + *p = object(*it, o.zone); + ++p; + ++it; + } while(p < pend); + } +} + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_LIST_HPP diff --git a/include/msgpack/adaptor/list_fwd.hpp b/include/msgpack/adaptor/list_fwd.hpp new file mode 100644 index 00000000..814a21a0 --- /dev/null +++ b/include/msgpack/adaptor/list_fwd.hpp @@ -0,0 +1,40 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2009 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_LIST_FWD_HPP +#define MSGPACK_TYPE_LIST_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +object const& operator>> (object const& o, std::list& v); +template +packer& operator<< (packer& o, const std::list& v); +template +void operator<< (object::with_zone& o, const std::list& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_LIST_FWD_HPP diff --git a/include/msgpack/adaptor/map.hpp b/include/msgpack/adaptor/map.hpp new file mode 100644 index 00000000..c8e5c22f --- /dev/null +++ b/include/msgpack/adaptor/map.hpp @@ -0,0 +1,211 @@ +// +// 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_MAP_HPP +#define MSGPACK_TYPE_MAP_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include +#include +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +namespace type { + +template +class assoc_vector : public std::vector< std::pair > {}; + +namespace detail { + template + struct pair_first_less { + bool operator() (const std::pair& x, const std::pair& y) const + { return x.first < y.first; } + }; +} + +} //namespace type + + +template +inline object const& operator>> (object const& o, type::assoc_vector& v) +{ + if(o.type != type::MAP) { throw type_error(); } + v.resize(o.via.map.size); + object_kv* p = o.via.map.ptr; + object_kv* const pend = o.via.map.ptr + o.via.map.size; + std::pair* it(&v.front()); + for(; p < pend; ++p, ++it) { + p->key.convert(it->first); + p->val.convert(it->second); + } + std::sort(v.begin(), v.end(), type::detail::pair_first_less()); + return o; +} + +template +inline packer& operator<< (packer& o, const type::assoc_vector& v) +{ + o.pack_map(v.size()); + for(typename type::assoc_vector::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(it->first); + o.pack(it->second); + } + return o; +} + +template +inline void operator<< (object::with_zone& o, const type::assoc_vector& v) +{ + o.type = type::MAP; + if(v.empty()) { + o.via.map.ptr = nullptr; + o.via.map.size = 0; + } else { + object_kv* p = static_cast(o.zone.allocate_align(sizeof(object_kv)*v.size())); + object_kv* const pend = p + v.size(); + o.via.map.ptr = p; + o.via.map.size = v.size(); + typename type::assoc_vector::const_iterator it(v.begin()); + do { + p->key = object(it->first, o.zone); + p->val = object(it->second, o.zone); + ++p; + ++it; + } while(p < pend); + } +} + + +template +inline object const& operator>> (object const& o, std::map& v) +{ + if(o.type != type::MAP) { throw type_error(); } + object_kv* p(o.via.map.ptr); + object_kv* const pend(o.via.map.ptr + o.via.map.size); + std::map tmp; + for(; p != pend; ++p) { + K key; + p->key.convert(key); + typename std::map::iterator it(tmp.lower_bound(key)); + if(it != tmp.end() && !(key < it->first)) { + p->val.convert(it->second); + } else { + V val; + p->val.convert(val); + tmp.insert(it, std::pair(key, val)); + } + } + tmp.swap(v); + return o; +} + +template +inline packer& operator<< (packer& o, const std::map& v) +{ + o.pack_map(v.size()); + for(typename std::map::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(it->first); + o.pack(it->second); + } + return o; +} + +template +inline void operator<< (object::with_zone& o, const std::map& v) +{ + o.type = type::MAP; + if(v.empty()) { + o.via.map.ptr = nullptr; + o.via.map.size = 0; + } else { + object_kv* p = static_cast(o.zone.allocate_align(sizeof(object_kv)*v.size())); + object_kv* const pend = p + v.size(); + o.via.map.ptr = p; + o.via.map.size = v.size(); + typename std::map::const_iterator it(v.begin()); + do { + p->key = object(it->first, o.zone); + p->val = object(it->second, o.zone); + ++p; + ++it; + } while(p < pend); + } +} + + +template +inline object const& operator>> (object const& o, std::multimap& v) +{ + if(o.type != type::MAP) { throw type_error(); } + object_kv* p(o.via.map.ptr); + object_kv* const pend(o.via.map.ptr + o.via.map.size); + std::multimap tmp; + for(; p != pend; ++p) { + std::pair value; + p->key.convert(value.first); + p->val.convert(value.second); + tmp.insert(value); + } + tmp.swap(v); + return o; +} + +template +inline packer& operator<< (packer& o, const std::multimap& v) +{ + o.pack_map(v.size()); + for(typename std::multimap::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(it->first); + o.pack(it->second); + } + return o; +} + +template +inline void operator<< (object::with_zone& o, const std::multimap& v) +{ + o.type = type::MAP; + if(v.empty()) { + o.via.map.ptr = nullptr; + o.via.map.size = 0; + } else { + object_kv* p = static_cast(o.zone.allocate_align(sizeof(object_kv)*v.size())); + object_kv* const pend = p + v.size(); + o.via.map.ptr = p; + o.via.map.size = v.size(); + typename std::multimap::const_iterator it(v.begin()); + do { + p->key = object(it->first, o.zone); + p->val = object(it->second, o.zone); + ++p; + ++it; + } while(p < pend); + } +} + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_MAP_HPP diff --git a/include/msgpack/adaptor/map_fwd.hpp b/include/msgpack/adaptor/map_fwd.hpp new file mode 100644 index 00000000..fe5cc6b0 --- /dev/null +++ b/include/msgpack/adaptor/map_fwd.hpp @@ -0,0 +1,69 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_MAP_FWD_HPP +#define MSGPACK_TYPE_MAP_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include +#include +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +namespace type { + +template +class assoc_vector; + +namespace detail { + template + struct pair_first_less; +} // namespace detail + +} // namespace type + + +template +object const& operator>> (object const& o, type::assoc_vector& v); +template +packer& operator<< (packer& o, const type::assoc_vector& v); +template +void operator<< (object::with_zone& o, const type::assoc_vector& v); + +template +object const& operator>> (object const& o, std::map& v); +template +packer& operator<< (packer& o, const std::map& v); +template +void operator<< (object::with_zone& o, const std::map& v); + +template +object const& operator>> (object const& o, std::multimap& v); +template +packer& operator<< (packer& o, const std::multimap& v); +template +void operator<< (object::with_zone& o, const std::multimap& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_MAP_HPP diff --git a/include/msgpack/adaptor/msgpack_tuple.hpp b/include/msgpack/adaptor/msgpack_tuple.hpp new file mode 100644 index 00000000..57fd4ba5 --- /dev/null +++ b/include/msgpack/adaptor/msgpack_tuple.hpp @@ -0,0 +1,29 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_MSGPACK_TUPLE_HPP +#define MSGPACK_MSGPACK_TUPLE_HPP + +#include "msgpack/cpp_config.hpp" + +#if defined(MSGPACK_USE_CPP03) +#include "detail/cpp03_msgpack_tuple.hpp" +#else // MSGPACK_USE_CPP03 +#include "detail/cpp11_msgpack_tuple.hpp" +#endif // MSGPACK_USE_CPP03 + +#endif // MSGPACK_MSGPACK_TUPLE_HPP diff --git a/include/msgpack/adaptor/msgpack_tuple_fwd.hpp b/include/msgpack/adaptor/msgpack_tuple_fwd.hpp new file mode 100644 index 00000000..12ea8e9b --- /dev/null +++ b/include/msgpack/adaptor/msgpack_tuple_fwd.hpp @@ -0,0 +1,29 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_MSGPACK_TUPLE_FWD_HPP +#define MSGPACK_MSGPACK_TUPLE_FWD_HPP + +#include "msgpack/cpp_config.hpp" + +#if defined(MSGPACK_USE_CPP03) +#include "detail/cpp03_msgpack_tuple_fwd.hpp" +#else // MSGPACK_USE_CPP03 +#include "detail/cpp11_msgpack_tuple_fwd.hpp" +#endif // MSGPACK_USE_CPP03 + +#endif // MSGPACK_MSGPACK_TUPLE_FWD_HPP diff --git a/src/msgpack/type/nil.hpp b/include/msgpack/adaptor/nil.hpp similarity index 64% rename from src/msgpack/type/nil.hpp rename to include/msgpack/adaptor/nil.hpp index f44e45e4..4b092e28 100644 --- a/src/msgpack/type/nil.hpp +++ b/include/msgpack/adaptor/nil.hpp @@ -15,13 +15,16 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_TYPE_NIL_HPP__ -#define MSGPACK_TYPE_NIL_HPP__ +#ifndef MSGPACK_TYPE_NIL_HPP +#define MSGPACK_TYPE_NIL_HPP -#include "msgpack/object.hpp" +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { + namespace type { struct nil { }; @@ -29,37 +32,37 @@ struct nil { }; } // namespace type -inline type::nil& operator>> (object o, type::nil& v) +inline object const& operator>> (object const& o, type::nil&) { - if(o.type != type::NIL) { throw type_error(); } - return v; + if(o.type != type::NIL) { throw type_error(); } + return o; } template -inline packer& operator<< (packer& o, const type::nil& v) +inline packer& operator<< (packer& o, const type::nil&) { - o.pack_nil(); - return o; + o.pack_nil(); + return o; } -inline void operator<< (object& o, type::nil v) +inline void operator<< (object& o, type::nil) { - o.type = type::NIL; + o.type = type::NIL; } inline void operator<< (object::with_zone& o, type::nil v) - { static_cast(o) << v; } + { static_cast(o) << v; } template <> inline void object::as() const { - msgpack::type::nil v; - convert(&v); + msgpack::type::nil v; + convert(v); } +} // MSGPACK_API_VERSION_NAMESPACE(v1) } // namespace msgpack -#endif /* msgpack/type/nil.hpp */ - +#endif // MSGPACK_TYPE_NIL_HPP diff --git a/include/msgpack/adaptor/nil_fwd.hpp b/include/msgpack/adaptor/nil_fwd.hpp new file mode 100644 index 00000000..80d14860 --- /dev/null +++ b/include/msgpack/adaptor/nil_fwd.hpp @@ -0,0 +1,51 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_NIL_FWD_HPP +#define MSGPACK_TYPE_NIL_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +namespace type { + +struct nil; + +} // namespace type + + +object const& operator>> (object const& o, type::nil&); + +template +packer& operator<< (packer& o, const type::nil&); + +void operator<< (object& o, type::nil); + +void operator<< (object::with_zone& o, type::nil v); + +template <> +inline void object::as() const; + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_NIL_FWD_HPP diff --git a/src/msgpack/type/pair.hpp b/include/msgpack/adaptor/pair.hpp similarity index 56% rename from src/msgpack/type/pair.hpp rename to include/msgpack/adaptor/pair.hpp index 296a8b64..27b88fae 100644 --- a/src/msgpack/type/pair.hpp +++ b/include/msgpack/adaptor/pair.hpp @@ -15,47 +15,49 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_TYPE_PAIR_HPP__ -#define MSGPACK_TYPE_PAIR_HPP__ +#ifndef MSGPACK_TYPE_PAIR_HPP +#define MSGPACK_TYPE_PAIR_HPP -#include "msgpack/object.hpp" +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" #include namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { template -inline std::pair& operator>> (object o, std::pair& v) +inline object const& operator>> (object const& o, std::pair& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size != 2) { throw type_error(); } - o.via.array.ptr[0].convert(&v.first); - o.via.array.ptr[1].convert(&v.second); - return v; + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size != 2) { throw type_error(); } + o.via.array.ptr[0].convert(v.first); + o.via.array.ptr[1].convert(v.second); + return o; } template inline packer& operator<< (packer& o, const std::pair& v) { - o.pack_array(2); - o.pack(v.first); - o.pack(v.second); - return o; + o.pack_array(2); + o.pack(v.first); + o.pack(v.second); + return o; } template inline void operator<< (object::with_zone& o, const std::pair& v) { - o.type = type::ARRAY; - object* p = (object*)o.zone->malloc(sizeof(object)*2); - o.via.array.ptr = p; - o.via.array.size = 2; - p[0] = object(v.first, o.zone); - p[1] = object(v.second, o.zone); + o.type = type::ARRAY; + object* p = static_cast(o.zone.allocate_align(sizeof(object)*2)); + o.via.array.ptr = p; + o.via.array.size = 2; + p[0] = object(v.first, o.zone); + p[1] = object(v.second, o.zone); } +} // MSGPACK_API_VERSION_NAMESPACE(v1) } // namespace msgpack -#endif /* msgpack/type/pair.hpp */ - +#endif // MSGPACK_TYPE_PAIR_HPP diff --git a/include/msgpack/adaptor/pair_fwd.hpp b/include/msgpack/adaptor/pair_fwd.hpp new file mode 100644 index 00000000..d6d84d39 --- /dev/null +++ b/include/msgpack/adaptor/pair_fwd.hpp @@ -0,0 +1,42 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2009 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_PAIR_FWD_HPP +#define MSGPACK_TYPE_PAIR_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +object const& operator>> (object const& o, std::pair& v); + +template +packer& operator<< (packer& o, const std::pair& v); + +template +void operator<< (object::with_zone& o, const std::pair& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_PAIR_FWD_HPP diff --git a/include/msgpack/adaptor/raw.hpp b/include/msgpack/adaptor/raw.hpp new file mode 100644 index 00000000..590b5de7 --- /dev/null +++ b/include/msgpack/adaptor/raw.hpp @@ -0,0 +1,98 @@ +// +// 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 "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +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 && 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 memcmp(ptr, x.ptr, size) < 0; } + else { return size < x.size; } + } + + bool operator> (const raw_ref& x) const + { + if(size == x.size) { return memcmp(ptr, x.ptr, size) > 0; } + else { return size > x.size; } + } +}; + +} // namespace type + + +inline object const& operator>> (object const& o, type::raw_ref& v) +{ + if(o.type != type::BIN) { throw type_error(); } + v.ptr = o.via.bin.ptr; + v.size = o.via.bin.size; + return o; +} + +template +inline packer& operator<< (packer& o, const type::raw_ref& v) +{ + o.pack_bin(v.size); + o.pack_bin_body(v.ptr, v.size); + return o; +} + +inline void operator<< (object& o, const type::raw_ref& v) +{ + o.type = type::BIN; + o.via.bin.ptr = v.ptr; + o.via.bin.size = v.size; +} + +inline void operator<< (object::with_zone& o, const type::raw_ref& v) + { static_cast(o) << v; } + + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_RAW_HPP diff --git a/include/msgpack/adaptor/raw_fwd.hpp b/include/msgpack/adaptor/raw_fwd.hpp new file mode 100644 index 00000000..26f83434 --- /dev/null +++ b/include/msgpack/adaptor/raw_fwd.hpp @@ -0,0 +1,50 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2009 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_RAW_FWD_HPP +#define MSGPACK_TYPE_RAW_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +namespace type { + +struct raw_ref; + +} // namespace type + + +object const& operator>> (object const& o, type::raw_ref& v); + +template +packer& operator<< (packer& o, const type::raw_ref& v); + +void operator<< (object& o, const type::raw_ref& v); + +void operator<< (object::with_zone& o, const type::raw_ref& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_RAW_FWD_HPP diff --git a/include/msgpack/adaptor/set.hpp b/include/msgpack/adaptor/set.hpp new file mode 100644 index 00000000..427b52fc --- /dev/null +++ b/include/msgpack/adaptor/set.hpp @@ -0,0 +1,129 @@ +// +// 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_SET_HPP +#define MSGPACK_TYPE_SET_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +inline object const& operator>> (object const& o, std::set& v) +{ + if(o.type != type::ARRAY) { throw type_error(); } + object* p = o.via.array.ptr + o.via.array.size; + object* const pbegin = o.via.array.ptr; + std::set tmp; + while(p > pbegin) { + --p; + tmp.insert(p->as()); + } + tmp.swap(v); + return o; +} + +template +inline packer& operator<< (packer& o, const std::set& v) +{ + o.pack_array(v.size()); + for(typename std::set::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(*it); + } + return o; +} + +template +inline void operator<< (object::with_zone& o, const std::set& v) +{ + o.type = type::ARRAY; + if(v.empty()) { + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } else { + object* p = static_cast(o.zone.allocate_align(sizeof(object)*v.size())); + object* const pend = p + v.size(); + o.via.array.ptr = p; + o.via.array.size = v.size(); + typename std::set::const_iterator it(v.begin()); + do { + *p = object(*it, o.zone); + ++p; + ++it; + } while(p < pend); + } +} + + +template +inline object const& operator>> (object const& o, std::multiset& v) +{ + if(o.type != type::ARRAY) { throw type_error(); } + object* p = o.via.array.ptr + o.via.array.size; + object* const pbegin = o.via.array.ptr; + std::multiset tmp; + while(p > pbegin) { + --p; + tmp.insert(p->as()); + } + tmp.swap(v); + return o; +} + +template +inline packer& operator<< (packer& o, const std::multiset& v) +{ + o.pack_array(v.size()); + for(typename std::multiset::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(*it); + } + return o; +} + +template +inline void operator<< (object::with_zone& o, const std::multiset& v) +{ + o.type = type::ARRAY; + if(v.empty()) { + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } else { + object* p = static_cast(o.zone.allocate_align(sizeof(object)*v.size())); + object* const pend = p + v.size(); + o.via.array.ptr = p; + o.via.array.size = v.size(); + typename std::multiset::const_iterator it(v.begin()); + do { + *p = object(*it, o.zone); + ++p; + ++it; + } while(p < pend); + } +} + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_SET_HPP diff --git a/include/msgpack/adaptor/set_fwd.hpp b/include/msgpack/adaptor/set_fwd.hpp new file mode 100644 index 00000000..ae5712f8 --- /dev/null +++ b/include/msgpack/adaptor/set_fwd.hpp @@ -0,0 +1,52 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_SET_FWD_HPP +#define MSGPACK_TYPE_SET_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +object const& operator>> (object const& o, std::set& v); + +template +packer& operator<< (packer& o, const std::set& v); + +template +void operator<< (object::with_zone& o, const std::set& v); + +template +object const& operator>> (object const& o, std::multiset& v); + +template +packer& operator<< (packer& o, const std::multiset& v); + +template +void operator<< (object::with_zone& o, const std::multiset& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_SET_FWD_HPP diff --git a/src/msgpack/type/string.hpp b/include/msgpack/adaptor/string.hpp similarity index 50% rename from src/msgpack/type/string.hpp rename to include/msgpack/adaptor/string.hpp index 37d4a172..05c2867f 100644 --- a/src/msgpack/type/string.hpp +++ b/include/msgpack/adaptor/string.hpp @@ -15,48 +15,59 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_TYPE_STRING_HPP__ -#define MSGPACK_TYPE_STRING_HPP__ +#ifndef MSGPACK_TYPE_STRING_HPP +#define MSGPACK_TYPE_STRING_HPP -#include "msgpack/object.hpp" +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" #include namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { -inline std::string& operator>> (object o, std::string& v) +inline object const& operator>> (object const& o, std::string& v) { - if(o.type != type::RAW) { throw type_error(); } - v.assign(o.via.raw.ptr, o.via.raw.size); - return v; + switch (o.type) { + case type::BIN: + v.assign(o.via.bin.ptr, o.via.bin.size); + break; + case type::STR: + v.assign(o.via.str.ptr, o.via.str.size); + break; + default: + throw type_error(); + break; + } + return o; } template inline packer& operator<< (packer& o, const std::string& v) { - o.pack_raw(v.size()); - o.pack_raw_body(v.data(), v.size()); - return o; + o.pack_str(v.size()); + o.pack_str_body(v.data(), v.size()); + return o; } inline void operator<< (object::with_zone& o, const std::string& v) { - o.type = type::RAW; - char* ptr = (char*)o.zone->malloc(v.size()); - o.via.raw.ptr = ptr; - o.via.raw.size = (uint32_t)v.size(); - memcpy(ptr, v.data(), v.size()); + o.type = type::STR; + char* ptr = static_cast(o.zone.allocate_align(v.size())); + o.via.str.ptr = ptr; + o.via.str.size = static_cast(v.size()); + memcpy(ptr, v.data(), v.size()); } inline void operator<< (object& o, const std::string& v) { - o.type = type::RAW; - o.via.raw.ptr = v.data(); - o.via.raw.size = (uint32_t)v.size(); + o.type = type::STR; + o.via.str.ptr = v.data(); + o.via.str.size = static_cast(v.size()); } +} // MSGPACK_API_VERSION_NAMESPACE(v1) } // namespace msgpack -#endif /* msgpack/type/string.hpp */ - +#endif // MSGPACK_TYPE_STRING_HPP diff --git a/include/msgpack/adaptor/string_fwd.hpp b/include/msgpack/adaptor/string_fwd.hpp new file mode 100644 index 00000000..471654e6 --- /dev/null +++ b/include/msgpack/adaptor/string_fwd.hpp @@ -0,0 +1,42 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_STRING_FWD_HPP +#define MSGPACK_TYPE_STRING_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +object const& operator>> (object const& o, std::string& v); + +template +packer& operator<< (packer& o, const std::string& v); + +void operator<< (object::with_zone& o, const std::string& v); + +void operator<< (object& o, const std::string& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_STRING_FWD_HPP diff --git a/include/msgpack/adaptor/tr1/unordered_map.hpp b/include/msgpack/adaptor/tr1/unordered_map.hpp new file mode 100644 index 00000000..caf9f544 --- /dev/null +++ b/include/msgpack/adaptor/tr1/unordered_map.hpp @@ -0,0 +1,156 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2009 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP +#define MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +#if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) + +#define MSGPACK_HAS_STD_UNOURDERED_MAP +#include +#define MSGPACK_STD_TR1 std + +#else // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) + +#if __GNUC__ >= 4 + +#define MSGPACK_HAS_STD_TR1_UNOURDERED_MAP + +#include +#define MSGPACK_STD_TR1 std::tr1 + +#endif // __GNUC__ >= 4 + +#endif // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) + + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +inline object const& operator>> (object const& o, MSGPACK_STD_TR1::unordered_map& v) +{ + if(o.type != type::MAP) { throw type_error(); } + object_kv* p(o.via.map.ptr); + object_kv* const pend(o.via.map.ptr + o.via.map.size); + MSGPACK_STD_TR1::unordered_map tmp; + for(; p != pend; ++p) { + K key; + p->key.convert(key); + p->val.convert(tmp[key]); + } + tmp.swap(v); + return o; +} + +template +inline packer& operator<< (packer& o, const MSGPACK_STD_TR1::unordered_map& v) +{ + o.pack_map(v.size()); + for(typename MSGPACK_STD_TR1::unordered_map::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(it->first); + o.pack(it->second); + } + return o; +} + +template +inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_map& v) +{ + o.type = type::MAP; + if(v.empty()) { + o.via.map.ptr = nullptr; + o.via.map.size = 0; + } else { + object_kv* p = static_cast(o.zone.allocate_align(sizeof(object_kv)*v.size())); + object_kv* const pend = p + v.size(); + o.via.map.ptr = p; + o.via.map.size = v.size(); + typename MSGPACK_STD_TR1::unordered_map::const_iterator it(v.begin()); + do { + p->key = object(it->first, o.zone); + p->val = object(it->second, o.zone); + ++p; + ++it; + } while(p < pend); + } +} + + +template +inline object const& operator>> (object const& o, MSGPACK_STD_TR1::unordered_multimap& v) +{ + if(o.type != type::MAP) { throw type_error(); } + object_kv* p(o.via.map.ptr); + object_kv* const pend(o.via.map.ptr + o.via.map.size); + MSGPACK_STD_TR1::unordered_multimap tmp; + for(; p != pend; ++p) { + std::pair value; + p->key.convert(value.first); + p->val.convert(value.second); + tmp.insert(value); + } + tmp.swap(v); + return o; +} + +template +inline packer& operator<< (packer& o, const MSGPACK_STD_TR1::unordered_multimap& v) +{ + o.pack_map(v.size()); + for(typename MSGPACK_STD_TR1::unordered_multimap::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(it->first); + o.pack(it->second); + } + return o; +} + +template +inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_multimap& v) +{ + o.type = type::MAP; + if(v.empty()) { + o.via.map.ptr = nullptr; + o.via.map.size = 0; + } else { + object_kv* p = static_cast(o.zone.allocate_align(sizeof(object_kv)*v.size())); + object_kv* const pend = p + v.size(); + o.via.map.ptr = p; + o.via.map.size = v.size(); + typename MSGPACK_STD_TR1::unordered_multimap::const_iterator it(v.begin()); + do { + p->key = object(it->first, o.zone); + p->val = object(it->second, o.zone); + ++p; + ++it; + } while(p < pend); + } +} + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#undef MSGPACK_STD_TR1 + +#endif // MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP diff --git a/include/msgpack/adaptor/tr1/unordered_map_fwd.hpp b/include/msgpack/adaptor/tr1/unordered_map_fwd.hpp new file mode 100644 index 00000000..99801e96 --- /dev/null +++ b/include/msgpack/adaptor/tr1/unordered_map_fwd.hpp @@ -0,0 +1,72 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_TR1_UNORDERED_MAP_FWD_HPP +#define MSGPACK_TYPE_TR1_UNORDERED_MAP_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +#if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) + +#define MSGPACK_HAS_STD_UNOURDERED_MAP +#include +#define MSGPACK_STD_TR1 std + +#else // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) + +#if __GNUC__ >= 4 + +#define MSGPACK_HAS_STD_TR1_UNOURDERED_MAP + +#include +#define MSGPACK_STD_TR1 std::tr1 + +#endif // __GNUC__ >= 4 + +#endif // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) + + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +object const& operator>> (object const& o, MSGPACK_STD_TR1::unordered_map& v); + +template +packer& operator<< (packer& o, const MSGPACK_STD_TR1::unordered_map& v); + +template +void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_map& v); + +template +object const& operator>> (object const& o, MSGPACK_STD_TR1::unordered_multimap& v); + +template +packer& operator<< (packer& o, const MSGPACK_STD_TR1::unordered_multimap& v); + +template +void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_multimap& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#undef MSGPACK_STD_TR1 + +#endif // MSGPACK_TYPE_TR1_UNORDERED_MAP_FWD_HPP diff --git a/include/msgpack/adaptor/tr1/unordered_set.hpp b/include/msgpack/adaptor/tr1/unordered_set.hpp new file mode 100644 index 00000000..9db2825c --- /dev/null +++ b/include/msgpack/adaptor/tr1/unordered_set.hpp @@ -0,0 +1,148 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2009 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_TR1_UNORDERED_SET_HPP +#define MSGPACK_TYPE_TR1_UNORDERED_SET_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +#if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) + +#define MSGPACK_HAS_STD_UNOURDERED_SET +#include +#define MSGPACK_STD_TR1 std + +#else // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) + +#if __GNUC__ >= 4 + +#define MSGPACK_HAS_STD_TR1_UNOURDERED_SET + +#include +#define MSGPACK_STD_TR1 std::tr1 + +#endif // __GNUC__ >= 4 + +#endif // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +inline object const& operator>> (object const& o, MSGPACK_STD_TR1::unordered_set& v) +{ + if(o.type != type::ARRAY) { throw type_error(); } + object* p = o.via.array.ptr + o.via.array.size; + object* const pbegin = o.via.array.ptr; + MSGPACK_STD_TR1::unordered_set tmp; + while(p > pbegin) { + --p; + tmp.insert(p->as()); + } + tmp.swap(v); + return o; +} + +template +inline packer& operator<< (packer& o, const MSGPACK_STD_TR1::unordered_set& v) +{ + o.pack_array(v.size()); + for(typename MSGPACK_STD_TR1::unordered_set::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(*it); + } + return o; +} + +template +inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_set& v) +{ + o.type = type::ARRAY; + if(v.empty()) { + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } else { + object* p = static_cast(o.zone.allocate_align(sizeof(object)*v.size())); + object* const pend = p + v.size(); + o.via.array.ptr = p; + o.via.array.size = v.size(); + typename MSGPACK_STD_TR1::unordered_set::const_iterator it(v.begin()); + do { + *p = object(*it, o.zone); + ++p; + ++it; + } while(p < pend); + } +} + + +template +inline object const& operator>> (object const& o, MSGPACK_STD_TR1::unordered_multiset& v) +{ + if(o.type != type::ARRAY) { throw type_error(); } + object* p = o.via.array.ptr + o.via.array.size; + object* const pbegin = o.via.array.ptr; + MSGPACK_STD_TR1::unordered_multiset tmp; + while(p > pbegin) { + --p; + tmp.insert(p->as()); + } + tmp.swap(v); + return o; +} + +template +inline packer& operator<< (packer& o, const MSGPACK_STD_TR1::unordered_multiset& v) +{ + o.pack_array(v.size()); + for(typename MSGPACK_STD_TR1::unordered_multiset::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(*it); + } + return o; +} + +template +inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_multiset& v) +{ + o.type = type::ARRAY; + if(v.empty()) { + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } else { + object* p = static_cast(o.zone.allocate_align(sizeof(object)*v.size())); + object* const pend = p + v.size(); + o.via.array.ptr = p; + o.via.array.size = v.size(); + typename MSGPACK_STD_TR1::unordered_multiset::const_iterator it(v.begin()); + do { + *p = object(*it, o.zone); + ++p; + ++it; + } while(p < pend); + } +} + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#undef MSGPACK_STD_TR1 + +#endif // MSGPACK_TYPE_TR1_UNORDERED_SET_HPP diff --git a/include/msgpack/adaptor/tr1/unordered_set_fwd.hpp b/include/msgpack/adaptor/tr1/unordered_set_fwd.hpp new file mode 100644 index 00000000..f5e9e648 --- /dev/null +++ b/include/msgpack/adaptor/tr1/unordered_set_fwd.hpp @@ -0,0 +1,71 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2009 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_TR1_UNORDERED_SET_FWD_HPP +#define MSGPACK_TYPE_TR1_UNORDERED_SET_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +#if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) + +#define MSGPACK_HAS_STD_UNOURDERED_SET +#include +#define MSGPACK_STD_TR1 std + +#else // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) + +#if __GNUC__ >= 4 + +#define MSGPACK_HAS_STD_TR1_UNOURDERED_SET + +#include +#define MSGPACK_STD_TR1 std::tr1 + +#endif // __GNUC__ >= 4 + +#endif // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +object const& operator>> (object const& o, MSGPACK_STD_TR1::unordered_set& v); + +template +packer& operator<< (packer& o, const MSGPACK_STD_TR1::unordered_set& v); + +template +void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_set& v); + +template +object const& operator>> (object const& o, MSGPACK_STD_TR1::unordered_multiset& v); + +template +packer& operator<< (packer& o, const MSGPACK_STD_TR1::unordered_multiset& v); + +template +void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_multiset& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#undef MSGPACK_STD_TR1 + +#endif // MSGPACK_TYPE_TR1_UNORDERED_SET_FWD_HPP diff --git a/include/msgpack/adaptor/vector.hpp b/include/msgpack/adaptor/vector.hpp new file mode 100644 index 00000000..fe643117 --- /dev/null +++ b/include/msgpack/adaptor/vector.hpp @@ -0,0 +1,83 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2009 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_VECTOR_HPP +#define MSGPACK_TYPE_VECTOR_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +inline object const& operator>> (object const& o, std::vector& v) +{ + if(o.type != type::ARRAY) { throw type_error(); } + v.resize(o.via.array.size); + if(o.via.array.size > 0) { + object* p = o.via.array.ptr; + object* const pend = o.via.array.ptr + o.via.array.size; + T* it = &v[0]; + do { + p->convert(*it); + ++p; + ++it; + } while(p < pend); + } + return o; +} + +template +inline packer& operator<< (packer& o, const std::vector& v) +{ + o.pack_array(v.size()); + for(typename std::vector::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(*it); + } + return o; +} + +template +inline void operator<< (object::with_zone& o, const std::vector& v) +{ + o.type = type::ARRAY; + if(v.empty()) { + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } else { + object* p = static_cast(o.zone.allocate_align(sizeof(object)*v.size())); + object* const pend = p + v.size(); + o.via.array.ptr = p; + o.via.array.size = v.size(); + typename std::vector::const_iterator it(v.begin()); + do { + *p = object(*it, o.zone); + ++p; + ++it; + } while(p < pend); + } +} + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_VECTOR_HPP diff --git a/include/msgpack/adaptor/vector_char.hpp b/include/msgpack/adaptor/vector_char.hpp new file mode 100644 index 00000000..1ea6c93c --- /dev/null +++ b/include/msgpack/adaptor/vector_char.hpp @@ -0,0 +1,76 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2014 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_VECTOR_CHAR_HPP +#define MSGPACK_TYPE_VECTOR_CHAR_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +inline object const& operator>> (object const& o, std::vector& v) +{ + switch (o.type) { + case type::BIN: + v.resize(o.via.bin.size); + std::memcpy(v.data(), o.via.bin.ptr, o.via.bin.size); + break; + case type::STR: + v.resize(o.via.str.size); + std::memcpy(v.data(), o.via.str.ptr, o.via.str.size); + break; + default: + throw type_error(); + break; + } + return o; +} + +template +inline packer& operator<< (packer& o, const std::vector& v) +{ + o.pack_bin(v.size()); + o.pack_bin_body(v.data(), v.size()); + + return o; +} + +inline void operator<< (object& o, const std::vector& v) +{ + o.type = type::BIN; + o.via.bin.ptr = v.data(); + o.via.bin.size = static_cast(v.size()); +} + +inline void operator<< (object::with_zone& o, const std::vector& v) +{ + o.type = type::BIN; + char* ptr = static_cast(o.zone.allocate_align(v.size())); + o.via.bin.ptr = ptr; + o.via.bin.size = static_cast(v.size()); + std::memcpy(ptr, v.data(), v.size()); +} + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_VECTOR_CHAR_HPP diff --git a/include/msgpack/adaptor/vector_char_fwd.hpp b/include/msgpack/adaptor/vector_char_fwd.hpp new file mode 100644 index 00000000..0d668efd --- /dev/null +++ b/include/msgpack/adaptor/vector_char_fwd.hpp @@ -0,0 +1,42 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2014 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_VECTOR_CHAR_FWD_HPP +#define MSGPACK_TYPE_VECTOR_CHAR_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +object const& operator>> (object const& o, std::vector& v); + +template +packer& operator<< (packer& o, const std::vector& v); + +void operator<< (object& o, const std::vector& v); + +void operator<< (object::with_zone& o, const std::vector& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_VECTOR_CHAR_FWD_HPP diff --git a/include/msgpack/adaptor/vector_fwd.hpp b/include/msgpack/adaptor/vector_fwd.hpp new file mode 100644 index 00000000..1e144018 --- /dev/null +++ b/include/msgpack/adaptor/vector_fwd.hpp @@ -0,0 +1,42 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2009 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_VECTOR_FWD_HPP +#define MSGPACK_TYPE_VECTOR_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +object const& operator>> (object const& o, std::vector& v); + +template +packer& operator<< (packer& o, const std::vector& v); + +template +void operator<< (object::with_zone& o, const std::vector& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_VECTOR_FWD_HPP diff --git a/include/msgpack/cpp_config.hpp b/include/msgpack/cpp_config.hpp new file mode 100644 index 00000000..be00f6ef --- /dev/null +++ b/include/msgpack/cpp_config.hpp @@ -0,0 +1,107 @@ +// +// MessagePack for C++ C++03/C++11 Adaptation +// +// Copyright (C) 2013 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_CPP_CONFIG_HPP +#define MSGPACK_CPP_CONFIG_HPP + +#include "msgpack/versioning.hpp" + +#if !defined(MSGPACK_USE_CPP03) + // If MSVC would support C++11 completely, + // then 'defined(_MSC_VER)' would replace with + // '_MSC_VER < XXXX' +# if (__cplusplus < 201103) || defined(_MSC_VER) +# define MSGPACK_USE_CPP03 +# endif +#endif // MSGPACK_USE_CPP03 + + + +#if defined __cplusplus +#if __cplusplus < 201103 + +#if !defined(nullptr) +#define nullptr (0) +#endif + +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +struct unique_ptr : std::auto_ptr { + explicit unique_ptr(T* p = 0) throw() : std::auto_ptr(p) {} + unique_ptr(unique_ptr& a) throw() : std::auto_ptr(a) {} + template + unique_ptr (unique_ptr& a) throw() : std::auto_ptr(a) {} +}; + +template +T& move(T& t) +{ + return t; +} + +template +T const& move(T const& t) +{ + return t; +} + +template +struct enable_if { + typedef T type; +}; + +template +struct enable_if { +}; + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + + +#else // __cplusplus < 201103 + +#include +#include + +namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { + + // unique_ptr + using std::unique_ptr; + // using std::make_unique; // since C++14 + using std::hash; + + // utility + using std::move; + using std::swap; + using std::enable_if; + +} // MSGPACK_API_VERSION_NAMESPACE(v1) +} // namespace msgpack + + +#endif // __cplusplus < 201103 + +#endif // __cplusplus + +#endif /* msgpack/cpp_config.hpp */ diff --git a/include/msgpack/detail/cpp03_zone.hpp b/include/msgpack/detail/cpp03_zone.hpp new file mode 100644 index 00000000..8d202232 --- /dev/null +++ b/include/msgpack/detail/cpp03_zone.hpp @@ -0,0 +1,640 @@ +// +// MessagePack for C++ memory pool +// +// Copyright (C) 2008-2010 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// 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_ZONE_HPP +#define MSGPACK_CPP03_ZONE_HPP + +#include +#include +#include + +#include "msgpack/versioning.hpp" + +#ifndef MSGPACK_ZONE_CHUNK_SIZE +#define MSGPACK_ZONE_CHUNK_SIZE 8192 +#endif + +#ifndef MSGPACK_ZONE_ALIGN +#define MSGPACK_ZONE_ALIGN sizeof(int) +#endif + + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +class zone { + struct finalizer { + finalizer(void (*func)(void*), void* data):m_func(func), m_data(data) {} + void operator()() { m_func(m_data); } + void (*m_func)(void*); + void* m_data; + }; + struct finalizer_array { + finalizer_array():m_tail(nullptr), m_end(nullptr), m_array(nullptr) {} + void call() { + finalizer* fin = m_tail; + for(; fin != m_array; --fin) (*(fin-1))(); + } + ~finalizer_array() { + call(); + ::free(m_array); + } + void clear() { + call(); + m_tail = m_array; + } + void push(void (*func)(void* data), void* data) + { + finalizer* fin = m_tail; + + if(fin == m_end) { + push_expand(func, data); + return; + } + + fin->m_func = func; + fin->m_data = data; + + ++m_tail; + } + void push_expand(void (*func)(void*), void* data) { + const size_t nused = m_end - m_array; + size_t nnext; + if(nused == 0) { + nnext = (sizeof(finalizer) < 72/2) ? + 72 / sizeof(finalizer) : 8; + } else { + nnext = nused * 2; + } + finalizer* tmp = + static_cast(::realloc(m_array, sizeof(finalizer) * nnext)); + if(!tmp) { + throw std::bad_alloc(); + } + m_array = tmp; + m_end = tmp + nnext; + m_tail = tmp + nused; + new (m_tail) finalizer(func, data); + + ++m_tail; + } + finalizer* m_tail; + finalizer* m_end; + finalizer* m_array; + }; + struct chunk { + chunk* m_next; + }; + struct chunk_list { + chunk_list(size_t chunk_size) + { + chunk* c = static_cast(::malloc(sizeof(chunk) + chunk_size)); + if(!c) { + throw std::bad_alloc(); + } + + m_head = c; + m_free = chunk_size; + m_ptr = reinterpret_cast(c) + sizeof(chunk); + c->m_next = nullptr; + } + ~chunk_list() + { + chunk* c = m_head; + while(c) { + chunk* n = c->m_next; + ::free(c); + c = n; + } + } + void clear(size_t chunk_size) + { + chunk* c = m_head; + while(true) { + chunk* n = c->m_next; + if(n) { + ::free(c); + c = n; + } else { + break; + } + } + m_head->m_next = nullptr; + m_free = chunk_size; + m_ptr = reinterpret_cast(m_head) + sizeof(chunk); + } + size_t m_free; + char* m_ptr; + chunk* m_head; + }; + size_t m_chunk_size; + chunk_list m_chunk_list; + finalizer_array m_finalizer_array; + +public: + zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE) /* throw() */; + +public: + void* allocate_align(size_t size); + void* allocate_no_align(size_t size); + + void push_finalizer(void (*func)(void*), void* data); + + template + void push_finalizer(msgpack::unique_ptr obj); + + void clear(); + + void swap(zone& o); + static void* operator new(std::size_t size) throw(std::bad_alloc) + { + void* p = ::malloc(size); + if (!p) throw std::bad_alloc(); + return p; + } + static void operator delete(void *p) throw() + { + ::free(p); + } + static void* operator new(std::size_t size, void* place) throw() + { + return ::operator new(size, place); + } + static void operator delete(void* p, void* place) throw() + { + ::operator delete(p, place); + } + + template + T* allocate(); + + template + T* allocate(A1 a1); + + template + T* allocate(A1 a1, A2 a2); + + template + T* allocate(A1 a1, A2 a2, A3 a3); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15); + + +private: + void undo_allocate(size_t size); + + template + static void object_destruct(void* obj); + + template + static void object_delete(void* obj); + + void* allocate_expand(size_t size); +}; + +inline zone::zone(size_t chunk_size) /* throw() */ :m_chunk_size(chunk_size), m_chunk_list(m_chunk_size) +{ +} + +inline void* zone::allocate_align(size_t size) +{ + return allocate_no_align( + ((size)+((MSGPACK_ZONE_ALIGN)-1)) & ~((MSGPACK_ZONE_ALIGN)-1)); +} + +inline void* zone::allocate_no_align(size_t size) +{ + if(m_chunk_list.m_free < size) { + return allocate_expand(size); + } + + char* ptr = m_chunk_list.m_ptr; + m_chunk_list.m_free -= size; + m_chunk_list.m_ptr += size; + + return ptr; +} + +inline void* zone::allocate_expand(size_t size) +{ + chunk_list* const cl = &m_chunk_list; + + size_t sz = m_chunk_size; + + while(sz < size) { + sz *= 2; + } + + chunk* c = static_cast(::malloc(sizeof(chunk) + sz)); + if (!c) throw std::bad_alloc(); + + char* ptr = reinterpret_cast(c) + sizeof(chunk); + + c->m_next = cl->m_head; + cl->m_head = c; + cl->m_free = sz - size; + cl->m_ptr = ptr + size; + + return ptr; +} + +inline void zone::push_finalizer(void (*func)(void*), void* data) +{ + m_finalizer_array.push(func, data); +} + +template +inline void zone::push_finalizer(msgpack::unique_ptr obj) +{ + m_finalizer_array.push(&zone::object_delete, obj.release()); +} + +inline void zone::clear() +{ + m_finalizer_array.clear(); + m_chunk_list.clear(m_chunk_size); +} + +inline void zone::swap(zone& o) +{ + std::swap(*this, o); +} + +template +void zone::object_destruct(void* obj) +{ + static_cast(obj)->~T(); +} + +template +void zone::object_delete(void* obj) +{ + delete static_cast(obj); +} + +inline void zone::undo_allocate(size_t size) +{ + m_chunk_list.m_ptr -= size; + m_chunk_list.m_free += size; +} + + +template +T* zone::allocate() +{ + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destruct, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } +} + +template +T* zone::allocate(A1 a1) +{ + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destruct, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(a1); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } +} + +template +T* zone::allocate(A1 a1, A2 a2) +{ + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destruct, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(a1, a2); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } +} + +template +T* zone::allocate(A1 a1, A2 a2, A3 a3) +{ + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destruct, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(a1, a2, a3); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } +} + +template +T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4) +{ + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destruct, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(a1, a2, a3, a4); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } +} + +template +T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) +{ + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destruct, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(a1, a2, a3, a4, a5); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } +} + +template +T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) +{ + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destruct, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(a1, a2, a3, a4, a5, a6); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } +} + +template +T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) +{ + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destruct, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(a1, a2, a3, a4, a5, a6, a7); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } +} + +template +T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) +{ + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destruct, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } +} + +template +T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) +{ + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destruct, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } +} + +template +T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) +{ + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destruct, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } +} + +template +T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) +{ + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destruct, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } +} + +template +T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) +{ + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destruct, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } +} + +template +T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) +{ + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destruct, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } +} + +template +T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) +{ + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destruct, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } +} + +template +T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) +{ + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destruct, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } +} + + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_CPP03_ZONE_HPP diff --git a/include/msgpack/detail/cpp11_zone.hpp b/include/msgpack/detail/cpp11_zone.hpp new file mode 100644 index 00000000..f3ec210b --- /dev/null +++ b/include/msgpack/detail/cpp11_zone.hpp @@ -0,0 +1,352 @@ +// +// MessagePack for C++ memory pool +// +// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_CPP11_ZONE_HPP +#define MSGPACK_CPP11_ZONE_HPP + +#include "msgpack/versioning.hpp" + +#include +#include +#include + +#include "msgpack/cpp_config.hpp" + +#ifndef MSGPACK_ZONE_CHUNK_SIZE +#define MSGPACK_ZONE_CHUNK_SIZE 8192 +#endif + +#ifndef MSGPACK_ZONE_ALIGN +#define MSGPACK_ZONE_ALIGN sizeof(int) +#endif + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +class zone { +private: + struct finalizer { + finalizer(void (*func)(void*), void* data):m_func(func), m_data(data) {} + void operator()() { m_func(m_data); } + void (*m_func)(void*); + void* m_data; + }; + struct finalizer_array { + finalizer_array():m_tail(nullptr), m_end(nullptr), m_array(nullptr) {} + void call() { + finalizer* fin = m_tail; + for(; fin != m_array; --fin) (*(fin-1))(); + } + ~finalizer_array() { + call(); + ::free(m_array); + } + void clear() { + call(); + m_tail = m_array; + } + void push(void (*func)(void* data), void* data) + { + finalizer* fin = m_tail; + + if(fin == m_end) { + push_expand(func, data); + return; + } + + fin->m_func = func; + fin->m_data = data; + + ++m_tail; + } + void push_expand(void (*func)(void*), void* data) { + const size_t nused = m_end - m_array; + size_t nnext; + if(nused == 0) { + nnext = (sizeof(finalizer) < 72/2) ? + 72 / sizeof(finalizer) : 8; + } else { + nnext = nused * 2; + } + finalizer* tmp = + static_cast(::realloc(m_array, sizeof(finalizer) * nnext)); + if(!tmp) { + throw std::bad_alloc(); + } + m_array = tmp; + m_end = tmp + nnext; + m_tail = tmp + nused; + new (m_tail) finalizer(func, data); + + ++m_tail; + } +#if !defined(MSGPACK_USE_CPP03) + finalizer_array(finalizer_array&& other) + :m_tail(other.m_tail), m_end(other.m_end), m_array(other.m_array) + { + other.m_tail = nullptr; + other.m_end = nullptr; + other.m_array = nullptr; + } + finalizer_array& operator=(finalizer_array&& other) + { + this->~finalizer_array(); + new (this) finalizer_array(std::move(other)); + return *this; + } +#endif + finalizer* m_tail; + finalizer* m_end; + finalizer* m_array; + + private: + finalizer_array(const finalizer_array&); + finalizer_array& operator=(const finalizer_array&); + }; + struct chunk { + chunk* m_next; + }; + struct chunk_list { + chunk_list(size_t chunk_size) + { + chunk* c = static_cast(::malloc(sizeof(chunk) + chunk_size)); + if(!c) { + throw std::bad_alloc(); + } + + m_head = c; + m_free = chunk_size; + m_ptr = reinterpret_cast(c) + sizeof(chunk); + c->m_next = nullptr; + } + ~chunk_list() + { + chunk* c = m_head; + while(c) { + chunk* n = c->m_next; + ::free(c); + c = n; + } + } + void clear(size_t chunk_size) + { + chunk* c = m_head; + while(true) { + chunk* n = c->m_next; + if(n) { + ::free(c); + c = n; + } else { + m_head = c; + break; + } + } + m_head->m_next = nullptr; + m_free = chunk_size; + m_ptr = reinterpret_cast(m_head) + sizeof(chunk); + } +#if !defined(MSGPACK_USE_CPP03) + chunk_list(chunk_list&& other) + :m_free(other.m_free), m_ptr(other.m_ptr), m_head(other.m_head) + { + other.m_head = nullptr; + } + chunk_list& operator=(chunk_list&& other) + { + this->~chunk_list(); + new (this) chunk_list(std::move(other)); + return *this; + } +#endif + size_t m_free; + char* m_ptr; + chunk* m_head; + private: + chunk_list(const chunk_list&); + chunk_list& operator=(const chunk_list&); + }; + size_t m_chunk_size; + chunk_list m_chunk_list; + finalizer_array m_finalizer_array; + +public: + zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE) noexcept; + +public: + void* allocate_align(size_t size); + void* allocate_no_align(size_t size); + + void push_finalizer(void (*func)(void*), void* data); + + template + void push_finalizer(msgpack::unique_ptr obj); + + void clear(); + + void swap(zone& o); + + + static void* operator new(std::size_t size) throw(std::bad_alloc) + { + void* p = ::malloc(size); + if (!p) throw std::bad_alloc(); + return p; + } + static void operator delete(void *p) throw() + { + ::free(p); + } + static void* operator new(std::size_t /*size*/, void* mem) throw() + { + return mem; + } + static void operator delete(void * /*p*/, void* /*mem*/) throw() + { + } + + template + T* allocate(Args... args); + + zone(zone&&) = default; + zone& operator=(zone&&) = default; + +private: + void undo_allocate(size_t size); + zone(const zone&); + zone& operator=(const zone&); + + template + static void object_destruct(void* obj); + + template + static void object_delete(void* obj); + + void* allocate_expand(size_t size); +}; + +inline zone::zone(size_t chunk_size) noexcept:m_chunk_size(chunk_size), m_chunk_list(m_chunk_size) +{ +} + +inline void* zone::allocate_align(size_t size) +{ + return allocate_no_align( + ((size)+((MSGPACK_ZONE_ALIGN)-1)) & ~((MSGPACK_ZONE_ALIGN)-1)); +} + +inline void* zone::allocate_no_align(size_t size) +{ + if(m_chunk_list.m_free < size) { + return allocate_expand(size); + } + + char* ptr = m_chunk_list.m_ptr; + m_chunk_list.m_free -= size; + m_chunk_list.m_ptr += size; + + return ptr; +} + +inline void* zone::allocate_expand(size_t size) +{ + chunk_list* const cl = &m_chunk_list; + + size_t sz = m_chunk_size; + + while(sz < size) { + sz *= 2; + } + + chunk* c = static_cast(::malloc(sizeof(chunk) + sz)); + if (!c) throw std::bad_alloc(); + + char* ptr = reinterpret_cast(c) + sizeof(chunk); + + c->m_next = cl->m_head; + cl->m_head = c; + cl->m_free = sz - size; + cl->m_ptr = ptr + size; + + return ptr; +} + +inline void zone::push_finalizer(void (*func)(void*), void* data) +{ + m_finalizer_array.push(func, data); +} + +template +inline void zone::push_finalizer(msgpack::unique_ptr obj) +{ + m_finalizer_array.push(&zone::object_delete, obj.release()); +} + +inline void zone::clear() +{ + m_finalizer_array.clear(); + m_chunk_list.clear(m_chunk_size); +} + +inline void zone::swap(zone& o) +{ + std::swap(*this, o); +} + +template +void zone::object_delete(void* obj) +{ + delete static_cast(obj); +} + +template +void zone::object_destruct(void* obj) +{ + static_cast(obj)->~T(); +} + +inline void zone::undo_allocate(size_t size) +{ + m_chunk_list.m_ptr -= size; + m_chunk_list.m_free += size; +} + + +template +T* zone::allocate(Args... args) +{ + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destruct, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(args...); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } +} + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_CPP11_ZONE_HPP diff --git a/src/msgpack/fbuffer.h b/include/msgpack/fbuffer.h similarity index 94% rename from src/msgpack/fbuffer.h rename to include/msgpack/fbuffer.h index 352f7269..85d62b03 100644 --- a/src/msgpack/fbuffer.h +++ b/include/msgpack/fbuffer.h @@ -33,7 +33,7 @@ extern "C" { static inline int msgpack_fbuffer_write(void* data, const char* buf, unsigned int len) { - return (1 == fwrite(buf, len, 1, (FILE *)data)) ? 0 : -1; + return (1 == fwrite(buf, len, 1, (FILE *)data)) ? 0 : -1; } /** @} */ diff --git a/src/msgpack/fbuffer.hpp b/include/msgpack/fbuffer.hpp similarity index 65% rename from src/msgpack/fbuffer.hpp rename to include/msgpack/fbuffer.hpp index 548ef0bf..39bb4089 100644 --- a/src/msgpack/fbuffer.hpp +++ b/include/msgpack/fbuffer.hpp @@ -18,39 +18,42 @@ #ifndef MSGPACK_FBUFFER_HPP__ #define MSGPACK_FBUFFER_HPP__ +#include "msgpack/versioning.hpp" + #include #include namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { class fbuffer { public: - explicit fbuffer(FILE* file) : m_file(file) { } + explicit fbuffer(FILE* file) : m_file(file) { } public: - void write(const char* buf, unsigned int len) - { - if (1 != fwrite(buf, len, 1, m_file)) { - throw std::runtime_error("fwrite() failed"); - } - } + void write(const char* buf, unsigned int len) + { + if (1 != fwrite(buf, len, 1, m_file)) { + throw std::runtime_error("fwrite() failed"); + } + } - FILE* file() const - { - return m_file; - } + FILE* file() const + { + return m_file; + } private: - fbuffer(const fbuffer&); - fbuffer& operator= (const fbuffer&); + fbuffer(const fbuffer&); + fbuffer& operator= (const fbuffer&); private: - FILE* m_file; + FILE* m_file; }; +} // MSGPACK_API_VERSION_NAMESPACE(v1) } // namespace msgpack #endif /* msgpack/fbuffer.hpp */ - diff --git a/src/gcc_atomic.h b/include/msgpack/gcc_atomic.h similarity index 90% rename from src/gcc_atomic.h rename to include/msgpack/gcc_atomic.h index 842a48fb..276acdc9 100644 --- a/src/gcc_atomic.h +++ b/include/msgpack/gcc_atomic.h @@ -12,8 +12,8 @@ * limitations under the License. */ -#ifndef MSGPACK_GCC_ATOMIC_H__ -#define MSGPACK_GCC_ATOMIC_H__ +#ifndef MSGPACK_GCC_ATOMIC_H +#define MSGPACK_GCC_ATOMIC_H #if defined(__cplusplus) extern "C" { @@ -30,4 +30,4 @@ int _msgpack_sync_incr_and_fetch(volatile _msgpack_atomic_counter_t* ptr); #endif -#endif // MSGPACK_GCC_ATOMIC_H__ +#endif // MSGPACK_GCC_ATOMIC_H diff --git a/src/msgpack/object.h b/include/msgpack/object.h similarity index 53% rename from src/msgpack/object.h rename to include/msgpack/object.h index baeeb9b2..3d0d1225 100644 --- a/src/msgpack/object.h +++ b/include/msgpack/object.h @@ -15,8 +15,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#ifndef MSGPACK_OBJECT_H__ -#define MSGPACK_OBJECT_H__ +#ifndef MSGPACK_OBJECT_H +#define MSGPACK_OBJECT_H #include "zone.h" #include @@ -33,14 +33,16 @@ extern "C" { */ typedef enum { - MSGPACK_OBJECT_NIL = 0x00, - MSGPACK_OBJECT_BOOLEAN = 0x01, - MSGPACK_OBJECT_POSITIVE_INTEGER = 0x02, - MSGPACK_OBJECT_NEGATIVE_INTEGER = 0x03, - MSGPACK_OBJECT_DOUBLE = 0x04, - MSGPACK_OBJECT_RAW = 0x05, - MSGPACK_OBJECT_ARRAY = 0x06, - MSGPACK_OBJECT_MAP = 0x07, + MSGPACK_OBJECT_NIL = 0x00, + MSGPACK_OBJECT_BOOLEAN = 0x01, + MSGPACK_OBJECT_POSITIVE_INTEGER = 0x02, + MSGPACK_OBJECT_NEGATIVE_INTEGER = 0x03, + MSGPACK_OBJECT_DOUBLE = 0x04, + MSGPACK_OBJECT_STR = 0x05, + MSGPACK_OBJECT_ARRAY = 0x06, + MSGPACK_OBJECT_MAP = 0x07, + MSGPACK_OBJECT_BIN = 0x08, + MSGPACK_OBJECT_EXT = 0x09 } msgpack_object_type; @@ -48,38 +50,51 @@ struct msgpack_object; struct msgpack_object_kv; typedef struct { - uint32_t size; - struct msgpack_object* ptr; + uint32_t size; + struct msgpack_object* ptr; } msgpack_object_array; typedef struct { - uint32_t size; - struct msgpack_object_kv* ptr; + uint32_t size; + struct msgpack_object_kv* ptr; } msgpack_object_map; typedef struct { - uint32_t size; - const char* ptr; -} msgpack_object_raw; + uint32_t size; + const char* ptr; +} msgpack_object_str; + +typedef struct { + uint32_t size; + const char* ptr; +} msgpack_object_bin; + +typedef struct { + int8_t type; + uint32_t size; + const char* ptr; +} msgpack_object_ext; typedef union { - bool boolean; - uint64_t u64; - int64_t i64; - double dec; - msgpack_object_array array; - msgpack_object_map map; - msgpack_object_raw raw; + bool boolean; + uint64_t u64; + int64_t i64; + double dec; + msgpack_object_array array; + msgpack_object_map map; + msgpack_object_str str; + msgpack_object_bin bin; + msgpack_object_ext ext; } msgpack_object_union; typedef struct msgpack_object { - msgpack_object_type type; - msgpack_object_union via; + msgpack_object_type type; + msgpack_object_union via; } msgpack_object; typedef struct msgpack_object_kv { - msgpack_object key; - msgpack_object val; + msgpack_object key; + msgpack_object val; } msgpack_object_kv; diff --git a/include/msgpack/object.hpp b/include/msgpack/object.hpp new file mode 100644 index 00000000..b6df9fa5 --- /dev/null +++ b/include/msgpack/object.hpp @@ -0,0 +1,560 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_OBJECT_HPP +#define MSGPACK_OBJECT_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include "msgpack/pack.hpp" +#include "msgpack/zone.hpp" +#include "msgpack/adaptor/int_fwd.hpp" +#include "msgpack/adaptor/bool_fwd.hpp" +#include "msgpack/adaptor/char_ptr_fwd.hpp" +#include "msgpack/adaptor/deque_fwd.hpp" +#include "msgpack/adaptor/fixint_fwd.hpp" +#include "msgpack/adaptor/float_fwd.hpp" +#include "msgpack/adaptor/int_fwd.hpp" +#include "msgpack/adaptor/list_fwd.hpp" +#include "msgpack/adaptor/map_fwd.hpp" +#include "msgpack/adaptor/msgpack_tuple_fwd.hpp" +#include "msgpack/adaptor/nil_fwd.hpp" +#include "msgpack/adaptor/pair_fwd.hpp" +#include "msgpack/adaptor/raw_fwd.hpp" +#include "msgpack/adaptor/set_fwd.hpp" +#include "msgpack/adaptor/string_fwd.hpp" +#include "msgpack/adaptor/vector_fwd.hpp" +#include "msgpack/adaptor/vector_char_fwd.hpp" +#include "msgpack/adaptor/tr1/unordered_map_fwd.hpp" +#include "msgpack/adaptor/tr1/unordered_set_fwd.hpp" + +#if !defined(MSGPACK_USE_CPP03) +#include "adaptor/cpp11/array_fwd.hpp" +#include "adaptor/cpp11/array_char_fwd.hpp" +#include "adaptor/cpp11/forward_list_fwd.hpp" +#include "adaptor/cpp11/tuple_fwd.hpp" +#endif // !defined(MSGPACK_USE_CPP03) + +#include +#include +#include +#include +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +struct object::with_zone : object { + with_zone(msgpack::zone& zone) : zone(zone) { } + msgpack::zone& zone; +private: + with_zone(); +}; + +struct object::implicit_type { + implicit_type(object const& o) : obj(o) { } + ~implicit_type() { } + + template + operator T() { return obj.as(); } + +private: + object const& obj; +}; + +inline object const& operator>> (object const& o, object& v) +{ + v = o; + return o; +} + +template +inline object const& operator>> (object const& o, T& v) +{ + // If you get a error 'class your_class has no member named 'msgpack_unpack', + // check the following: + // 1. The class your_class should have MSGPACK_DEFINE macro or + // + // 2. The class your_class should have the following operator declaration and + // definition: + // inline object const& operator>> (object const& o, std::string& v) + // + // See 3. + // + // 3. #include "msgpack.hpp" too early. + // Replace msgpack.hpp with msgpack_fwd.hpp, then, + // place operator declarations as follows: + // + // namespace msgpack { + // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) { + // object const& operator>> (object const& o, std::string& v); + // } + // } + // + // then, #include "msgpack.hpp", finally place the operator definitions as follows: + // + // namespace msgpack { + // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) { + // object const& operator>> (object const& o, std::string& v) { + // // converting operations here + // } + // } // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) + // } // namespace msgpack + // + v.msgpack_unpack(o.convert()); + return o; +} + +// obsolete +template +class define : public Type { +public: + typedef Type msgpack_type; + typedef define define_type; + + define() {} + define(const msgpack_type& v) : msgpack_type(v) {} + + template + void msgpack_pack(Packer& o) const + { + msgpack::operator<<(o, static_cast(*this)); + } + + void msgpack_unpack(object const& o) + { + msgpack::operator>>(o, static_cast(*this)); + } +}; + +namespace detail { +template +struct packer_serializer { + static packer& pack(packer& o, const T& v) { + // If you get a error 'const class your_class has no member named 'msgpack_pack', + // check the following: + // 1. The class your_class should have MSGPACK_DEFINE macro or + // + // 2. The class your_class should have the following operator declaration and + // definition: + // + // namespace msgpack { + // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) { + // template + // inline packer& operator<< (packer& o, const your_class& v) + // } // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) + // } // namespace msgpack + // + // See 3. + // + // 3. #include "msgpack.hpp" too early. + // Replace msgpack.hpp with msgpack_fwd.hpp, then, + // place operator declarations as follows: + // + // namespace msgpack { + // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) { + // template + // packer& operator<< (packer& o, const your_class& v); + // } // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) + // } // namespace msgpack + // + // then, #include "msgpack.hpp", finally place the operator definitions as follows: + // + // template + // inline packer& operator<< (packer& o, const your_class& v) { + // // packing operation + // } + // } // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) + // } // namespace msgpack + // + v.msgpack_pack(o); + return o; + } +}; +} + +// serialize operator +template +inline packer& operator<< (packer& o, const T& v) +{ + return detail::packer_serializer::pack(o, v); +} + +// deconvert operator +template +inline void operator<< (object::with_zone& o, const T& v) +{ + v.msgpack_object(static_cast(&o), o.zone); +} + +template +template +inline packer& packer::pack(const T& v) +{ + msgpack::operator<<(*this, v); + return *this; +} + +inline bool operator==(const object& x, const object& y) +{ + if(x.type != y.type) { return false; } + + switch(x.type) { + case type::NIL: + return true; + + case type::BOOLEAN: + return x.via.boolean == y.via.boolean; + + case type::POSITIVE_INTEGER: + return x.via.u64 == y.via.u64; + + case type::NEGATIVE_INTEGER: + return x.via.i64 == y.via.i64; + + case type::DOUBLE: + return x.via.dec == y.via.dec; + + case type::STR: + return x.via.str.size == y.via.str.size && + memcmp(x.via.str.ptr, y.via.str.ptr, x.via.str.size) == 0; + + case type::BIN: + return x.via.bin.size == y.via.bin.size && + memcmp(x.via.bin.ptr, y.via.bin.ptr, x.via.bin.size) == 0; + + case type::EXT: + return x.via.ext.size == y.via.ext.size && + memcmp(x.via.ext.ptr, y.via.ext.ptr, x.via.ext.size) == 0; + + case type::ARRAY: + if(x.via.array.size != y.via.array.size) { + return false; + } else if(x.via.array.size == 0) { + return true; + } else { + object* px = x.via.array.ptr; + object* const pxend = x.via.array.ptr + x.via.array.size; + object* py = y.via.array.ptr; + do { + if(!(*px == *py)) { + return false; + } + ++px; + ++py; + } while(px < pxend); + return true; + } + + case type::MAP: + if(x.via.map.size != y.via.map.size) { + return false; + } else if(x.via.map.size == 0) { + return true; + } else { + object_kv* px = x.via.map.ptr; + object_kv* const pxend = x.via.map.ptr + x.via.map.size; + object_kv* py = y.via.map.ptr; + do { + if(!(px->key == py->key) || !(px->val == py->val)) { + return false; + } + ++px; + ++py; + } while(px < pxend); + return true; + } + + default: + return false; + } +} + +template +inline bool operator==(const object& x, const T& y) +try { + return x == object(y); +} catch (msgpack::type_error&) { + return false; +} + +inline bool operator!=(const object& x, const object& y) +{ return !(x == y); } + +template +inline bool operator==(const T& y, const object x) +{ return x == y; } + +template +inline bool operator!=(const object& x, const T& y) +{ return !(x == y); } + +template +inline bool operator!=(const T& y, const object& x) +{ return x != y; } + + +inline object::implicit_type object::convert() const +{ + return implicit_type(*this); +} + +template +inline void object::convert(T& v) const +{ + msgpack::operator>>(*this, v); +} + +template +inline void object::convert(T* v) const +{ + convert(*v); +} + +template +inline T object::as() const +{ + T v; + convert(v); + return v; +} + + +inline object::object() +{ + type = type::NIL; +} + +template +inline object::object(const T& v) +{ + msgpack::operator<<(*this, v); +} + +template +inline object& object::operator=(const T& v) +{ + *this = object(v); + return *this; +} + +template +object::object(const T& v, zone& z) +{ + with_zone oz(z); + msgpack::operator<<(oz, v); + type = oz.type; + via = oz.via; +} + +template +object::object(const T& v, zone* z) +{ + with_zone oz(*z); + msgpack::operator<<(oz, v); + type = oz.type; + via = oz.via; +} + + +inline object::object(msgpack_object o) +{ + // FIXME beter way? + ::memcpy(this, &o, sizeof(o)); +} + +inline void operator<< (object& o, msgpack_object v) +{ + // FIXME beter way? + ::memcpy(&o, &v, sizeof(v)); +} + +inline object::operator msgpack_object() const +{ + // FIXME beter way? + msgpack_object obj; + ::memcpy(&obj, this, sizeof(obj)); + return obj; +} + + +// obsolete +template +inline void convert(T& v, object const& o) +{ + o.convert(v); +} + +// obsolete +template +inline void pack(packer& o, const T& v) +{ + o.pack(v); +} + +// obsolete +template +inline void pack_copy(packer& o, T v) +{ + pack(o, v); +} + + +template +inline packer& operator<< (packer& o, const object& v) +{ + switch(v.type) { + case type::NIL: + o.pack_nil(); + return o; + + case type::BOOLEAN: + if(v.via.boolean) { + o.pack_true(); + } else { + o.pack_false(); + } + return o; + + case type::POSITIVE_INTEGER: + o.pack_uint64(v.via.u64); + return o; + + case type::NEGATIVE_INTEGER: + o.pack_int64(v.via.i64); + return o; + + case type::DOUBLE: + o.pack_double(v.via.dec); + return o; + + case type::STR: + o.pack_str(v.via.str.size); + o.pack_str_body(v.via.str.ptr, v.via.str.size); + return o; + + case type::BIN: + o.pack_bin(v.via.bin.size); + o.pack_bin_body(v.via.bin.ptr, v.via.bin.size); + return o; + + case type::EXT: + o.pack_ext(v.via.ext.size, v.via.ext.type()); + o.pack_ext_body(v.via.ext.data(), v.via.ext.size); + return o; + + case type::ARRAY: + o.pack_array(v.via.array.size); + for(object* p(v.via.array.ptr), + * const pend(v.via.array.ptr + v.via.array.size); + p < pend; ++p) { + msgpack::operator<<(o, *p); + } + return o; + + case type::MAP: + o.pack_map(v.via.map.size); + for(object_kv* p(v.via.map.ptr), + * const pend(v.via.map.ptr + v.via.map.size); + p < pend; ++p) { + msgpack::operator<<(o, p->key); + msgpack::operator<<(o, p->val); + } + return o; + + default: + throw type_error(); + } +} + +inline std::ostream& operator<< (std::ostream& s, const object& o) +{ + switch(o.type) { + case type::NIL: + s << "nil"; + break; + + case type::BOOLEAN: + s << (o.via.boolean ? "true" : "false"); + break; + + case type::POSITIVE_INTEGER: + s << o.via.u64; + break; + + case type::NEGATIVE_INTEGER: + s << o.via.i64; + break; + + case type::DOUBLE: + s << o.via.dec; + break; + + case type::STR: + (s << '"').write(o.via.str.ptr, o.via.str.size) << '"'; + break; + + case type::BIN: + (s << '"').write(o.via.bin.ptr, o.via.bin.size) << '"'; + break; + + case type::EXT: + s << "EXT"; + + case type::ARRAY: + s << "["; + if(o.via.array.size != 0) { + object* p(o.via.array.ptr); + s << *p; + ++p; + for(object* const pend(o.via.array.ptr + o.via.array.size); + p < pend; ++p) { + s << ", " << *p; + } + } + s << "]"; + break; + + case type::MAP: + s << "{"; + if(o.via.map.size != 0) { + object_kv* p(o.via.map.ptr); + s << p->key << "=>" << p->val; + ++p; + for(object_kv* const pend(o.via.map.ptr + o.via.map.size); + p < pend; ++p) { + s << ", " << p->key << "=>" << p->val; + } + } + s << "}"; + break; + + default: + // FIXME + s << "#(o.type) << ">"; + } + return s; +} + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#include "msgpack/type.hpp" + +#endif /* msgpack/object.hpp */ diff --git a/include/msgpack/object_fwd.hpp b/include/msgpack/object_fwd.hpp new file mode 100644 index 00000000..a8ae4422 --- /dev/null +++ b/include/msgpack/object_fwd.hpp @@ -0,0 +1,170 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#ifndef MSGPACK_OBJECT_FWD_HPP +#define MSGPACK_OBJECT_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/zone.hpp" +#include "msgpack/object.h" + +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + + +namespace type { + enum object_type { + NIL = MSGPACK_OBJECT_NIL, + BOOLEAN = MSGPACK_OBJECT_BOOLEAN, + POSITIVE_INTEGER = MSGPACK_OBJECT_POSITIVE_INTEGER, + NEGATIVE_INTEGER = MSGPACK_OBJECT_NEGATIVE_INTEGER, + DOUBLE = MSGPACK_OBJECT_DOUBLE, + STR = MSGPACK_OBJECT_STR, + BIN = MSGPACK_OBJECT_BIN, + ARRAY = MSGPACK_OBJECT_ARRAY, + MAP = MSGPACK_OBJECT_MAP, + EXT = MSGPACK_OBJECT_EXT + }; +} + + +struct object; +struct object_kv; + +struct object_array { + uint32_t size; + object* ptr; +}; + +struct object_map { + uint32_t size; + object_kv* ptr; +}; + +struct object_str { + uint32_t size; + const char* ptr; +}; + +struct object_bin { + uint32_t size; + const char* ptr; +}; + +struct object_ext { + int8_t type() const { return ptr[0]; } + const char* data() const { return &ptr[1]; } + uint32_t size; + const char* ptr; +}; + +struct object { + union union_type { + bool boolean; + uint64_t u64; + int64_t i64; + double dec; + object_array array; + object_map map; + object_str str; + object_bin bin; + object_ext ext; + }; + + type::object_type type; + union_type via; + + bool is_nil() const { return type == type::NIL; } + + template + T as() const; + + template + void convert(T& v) const; + template + void convert(T* v) const; + + object(); + + object(msgpack_object o); + + template + explicit object(const T& v); + + template + object(const T& v, zone& z); + + // obsolete + template + object(const T& v, zone* z); + + template + object& operator=(const T& v); + + operator msgpack_object() const; + + struct with_zone; + +private: + struct implicit_type; + +public: + implicit_type convert() const; +}; + +class type_error : public std::bad_cast { }; + +struct object_kv { + object key; + object val; +}; + +namespace detail { +template +struct packer_serializer; +} // namespace detail + +object const& operator>> (object const& o, object& v); + +template +object const& operator>> (object const& o, T& v); + +template +void operator<< (object::with_zone& o, const T& v); + + +template +class packer; + +template +packer& operator<< (packer& o, const object& v); + +template +packer& operator<< (packer& o, const T& v); + +template +void operator<< (object::with_zone& o, const T& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_OBJECT_FWD_HPP diff --git a/src/msgpack/pack.h b/include/msgpack/pack.h similarity index 81% rename from src/msgpack/pack.h rename to include/msgpack/pack.h index 2502bd6a..ea0fbf70 100644 --- a/src/msgpack/pack.h +++ b/include/msgpack/pack.h @@ -15,8 +15,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#ifndef MSGPACK_PACK_H__ -#define MSGPACK_PACK_H__ +#ifndef MSGPACK_PACK_H +#define MSGPACK_PACK_H #include "pack_define.h" #include "object.h" @@ -43,8 +43,8 @@ extern "C" { typedef int (*msgpack_packer_write)(void* data, const char* buf, size_t len); typedef struct msgpack_packer { - void* data; - msgpack_packer_write callback; + void* data; + msgpack_packer_write callback; } msgpack_packer; static void msgpack_packer_init(msgpack_packer* pk, void* data, msgpack_packer_write callback); @@ -94,8 +94,14 @@ static int msgpack_pack_array(msgpack_packer* pk, size_t n); static int msgpack_pack_map(msgpack_packer* pk, size_t n); -static int msgpack_pack_raw(msgpack_packer* pk, size_t l); -static int msgpack_pack_raw_body(msgpack_packer* pk, const void* b, size_t l); +static int msgpack_pack_str(msgpack_packer* pk, size_t l); +static int msgpack_pack_str_body(msgpack_packer* pk, const void* b, size_t l); + +static int msgpack_pack_bin(msgpack_packer* pk, size_t l); +static int msgpack_pack_bin_body(msgpack_packer* pk, const void* b, size_t l); + +static int msgpack_pack_ext(msgpack_packer* pk, size_t l, int8_t type); +static int msgpack_pack_ext_body(msgpack_packer* pk, const void* b, size_t l); int msgpack_pack_object(msgpack_packer* pk, msgpack_object d); @@ -104,38 +110,38 @@ int msgpack_pack_object(msgpack_packer* pk, msgpack_object d); #define msgpack_pack_inline_func(name) \ - inline int msgpack_pack ## name + inline int msgpack_pack ## name #define msgpack_pack_inline_func_cint(name) \ - inline int msgpack_pack ## name + inline int msgpack_pack ## name #define msgpack_pack_inline_func_fixint(name) \ - inline int msgpack_pack_fix ## name + inline int msgpack_pack_fix ## name #define msgpack_pack_user msgpack_packer* #define msgpack_pack_append_buffer(user, buf, len) \ - return (*(user)->callback)((user)->data, (const char*)buf, len) + return (*(user)->callback)((user)->data, (const char*)buf, len) #include "pack_template.h" inline void msgpack_packer_init(msgpack_packer* pk, void* data, msgpack_packer_write callback) { - pk->data = data; - pk->callback = callback; + pk->data = data; + pk->callback = callback; } inline msgpack_packer* msgpack_packer_new(void* data, msgpack_packer_write callback) { - msgpack_packer* pk = (msgpack_packer*)calloc(1, sizeof(msgpack_packer)); - if(!pk) { return NULL; } - msgpack_packer_init(pk, data, callback); - return pk; + msgpack_packer* pk = (msgpack_packer*)calloc(1, sizeof(msgpack_packer)); + if(!pk) { return NULL; } + msgpack_packer_init(pk, data, callback); + return pk; } inline void msgpack_packer_free(msgpack_packer* pk) { - free(pk); + free(pk); } diff --git a/include/msgpack/pack.hpp b/include/msgpack/pack.hpp new file mode 100644 index 00000000..088d69a6 --- /dev/null +++ b/include/msgpack/pack.hpp @@ -0,0 +1,1028 @@ +// +// MessagePack for C++ serializing 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_PACK_HPP +#define MSGPACK_PACK_HPP + +#include "msgpack/versioning.hpp" + +#include +#include +#include + +#include "sysdep.h" + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +class packer { +public: + packer(Stream* s); + packer(Stream& s); + +public: + template + packer& pack(const T& v); + + packer& pack_uint8(uint8_t d); + packer& pack_uint16(uint16_t d); + packer& pack_uint32(uint32_t d); + packer& pack_uint64(uint64_t d); + packer& pack_int8(int8_t d); + packer& pack_int16(int16_t d); + packer& pack_int32(int32_t d); + packer& pack_int64(int64_t d); + + packer& pack_fix_uint8(uint8_t d); + packer& pack_fix_uint16(uint16_t d); + packer& pack_fix_uint32(uint32_t d); + packer& pack_fix_uint64(uint64_t d); + packer& pack_fix_int8(int8_t d); + packer& pack_fix_int16(int16_t d); + packer& pack_fix_int32(int32_t d); + packer& pack_fix_int64(int64_t d); + + packer& pack_char(char d); + packer& pack_signed_char(signed char d); + packer& pack_short(short d); + packer& pack_int(int d); + packer& pack_long(long d); + packer& pack_long_long(long long d); + packer& pack_unsigned_char(unsigned char d); + packer& pack_unsigned_short(unsigned short d); + packer& pack_unsigned_int(unsigned int d); + packer& pack_unsigned_long(unsigned long d); + packer& pack_unsigned_long_long(unsigned long long d); + + packer& pack_float(float d); + packer& pack_double(double d); + + packer& pack_nil(); + packer& pack_true(); + packer& pack_false(); + + packer& pack_array(size_t n); + + packer& pack_map(size_t n); + + packer& pack_str(size_t l); + packer& pack_str_body(const char* b, size_t l); + + packer& pack_bin(size_t l); + packer& pack_bin_body(const char* b, size_t l); + + packer& pack_ext(size_t l, int8_t type); + packer& pack_ext_body(const char* b, size_t l); + +private: + template + void pack_imp_uint8(T d); + template + void pack_imp_uint16(T d); + template + void pack_imp_uint32(T d); + template + void pack_imp_uint64(T d); + template + void pack_imp_int8(T d); + template + void pack_imp_int16(T d); + template + void pack_imp_int32(T d); + template + void pack_imp_int64(T d); + + void append_buffer(const char* buf, size_t len) + { m_stream.write(buf, len); } + +private: + Stream& m_stream; + +private: + packer(); +}; + + +template +inline void pack(Stream* s, const T& v) +{ + packer(*s).pack(v); +} + +template +inline void pack(Stream& s, const T& v) +{ + packer(s).pack(v); +} + +#if defined(__LITTLE_ENDIAN__) +template +inline char take8_8(T d) { + return static_cast(reinterpret_cast(&d)[0]); +} +template +inline char take8_16(T d) { + return static_cast(reinterpret_cast(&d)[0]); +} +template +inline char take8_32(T d) { + return static_cast(reinterpret_cast(&d)[0]); +} +template +inline char take8_64(T d) { + return static_cast(reinterpret_cast(&d)[0]); +} + +#elif defined(__BIG_ENDIAN__) + +template +inline char take8_8(T d) { + return static_cast(reinterpret_cast(&d)[0]); +} +template +inline char take8_16(T d) { + return static_cast(reinterpret_cast(&d)[1]); +} +template +inline char take8_32(T d) { + return static_cast(reinterpret_cast(&d)[3]); +} +template +inline char take8_64(T d) { + return static_cast(reinterpret_cast(&d)[7]); +} + +#endif + +template +inline packer::packer(Stream* s) : m_stream(*s) { } + +template +inline packer::packer(Stream& s) : m_stream(s) { } + + +template +inline packer& packer::pack_uint8(uint8_t d) +{ pack_imp_uint8(d); return *this; } + +template +inline packer& packer::pack_uint16(uint16_t d) +{ pack_imp_uint16(d); return *this; } + +template +inline packer& packer::pack_uint32(uint32_t d) +{ pack_imp_uint32(d); return *this; } + +template +inline packer& packer::pack_uint64(uint64_t d) +{ pack_imp_uint64(d); return *this; } + +template +inline packer& packer::pack_int8(int8_t d) +{ pack_imp_int8(d); return *this; } + +template +inline packer& packer::pack_int16(int16_t d) +{ pack_imp_int16(d); return *this; } + +template +inline packer& packer::pack_int32(int32_t d) +{ pack_imp_int32(d); return *this; } + +template +inline packer& packer::pack_int64(int64_t d) +{ pack_imp_int64(d); return *this;} + + +template +inline packer& packer::pack_fix_uint8(uint8_t d) +{ + char buf[2] = {static_cast(0xcc), take8_8(d)}; + append_buffer(buf, 2); + return *this; +} + +template +inline packer& packer::pack_fix_uint16(uint16_t d) +{ + char buf[3]; + buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], d); + append_buffer(buf, 3); + return *this; +} + +template +inline packer& packer::pack_fix_uint32(uint32_t d) +{ + char buf[5]; + buf[0] = static_cast(0xce); _msgpack_store32(&buf[1], d); + append_buffer(buf, 5); + return *this; +} + +template +inline packer& packer::pack_fix_uint64(uint64_t d) +{ + char buf[9]; + buf[0] = static_cast(0xcf); _msgpack_store64(&buf[1], d); + append_buffer(buf, 9); + return *this; +} + +template +inline packer& packer::pack_fix_int8(int8_t d) +{ + char buf[2] = {static_cast(0xd0), take8_8(d)}; + append_buffer(buf, 2); + return *this; +} + +template +inline packer& packer::pack_fix_int16(int16_t d) +{ + char buf[3]; + buf[0] = static_cast(0xd1); _msgpack_store16(&buf[1], d); + append_buffer(buf, 3); + return *this; +} + +template +inline packer& packer::pack_fix_int32(int32_t d) +{ + char buf[5]; + buf[0] = static_cast(0xd2); _msgpack_store32(&buf[1], d); + append_buffer(buf, 5); + return *this; +} + +template +inline packer& packer::pack_fix_int64(int64_t d) +{ + char buf[9]; + buf[0] = static_cast(0xd3); _msgpack_store64(&buf[1], d); + append_buffer(buf, 9); + return *this; +} + + +template +inline packer& packer::pack_char(char d) +{ _pack_char(m_stream, d); return *this; } + +template +inline packer& packer::pack_signed_char(signed char d) +{ _pack_signed_char(m_stream, d); return *this; } + +template +inline packer& packer::pack_short(short d) +{ +#if defined(SIZEOF_SHORT) +#if SIZEOF_SHORT == 2 + pack_imp_int16(d); +#elif SIZEOF_SHORT == 4 + pack_imp_int32(d); +#else + pack_imp_int64(d); +#endif + +#elif defined(SHRT_MAX) +#if SHRT_MAX == 0x7fff + pack_imp_int16(d); +#elif SHRT_MAX == 0x7fffffff + pack_imp_int32(d); +#else + pack_imp_int64(d); +#endif + +#else + if(sizeof(short) == 2) { + pack_imp_int16(d); + } else if(sizeof(short) == 4) { + pack_imp_int32(d); + } else { + pack_imp_int64(d); + } +#endif + return *this; +} + +template +inline packer& packer::pack_int(int d) +{ +#if defined(SIZEOF_INT) +#if SIZEOF_INT == 2 + pack_imp_int16(d); +#elif SIZEOF_INT == 4 + pack_imp_int32(d); +#else + pack_imp_int64(d); +#endif + +#elif defined(INT_MAX) +#if INT_MAX == 0x7fff + pack_imp_int16(d); +#elif INT_MAX == 0x7fffffff + pack_imp_int32(d); +#else + pack_imp_int64(d); +#endif + +#else + if(sizeof(int) == 2) { + pack_imp_int16(d); + } else if(sizeof(int) == 4) { + pack_imp_int32(d); + } else { + pack_imp_int64(d); + } +#endif + return *this; +} + +template +inline packer& packer::pack_long(long d) +{ +#if defined(SIZEOF_LONG) +#if SIZEOF_LONG == 2 + pack_imp_int16(d); +#elif SIZEOF_LONG == 4 + pack_imp_int32(d); +#else + pack_imp_int64(d); +#endif + +#elif defined(LONG_MAX) +#if LONG_MAX == 0x7fffL + pack_imp_int16(d); +#elif LONG_MAX == 0x7fffffffL + pack_imp_int32(d); +#else + pack_imp_int64(d); +#endif + +#else + if(sizeof(long) == 2) { + pack_imp_int16(d); + } else if(sizeof(long) == 4) { + pack_imp_int32(d); + } else { + pack_imp_int64(d); + } +#endif + return *this; +} + +template +inline packer& packer::pack_long_long(long long d) +{ +#if defined(SIZEOF_LONG_LONG) +#if SIZEOF_LONG_LONG == 2 + pack_imp_int16(d); +#elif SIZEOF_LONG_LONG == 4 + pack_imp_int32(d); +#else + pack_imp_int64(d); +#endif + +#elif defined(LLONG_MAX) +#if LLONG_MAX == 0x7fffL + pack_imp_int16(d); +#elif LLONG_MAX == 0x7fffffffL + pack_imp_int32(d); +#else + pack_imp_int64(d); +#endif + +#else + if(sizeof(long long) == 2) { + pack_imp_int16(d); + } else if(sizeof(long long) == 4) { + pack_imp_int32(d); + } else { + pack_imp_int64(d); + } +#endif + return *this; +} + + +template +inline packer& packer::pack_unsigned_char(unsigned char d) +{ _pack_unsigned_char(m_stream, d); return *this; } + +template +inline packer& packer::pack_unsigned_short(unsigned short d) +{ +#if defined(SIZEOF_SHORT) +#if SIZEOF_SHORT == 2 + pack_imp_uint16(d); +#elif SIZEOF_SHORT == 4 + pack_imp_uint32(d); +#else + pack_imp_uint64(d); +#endif + +#elif defined(USHRT_MAX) +#if USHRT_MAX == 0xffffU + pack_imp_uint16(d); +#elif USHRT_MAX == 0xffffffffU + pack_imp_uint32(d); +#else + pack_imp_uint64(d); +#endif + +#else + if(sizeof(unsigned short) == 2) { + pack_imp_uint16(d); + } else if(sizeof(unsigned short) == 4) { + pack_imp_uint32(d); + } else { + pack_imp_uint64(d); + } +#endif + return *this; +} + +template +inline packer& packer::pack_unsigned_int(unsigned int d) +{ +#if defined(SIZEOF_INT) +#if SIZEOF_INT == 2 + pack_imp_uint16(d); +#elif SIZEOF_INT == 4 + pack_imp_uint32(d); +#else + pack_imp_uint64(d); +#endif + +#elif defined(UINT_MAX) +#if UINT_MAX == 0xffffU + pack_imp_uint16(d); +#elif UINT_MAX == 0xffffffffU + pack_imp_uint32(d); +#else + pack_imp_uint64(d); +#endif + +#else + if(sizeof(unsigned int) == 2) { + pack_imp_uint16(d); + } else if(sizeof(unsigned int) == 4) { + pack_imp_uint32(d); + } else { + pack_imp_uint64(d); + } +#endif + return *this; +} + +template +inline packer& packer::pack_unsigned_long(unsigned long d) +{ +#if defined(SIZEOF_LONG) +#if SIZEOF_LONG == 2 + pack_imp_uint16(d); +#elif SIZEOF_LONG == 4 + pack_imp_uint32(d); +#else + pack_imp_uint64(d); +#endif + +#elif defined(ULONG_MAX) +#if ULONG_MAX == 0xffffUL + pack_imp_uint16(d); +#elif ULONG_MAX == 0xffffffffUL + pack_imp_uint32(d); +#else + pack_imp_uint64(d); +#endif + +#else + if(sizeof(unsigned long) == 2) { + pack_imp_uint16(d); + } else if(sizeof(unsigned long) == 4) { + pack_imp_uint32(d); + } else { + pack_imp_uint64(d); + } +#endif + return *this; +} + +template +inline packer& packer::pack_unsigned_long_long(unsigned long long d) +{ +#if defined(SIZEOF_LONG_LONG) +#if SIZEOF_LONG_LONG == 2 + pack_imp_uint16(d); +#elif SIZEOF_LONG_LONG == 4 + pack_imp_uint32(d); +#else + pack_imp_uint64(d); +#endif + +#elif defined(ULLONG_MAX) +#if ULLONG_MAX == 0xffffUL + pack_imp_uint16(d); +#elif ULLONG_MAX == 0xffffffffUL + pack_imp_uint32(d); +#else + pack_imp_uint64(d); +#endif + +#else + if(sizeof(unsigned long long) == 2) { + pack_imp_uint16(d); + } else if(sizeof(unsigned long long) == 4) { + pack_imp_uint32(d); + } else { + pack_imp_uint64(d); + } +#endif + return *this; +} + + +template +inline packer& packer::pack_float(float d) +{ + union { float f; uint32_t i; } mem; + mem.f = d; + char buf[5]; + buf[0] = static_cast(0xca); _msgpack_store32(&buf[1], mem.i); + append_buffer(buf, 5); + return *this; +} + +template +inline packer& packer::pack_double(double d) +{ + union { double f; uint64_t i; } mem; + mem.f = d; + char buf[9]; + buf[0] = static_cast(0xcb); +#if defined(__arm__) && !(__ARM_EABI__) // arm-oabi + // https://github.com/msgpack/msgpack-perl/pull/1 + mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); +#endif + _msgpack_store64(&buf[1], mem.i); + append_buffer(buf, 9); + return *this; +} + + +template +inline packer& packer::pack_nil() +{ + const char d = static_cast(0xc0); + append_buffer(&d, 1); + return *this; +} + +template +inline packer& packer::pack_true() +{ + const char d = static_cast(0xc3); + append_buffer(&d, 1); + return *this; +} + +template +inline packer& packer::pack_false() +{ + const char d = static_cast(0xc2); + append_buffer(&d, 1); + return *this; +} + + +template +inline packer& packer::pack_array(size_t n) +{ + if(n < 16) { + char d = static_cast(0x90 | n); + append_buffer(&d, 1); + } else if(n < 65536) { + char buf[3]; + buf[0] = static_cast(0xdc); _msgpack_store16(&buf[1], static_cast(n)); + append_buffer(buf, 3); + } else { + char buf[5]; + buf[0] = static_cast(0xdd); _msgpack_store32(&buf[1], static_cast(n)); + append_buffer(buf, 5); + } + return *this; +} + +template +inline packer& packer::pack_map(size_t n) +{ + if(n < 16) { + unsigned char d = 0x80 | n; + char buf = take8_8(d); + append_buffer(&buf, 1); + } else if(n < 65536) { + char buf[3]; + buf[0] = static_cast(0xde); _msgpack_store16(&buf[1], static_cast(n)); + append_buffer(buf, 3); + } else { + char buf[5]; + buf[0] = static_cast(0xdf); _msgpack_store32(&buf[1], static_cast(n)); + append_buffer(buf, 5); + } + return *this; +} + +template +inline packer& packer::pack_str(size_t l) +{ + if(l < 32) { + unsigned char d = 0xa0 | static_cast(l); + char buf = take8_8(d); + append_buffer(&buf, 1); + } else if(l < 256) { + char buf[2]; + buf[0] = static_cast(0xd9); buf[1] = static_cast(l); + append_buffer(buf, 2); + } else if(l < 65536) { + char buf[3]; + buf[0] = static_cast(0xda); _msgpack_store16(&buf[1], static_cast(l)); + append_buffer(buf, 3); + } else { + char buf[5]; + buf[0] = static_cast(0xdb); _msgpack_store32(&buf[1], static_cast(l)); + append_buffer(buf, 5); + } + return *this; +} + +template +inline packer& packer::pack_str_body(const char* b, size_t l) +{ + append_buffer(b, l); + return *this; +} + +template +inline packer& packer::pack_bin(size_t l) +{ + if(l < 256) { + char buf[2]; + buf[0] = static_cast(0xc4); buf[1] = static_cast(l); + append_buffer(buf, 2); + } else if(l < 65536) { + char buf[3]; + buf[0] = static_cast(0xc5); _msgpack_store16(&buf[1], static_cast(l)); + append_buffer(buf, 3); + } else { + char buf[5]; + buf[0] = static_cast(0xc6); _msgpack_store32(&buf[1], static_cast(l)); + append_buffer(buf, 5); + } + return *this; +} + +template +inline packer& packer::pack_bin_body(const char* b, size_t l) +{ + append_buffer(b, l); + return *this; +} + +template +inline packer& packer::pack_ext(size_t l, int8_t type) +{ + switch(l) { + case 1: { + char buf[2]; + buf[0] = static_cast(0xd4); + buf[1] = static_cast(type); + append_buffer(buf, 2); + } break; + case 2: { + char buf[2]; + buf[0] = static_cast(0xd5); + buf[1] = static_cast(type); + append_buffer(buf, 2); + } break; + case 4: { + char buf[2]; + buf[0] = static_cast(0xd6); + buf[1] = static_cast(type); + append_buffer(buf, 2); + } break; + case 8: { + char buf[2]; + buf[0] = static_cast(0xd7); + buf[1] = static_cast(type); + append_buffer(buf, 2); + } break; + case 16: { + char buf[2]; + buf[0] = static_cast(0xd8); + buf[1] = static_cast(type); + append_buffer(buf, 2); + } break; + default: + if(l < 256) { + char buf[3]; + buf[0] = static_cast(0xc7); + buf[1] = static_cast(l); + buf[2] = static_cast(type); + append_buffer(buf, 3); + } else if(l < 65536) { + char buf[4]; + buf[0] = static_cast(0xc8); + _msgpack_store16(&buf[1], static_cast(l)); + buf[3] = static_cast(type); + append_buffer(buf, 4); + } else { + char buf[6]; + buf[0] = static_cast(0xc9); + _msgpack_store32(&buf[1], static_cast(l)); + buf[5] = static_cast(type); + append_buffer(buf, 6); + } + break; + } + return *this; +} + +template +inline packer& packer::pack_ext_body(const char* b, size_t l) +{ + append_buffer(b, l); + return *this; +} + +template +template +inline void packer::pack_imp_uint8(T d) +{ + if(d < (1<<7)) { + /* fixnum */ + char buf = take8_8(d); + append_buffer(&buf, 1); + } else { + /* unsigned 8 */ + char buf[2] = {static_cast(0xcc), take8_8(d)}; + append_buffer(buf, 2); + } +} + +template +template +inline void packer::pack_imp_uint16(T d) +{ + if(d < (1<<7)) { + /* fixnum */ + char buf = take8_16(d); + append_buffer(&buf, 1); + } else if(d < (1<<8)) { + /* unsigned 8 */ + char buf[2] = {static_cast(0xcc), take8_16(d)}; + append_buffer(buf, 2); + } else { + /* unsigned 16 */ + char buf[3]; + buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], static_cast(d)); + append_buffer(buf, 3); + } +} + +template +template +inline void packer::pack_imp_uint32(T d) +{ + if(d < (1<<8)) { + if(d < (1<<7)) { + /* fixnum */ + char buf = take8_32(d); + append_buffer(&buf, 1); + } else { + /* unsigned 8 */ + char buf[2] = {static_cast(0xcc), take8_32(d)}; + append_buffer(buf, 2); + } + } else { + if(d < (1<<16)) { + /* unsigned 16 */ + char buf[3]; + buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], static_cast(d)); + append_buffer(buf, 3); + } else { + /* unsigned 32 */ + char buf[5]; + buf[0] = static_cast(0xce); _msgpack_store32(&buf[1], static_cast(d)); + append_buffer(buf, 5); + } + } +} + +template +template +inline void packer::pack_imp_uint64(T d) +{ + if(d < (1ULL<<8)) { + if(d < (1ULL<<7)) { + /* fixnum */ + char buf = take8_64(d); + append_buffer(&buf, 1); + } else { + /* unsigned 8 */ + char buf[2] = {static_cast(0xcc), take8_64(d)}; + append_buffer(buf, 2); + } + } else { + if(d < (1ULL<<16)) { + /* unsigned 16 */ + char buf[3]; + buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], static_cast(d)); + append_buffer(buf, 3); + } else if(d < (1ULL<<32)) { + /* unsigned 32 */ + char buf[5]; + buf[0] = static_cast(0xce); _msgpack_store32(&buf[1], static_cast(d)); + append_buffer(buf, 5); + } else { + /* unsigned 64 */ + char buf[9]; + buf[0] = static_cast(0xcf); _msgpack_store64(&buf[1], d); + append_buffer(buf, 9); + } + } +} + +template +template +inline void packer::pack_imp_int8(T d) +{ + if(d < -(1<<5)) { + /* signed 8 */ + char buf[2] = {static_cast(0xd0), take8_8(d)}; + append_buffer(buf, 2); + } else { + /* fixnum */ + char buf = take8_8(d); + append_buffer(&buf, 1); + } +} + +template +template +inline void packer::pack_imp_int16(T d) +{ + if(d < -(1<<5)) { + if(d < -(1<<7)) { + /* signed 16 */ + char buf[3]; + buf[0] = static_cast(0xd1); _msgpack_store16(&buf[1], static_cast(d)); + append_buffer(buf, 3); + } else { + /* signed 8 */ + char buf[2] = {static_cast(0xd0), take8_16(d)}; + append_buffer(buf, 2); + } + } else if(d < (1<<7)) { + /* fixnum */ + char buf = take8_16(d); + append_buffer(&buf, 1); + } else { + if(d < (1<<8)) { + /* unsigned 8 */ + char buf[2] = {static_cast(0xcc), take8_16(d)}; + append_buffer(buf, 2); + } else { + /* unsigned 16 */ + char buf[3]; + buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], static_cast(d)); + append_buffer(buf, 3); + } + } +} + +template +template +inline void packer::pack_imp_int32(T d) +{ + if(d < -(1<<5)) { + if(d < -(1<<15)) { + /* signed 32 */ + char buf[5]; + buf[0] = static_cast(0xd2); _msgpack_store32(&buf[1], static_cast(d)); + append_buffer(buf, 5); + } else if(d < -(1<<7)) { + /* signed 16 */ + char buf[3]; + buf[0] = static_cast(0xd1); _msgpack_store16(&buf[1], static_cast(d)); + append_buffer(buf, 3); + } else { + /* signed 8 */ + char buf[2] = { static_cast(0xd0), take8_32(d)}; + append_buffer(buf, 2); + } + } else if(d < (1<<7)) { + /* fixnum */ + char buf = take8_32(d); + append_buffer(&buf, 1); + } else { + if(d < (1<<8)) { + /* unsigned 8 */ + char buf[2] = { static_cast(0xcc), take8_32(d)}; + append_buffer(buf, 2); + } else if(d < (1<<16)) { + /* unsigned 16 */ + char buf[3]; + buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], static_cast(d)); + append_buffer(buf, 3); + } else { + /* unsigned 32 */ + char buf[5]; + buf[0] = static_cast(0xce); _msgpack_store32(&buf[1], static_cast(d)); + append_buffer(buf, 5); + } + } +} + +template +template +inline void packer::pack_imp_int64(T d) +{ + if(d < -(1LL<<5)) { + if(d < -(1LL<<15)) { + if(d < -(1LL<<31)) { + /* signed 64 */ + char buf[9]; + buf[0] = static_cast(0xd3); _msgpack_store64(&buf[1], d); + append_buffer(buf, 9); + } else { + /* signed 32 */ + char buf[5]; + buf[0] = static_cast(0xd2); _msgpack_store32(&buf[1], static_cast(d)); + append_buffer(buf, 5); + } + } else { + if(d < -(1<<7)) { + /* signed 16 */ + char buf[3]; + buf[0] = static_cast(0xd1); _msgpack_store16(&buf[1], static_cast(d)); + append_buffer(buf, 3); + } else { + /* signed 8 */ + char buf[2] = {static_cast(0xd0), take8_64(d)}; + append_buffer(buf, 2); + } + } + } else if(d < (1<<7)) { + /* fixnum */ + char buf = take8_64(d); + append_buffer(&buf, 1); + } else { + if(d < (1LL<<16)) { + if(d < (1<<8)) { + /* unsigned 8 */ + char buf[2] = {static_cast(0xcc), take8_64(d)}; + append_buffer(buf, 2); + } else { + /* unsigned 16 */ + char buf[3]; + buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], static_cast(d)); + append_buffer(buf, 3); + } + } else { + if(d < (1LL<<32)) { + /* unsigned 32 */ + char buf[5]; + buf[0] = static_cast(0xce); _msgpack_store32(&buf[1], static_cast(d)); + append_buffer(buf, 5); + } else { + /* unsigned 64 */ + char buf[9]; + buf[0] = static_cast(0xcf); _msgpack_store64(&buf[1], d); + append_buffer(buf, 9); + } + } + } +} + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif /* msgpack/pack.hpp */ diff --git a/src/msgpack/pack_define.h b/include/msgpack/pack_define.h similarity index 92% rename from src/msgpack/pack_define.h rename to include/msgpack/pack_define.h index 4845d52e..991ee5c5 100644 --- a/src/msgpack/pack_define.h +++ b/include/msgpack/pack_define.h @@ -15,8 +15,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#ifndef MSGPACK_PACK_DEFINE_H__ -#define MSGPACK_PACK_DEFINE_H__ +#ifndef MSGPACK_PACK_DEFINE_H +#define MSGPACK_PACK_DEFINE_H #include "msgpack/sysdep.h" #include diff --git a/include/msgpack/pack_template.h b/include/msgpack/pack_template.h new file mode 100644 index 00000000..fc47619f --- /dev/null +++ b/include/msgpack/pack_template.h @@ -0,0 +1,889 @@ +/* + * MessagePack packing routine template + * + * Copyright (C) 2008-2010 FURUHASHI Sadayuki + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * 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. + */ + +#if defined(__LITTLE_ENDIAN__) +#define TAKE8_8(d) ((uint8_t*)&d)[0] +#define TAKE8_16(d) ((uint8_t*)&d)[0] +#define TAKE8_32(d) ((uint8_t*)&d)[0] +#define TAKE8_64(d) ((uint8_t*)&d)[0] +#elif defined(__BIG_ENDIAN__) +#define TAKE8_8(d) ((uint8_t*)&d)[0] +#define TAKE8_16(d) ((uint8_t*)&d)[1] +#define TAKE8_32(d) ((uint8_t*)&d)[3] +#define TAKE8_64(d) ((uint8_t*)&d)[7] +#endif + +#ifndef msgpack_pack_inline_func +#error msgpack_pack_inline_func template is not defined +#endif + +#ifndef msgpack_pack_user +#error msgpack_pack_user type is not defined +#endif + +#ifndef msgpack_pack_append_buffer +#error msgpack_pack_append_buffer callback is not defined +#endif + + +/* + * Integer + */ + +#define msgpack_pack_real_uint8(x, d) \ +do { \ + if(d < (1<<7)) { \ + /* fixnum */ \ + msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); \ + } else { \ + /* unsigned 8 */ \ + unsigned char buf[2] = {0xcc, TAKE8_8(d)}; \ + msgpack_pack_append_buffer(x, buf, 2); \ + } \ +} while(0) + +#define msgpack_pack_real_uint16(x, d) \ +do { \ + if(d < (1<<7)) { \ + /* fixnum */ \ + msgpack_pack_append_buffer(x, &TAKE8_16(d), 1); \ + } else if(d < (1<<8)) { \ + /* unsigned 8 */ \ + unsigned char buf[2] = {0xcc, TAKE8_16(d)}; \ + msgpack_pack_append_buffer(x, buf, 2); \ + } else { \ + /* unsigned 16 */ \ + unsigned char buf[3]; \ + buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ + msgpack_pack_append_buffer(x, buf, 3); \ + } \ +} while(0) + +#define msgpack_pack_real_uint32(x, d) \ +do { \ + if(d < (1<<8)) { \ + if(d < (1<<7)) { \ + /* fixnum */ \ + msgpack_pack_append_buffer(x, &TAKE8_32(d), 1); \ + } else { \ + /* unsigned 8 */ \ + unsigned char buf[2] = {0xcc, TAKE8_32(d)}; \ + msgpack_pack_append_buffer(x, buf, 2); \ + } \ + } else { \ + if(d < (1<<16)) { \ + /* unsigned 16 */ \ + unsigned char buf[3]; \ + buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ + msgpack_pack_append_buffer(x, buf, 3); \ + } else { \ + /* unsigned 32 */ \ + unsigned char buf[5]; \ + buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \ + msgpack_pack_append_buffer(x, buf, 5); \ + } \ + } \ +} while(0) + +#define msgpack_pack_real_uint64(x, d) \ +do { \ + if(d < (1ULL<<8)) { \ + if(d < (1ULL<<7)) { \ + /* fixnum */ \ + msgpack_pack_append_buffer(x, &TAKE8_64(d), 1); \ + } else { \ + /* unsigned 8 */ \ + unsigned char buf[2] = {0xcc, TAKE8_64(d)}; \ + msgpack_pack_append_buffer(x, buf, 2); \ + } \ + } else { \ + if(d < (1ULL<<16)) { \ + /* unsigned 16 */ \ + unsigned char buf[3]; \ + buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ + msgpack_pack_append_buffer(x, buf, 3); \ + } else if(d < (1ULL<<32)) { \ + /* unsigned 32 */ \ + unsigned char buf[5]; \ + buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \ + msgpack_pack_append_buffer(x, buf, 5); \ + } else { \ + /* unsigned 64 */ \ + unsigned char buf[9]; \ + buf[0] = 0xcf; _msgpack_store64(&buf[1], d); \ + msgpack_pack_append_buffer(x, buf, 9); \ + } \ + } \ +} while(0) + +#define msgpack_pack_real_int8(x, d) \ +do { \ + if(d < -(1<<5)) { \ + /* signed 8 */ \ + unsigned char buf[2] = {0xd0, TAKE8_8(d)}; \ + msgpack_pack_append_buffer(x, buf, 2); \ + } else { \ + /* fixnum */ \ + msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); \ + } \ +} while(0) + +#define msgpack_pack_real_int16(x, d) \ +do { \ + if(d < -(1<<5)) { \ + if(d < -(1<<7)) { \ + /* signed 16 */ \ + unsigned char buf[3]; \ + buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \ + msgpack_pack_append_buffer(x, buf, 3); \ + } else { \ + /* signed 8 */ \ + unsigned char buf[2] = {0xd0, TAKE8_16(d)}; \ + msgpack_pack_append_buffer(x, buf, 2); \ + } \ + } else if(d < (1<<7)) { \ + /* fixnum */ \ + msgpack_pack_append_buffer(x, &TAKE8_16(d), 1); \ + } else { \ + if(d < (1<<8)) { \ + /* unsigned 8 */ \ + unsigned char buf[2] = {0xcc, TAKE8_16(d)}; \ + msgpack_pack_append_buffer(x, buf, 2); \ + } else { \ + /* unsigned 16 */ \ + unsigned char buf[3]; \ + buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ + msgpack_pack_append_buffer(x, buf, 3); \ + } \ + } \ +} while(0) + +#define msgpack_pack_real_int32(x, d) \ +do { \ + if(d < -(1<<5)) { \ + if(d < -(1<<15)) { \ + /* signed 32 */ \ + unsigned char buf[5]; \ + buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); \ + msgpack_pack_append_buffer(x, buf, 5); \ + } else if(d < -(1<<7)) { \ + /* signed 16 */ \ + unsigned char buf[3]; \ + buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \ + msgpack_pack_append_buffer(x, buf, 3); \ + } else { \ + /* signed 8 */ \ + unsigned char buf[2] = {0xd0, TAKE8_32(d)}; \ + msgpack_pack_append_buffer(x, buf, 2); \ + } \ + } else if(d < (1<<7)) { \ + /* fixnum */ \ + msgpack_pack_append_buffer(x, &TAKE8_32(d), 1); \ + } else { \ + if(d < (1<<8)) { \ + /* unsigned 8 */ \ + unsigned char buf[2] = {0xcc, TAKE8_32(d)}; \ + msgpack_pack_append_buffer(x, buf, 2); \ + } else if(d < (1<<16)) { \ + /* unsigned 16 */ \ + unsigned char buf[3]; \ + buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ + msgpack_pack_append_buffer(x, buf, 3); \ + } else { \ + /* unsigned 32 */ \ + unsigned char buf[5]; \ + buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \ + msgpack_pack_append_buffer(x, buf, 5); \ + } \ + } \ +} while(0) + +#define msgpack_pack_real_int64(x, d) \ +do { \ + if(d < -(1LL<<5)) { \ + if(d < -(1LL<<15)) { \ + if(d < -(1LL<<31)) { \ + /* signed 64 */ \ + unsigned char buf[9]; \ + buf[0] = 0xd3; _msgpack_store64(&buf[1], d); \ + msgpack_pack_append_buffer(x, buf, 9); \ + } else { \ + /* signed 32 */ \ + unsigned char buf[5]; \ + buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); \ + msgpack_pack_append_buffer(x, buf, 5); \ + } \ + } else { \ + if(d < -(1<<7)) { \ + /* signed 16 */ \ + unsigned char buf[3]; \ + buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \ + msgpack_pack_append_buffer(x, buf, 3); \ + } else { \ + /* signed 8 */ \ + unsigned char buf[2] = {0xd0, TAKE8_64(d)}; \ + msgpack_pack_append_buffer(x, buf, 2); \ + } \ + } \ + } else if(d < (1<<7)) { \ + /* fixnum */ \ + msgpack_pack_append_buffer(x, &TAKE8_64(d), 1); \ + } else { \ + if(d < (1LL<<16)) { \ + if(d < (1<<8)) { \ + /* unsigned 8 */ \ + unsigned char buf[2] = {0xcc, TAKE8_64(d)}; \ + msgpack_pack_append_buffer(x, buf, 2); \ + } else { \ + /* unsigned 16 */ \ + unsigned char buf[3]; \ + buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ + msgpack_pack_append_buffer(x, buf, 3); \ + } \ + } else { \ + if(d < (1LL<<32)) { \ + /* unsigned 32 */ \ + unsigned char buf[5]; \ + buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \ + msgpack_pack_append_buffer(x, buf, 5); \ + } else { \ + /* unsigned 64 */ \ + unsigned char buf[9]; \ + buf[0] = 0xcf; _msgpack_store64(&buf[1], d); \ + msgpack_pack_append_buffer(x, buf, 9); \ + } \ + } \ + } \ +} while(0) + + +#ifdef msgpack_pack_inline_func_fixint + +msgpack_pack_inline_func_fixint(_uint8)(msgpack_pack_user x, uint8_t d) +{ + unsigned char buf[2] = {0xcc, TAKE8_8(d)}; + msgpack_pack_append_buffer(x, buf, 2); +} + +msgpack_pack_inline_func_fixint(_uint16)(msgpack_pack_user x, uint16_t d) +{ + unsigned char buf[3]; + buf[0] = 0xcd; _msgpack_store16(&buf[1], d); + msgpack_pack_append_buffer(x, buf, 3); +} + +msgpack_pack_inline_func_fixint(_uint32)(msgpack_pack_user x, uint32_t d) +{ + unsigned char buf[5]; + buf[0] = 0xce; _msgpack_store32(&buf[1], d); + msgpack_pack_append_buffer(x, buf, 5); +} + +msgpack_pack_inline_func_fixint(_uint64)(msgpack_pack_user x, uint64_t d) +{ + unsigned char buf[9]; + buf[0] = 0xcf; _msgpack_store64(&buf[1], d); + msgpack_pack_append_buffer(x, buf, 9); +} + +msgpack_pack_inline_func_fixint(_int8)(msgpack_pack_user x, int8_t d) +{ + unsigned char buf[2] = {0xd0, TAKE8_8(d)}; + msgpack_pack_append_buffer(x, buf, 2); +} + +msgpack_pack_inline_func_fixint(_int16)(msgpack_pack_user x, int16_t d) +{ + unsigned char buf[3]; + buf[0] = 0xd1; _msgpack_store16(&buf[1], d); + msgpack_pack_append_buffer(x, buf, 3); +} + +msgpack_pack_inline_func_fixint(_int32)(msgpack_pack_user x, int32_t d) +{ + unsigned char buf[5]; + buf[0] = 0xd2; _msgpack_store32(&buf[1], d); + msgpack_pack_append_buffer(x, buf, 5); +} + +msgpack_pack_inline_func_fixint(_int64)(msgpack_pack_user x, int64_t d) +{ + unsigned char buf[9]; + buf[0] = 0xd3; _msgpack_store64(&buf[1], d); + msgpack_pack_append_buffer(x, buf, 9); +} + +#undef msgpack_pack_inline_func_fixint +#endif + + +msgpack_pack_inline_func(_uint8)(msgpack_pack_user x, uint8_t d) +{ + msgpack_pack_real_uint8(x, d); +} + +msgpack_pack_inline_func(_uint16)(msgpack_pack_user x, uint16_t d) +{ + msgpack_pack_real_uint16(x, d); +} + +msgpack_pack_inline_func(_uint32)(msgpack_pack_user x, uint32_t d) +{ + msgpack_pack_real_uint32(x, d); +} + +msgpack_pack_inline_func(_uint64)(msgpack_pack_user x, uint64_t d) +{ + msgpack_pack_real_uint64(x, d); +} + +msgpack_pack_inline_func(_int8)(msgpack_pack_user x, int8_t d) +{ + msgpack_pack_real_int8(x, d); +} + +msgpack_pack_inline_func(_int16)(msgpack_pack_user x, int16_t d) +{ + msgpack_pack_real_int16(x, d); +} + +msgpack_pack_inline_func(_int32)(msgpack_pack_user x, int32_t d) +{ + msgpack_pack_real_int32(x, d); +} + +msgpack_pack_inline_func(_int64)(msgpack_pack_user x, int64_t d) +{ + msgpack_pack_real_int64(x, d); +} + +msgpack_pack_inline_func(_char)(msgpack_pack_user x, char d) +{ +#if defined(CHAR_MIN) +#if CHAR_MIN < 0 + msgpack_pack_real_int8(x, d); +#else + msgpack_pack_real_uint8(x, d); +#endif +#else +#error CHAR_MIN is not defined +#endif +} + +msgpack_pack_inline_func(_signed_char)(msgpack_pack_user x, signed char d) +{ + msgpack_pack_real_int8(x, d); +} + +msgpack_pack_inline_func(_unsigned_char)(msgpack_pack_user x, unsigned char d) +{ + msgpack_pack_real_uint8(x, d); +} + +#ifdef msgpack_pack_inline_func_cint + +msgpack_pack_inline_func_cint(_short)(msgpack_pack_user x, short d) +{ +#if defined(SIZEOF_SHORT) +#if SIZEOF_SHORT == 2 + msgpack_pack_real_int16(x, d); +#elif SIZEOF_SHORT == 4 + msgpack_pack_real_int32(x, d); +#else + msgpack_pack_real_int64(x, d); +#endif + +#elif defined(SHRT_MAX) +#if SHRT_MAX == 0x7fff + msgpack_pack_real_int16(x, d); +#elif SHRT_MAX == 0x7fffffff + msgpack_pack_real_int32(x, d); +#else + msgpack_pack_real_int64(x, d); +#endif + +#else +if(sizeof(short) == 2) { + msgpack_pack_real_int16(x, d); +} else if(sizeof(short) == 4) { + msgpack_pack_real_int32(x, d); +} else { + msgpack_pack_real_int64(x, d); +} +#endif +} + +msgpack_pack_inline_func_cint(_int)(msgpack_pack_user x, int d) +{ +#if defined(SIZEOF_INT) +#if SIZEOF_INT == 2 + msgpack_pack_real_int16(x, d); +#elif SIZEOF_INT == 4 + msgpack_pack_real_int32(x, d); +#else + msgpack_pack_real_int64(x, d); +#endif + +#elif defined(INT_MAX) +#if INT_MAX == 0x7fff + msgpack_pack_real_int16(x, d); +#elif INT_MAX == 0x7fffffff + msgpack_pack_real_int32(x, d); +#else + msgpack_pack_real_int64(x, d); +#endif + +#else +if(sizeof(int) == 2) { + msgpack_pack_real_int16(x, d); +} else if(sizeof(int) == 4) { + msgpack_pack_real_int32(x, d); +} else { + msgpack_pack_real_int64(x, d); +} +#endif +} + +msgpack_pack_inline_func_cint(_long)(msgpack_pack_user x, long d) +{ +#if defined(SIZEOF_LONG) +#if SIZEOF_LONG == 2 + msgpack_pack_real_int16(x, d); +#elif SIZEOF_LONG == 4 + msgpack_pack_real_int32(x, d); +#else + msgpack_pack_real_int64(x, d); +#endif + +#elif defined(LONG_MAX) +#if LONG_MAX == 0x7fffL + msgpack_pack_real_int16(x, d); +#elif LONG_MAX == 0x7fffffffL + msgpack_pack_real_int32(x, d); +#else + msgpack_pack_real_int64(x, d); +#endif + +#else +if(sizeof(long) == 2) { + msgpack_pack_real_int16(x, d); +} else if(sizeof(long) == 4) { + msgpack_pack_real_int32(x, d); +} else { + msgpack_pack_real_int64(x, d); +} +#endif +} + +msgpack_pack_inline_func_cint(_long_long)(msgpack_pack_user x, long long d) +{ +#if defined(SIZEOF_LONG_LONG) +#if SIZEOF_LONG_LONG == 2 + msgpack_pack_real_int16(x, d); +#elif SIZEOF_LONG_LONG == 4 + msgpack_pack_real_int32(x, d); +#else + msgpack_pack_real_int64(x, d); +#endif + +#elif defined(LLONG_MAX) +#if LLONG_MAX == 0x7fffL + msgpack_pack_real_int16(x, d); +#elif LLONG_MAX == 0x7fffffffL + msgpack_pack_real_int32(x, d); +#else + msgpack_pack_real_int64(x, d); +#endif + +#else +if(sizeof(long long) == 2) { + msgpack_pack_real_int16(x, d); +} else if(sizeof(long long) == 4) { + msgpack_pack_real_int32(x, d); +} else { + msgpack_pack_real_int64(x, d); +} +#endif +} + +msgpack_pack_inline_func_cint(_unsigned_short)(msgpack_pack_user x, unsigned short d) +{ +#if defined(SIZEOF_SHORT) +#if SIZEOF_SHORT == 2 + msgpack_pack_real_uint16(x, d); +#elif SIZEOF_SHORT == 4 + msgpack_pack_real_uint32(x, d); +#else + msgpack_pack_real_uint64(x, d); +#endif + +#elif defined(USHRT_MAX) +#if USHRT_MAX == 0xffffU + msgpack_pack_real_uint16(x, d); +#elif USHRT_MAX == 0xffffffffU + msgpack_pack_real_uint32(x, d); +#else + msgpack_pack_real_uint64(x, d); +#endif + +#else +if(sizeof(unsigned short) == 2) { + msgpack_pack_real_uint16(x, d); +} else if(sizeof(unsigned short) == 4) { + msgpack_pack_real_uint32(x, d); +} else { + msgpack_pack_real_uint64(x, d); +} +#endif +} + +msgpack_pack_inline_func_cint(_unsigned_int)(msgpack_pack_user x, unsigned int d) +{ +#if defined(SIZEOF_INT) +#if SIZEOF_INT == 2 + msgpack_pack_real_uint16(x, d); +#elif SIZEOF_INT == 4 + msgpack_pack_real_uint32(x, d); +#else + msgpack_pack_real_uint64(x, d); +#endif + +#elif defined(UINT_MAX) +#if UINT_MAX == 0xffffU + msgpack_pack_real_uint16(x, d); +#elif UINT_MAX == 0xffffffffU + msgpack_pack_real_uint32(x, d); +#else + msgpack_pack_real_uint64(x, d); +#endif + +#else +if(sizeof(unsigned int) == 2) { + msgpack_pack_real_uint16(x, d); +} else if(sizeof(unsigned int) == 4) { + msgpack_pack_real_uint32(x, d); +} else { + msgpack_pack_real_uint64(x, d); +} +#endif +} + +msgpack_pack_inline_func_cint(_unsigned_long)(msgpack_pack_user x, unsigned long d) +{ +#if defined(SIZEOF_LONG) +#if SIZEOF_LONG == 2 + msgpack_pack_real_uint16(x, d); +#elif SIZEOF_LONG == 4 + msgpack_pack_real_uint32(x, d); +#else + msgpack_pack_real_uint64(x, d); +#endif + +#elif defined(ULONG_MAX) +#if ULONG_MAX == 0xffffUL + msgpack_pack_real_uint16(x, d); +#elif ULONG_MAX == 0xffffffffUL + msgpack_pack_real_uint32(x, d); +#else + msgpack_pack_real_uint64(x, d); +#endif + +#else +if(sizeof(unsigned long) == 2) { + msgpack_pack_real_uint16(x, d); +} else if(sizeof(unsigned long) == 4) { + msgpack_pack_real_uint32(x, d); +} else { + msgpack_pack_real_uint64(x, d); +} +#endif +} + +msgpack_pack_inline_func_cint(_unsigned_long_long)(msgpack_pack_user x, unsigned long long d) +{ +#if defined(SIZEOF_LONG_LONG) +#if SIZEOF_LONG_LONG == 2 + msgpack_pack_real_uint16(x, d); +#elif SIZEOF_LONG_LONG == 4 + msgpack_pack_real_uint32(x, d); +#else + msgpack_pack_real_uint64(x, d); +#endif + +#elif defined(ULLONG_MAX) +#if ULLONG_MAX == 0xffffUL + msgpack_pack_real_uint16(x, d); +#elif ULLONG_MAX == 0xffffffffUL + msgpack_pack_real_uint32(x, d); +#else + msgpack_pack_real_uint64(x, d); +#endif + +#else +if(sizeof(unsigned long long) == 2) { + msgpack_pack_real_uint16(x, d); +} else if(sizeof(unsigned long long) == 4) { + msgpack_pack_real_uint32(x, d); +} else { + msgpack_pack_real_uint64(x, d); +} +#endif +} + +#undef msgpack_pack_inline_func_cint +#endif + + + +/* + * Float + */ + +msgpack_pack_inline_func(_float)(msgpack_pack_user x, float d) +{ + unsigned char buf[5]; + union { float f; uint32_t i; } mem; + mem.f = d; + buf[0] = 0xca; _msgpack_store32(&buf[1], mem.i); + msgpack_pack_append_buffer(x, buf, 5); +} + +msgpack_pack_inline_func(_double)(msgpack_pack_user x, double d) +{ + unsigned char buf[9]; + union { double f; uint64_t i; } mem; + mem.f = d; + buf[0] = 0xcb; +#if defined(__arm__) && !(__ARM_EABI__) // arm-oabi + // https://github.com/msgpack/msgpack-perl/pull/1 + mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); +#endif + _msgpack_store64(&buf[1], mem.i); + msgpack_pack_append_buffer(x, buf, 9); +} + + +/* + * Nil + */ + +msgpack_pack_inline_func(_nil)(msgpack_pack_user x) +{ + static const unsigned char d = 0xc0; + msgpack_pack_append_buffer(x, &d, 1); +} + + +/* + * Boolean + */ + +msgpack_pack_inline_func(_true)(msgpack_pack_user x) +{ + static const unsigned char d = 0xc3; + msgpack_pack_append_buffer(x, &d, 1); +} + +msgpack_pack_inline_func(_false)(msgpack_pack_user x) +{ + static const unsigned char d = 0xc2; + msgpack_pack_append_buffer(x, &d, 1); +} + + +/* + * Array + */ + +msgpack_pack_inline_func(_array)(msgpack_pack_user x, size_t n) +{ + if(n < 16) { + unsigned char d = 0x90 | (uint8_t)n; + msgpack_pack_append_buffer(x, &d, 1); + } else if(n < 65536) { + unsigned char buf[3]; + buf[0] = 0xdc; _msgpack_store16(&buf[1], (uint16_t)n); + msgpack_pack_append_buffer(x, buf, 3); + } else { + unsigned char buf[5]; + buf[0] = 0xdd; _msgpack_store32(&buf[1], (uint32_t)n); + msgpack_pack_append_buffer(x, buf, 5); + } +} + + +/* + * Map + */ + +msgpack_pack_inline_func(_map)(msgpack_pack_user x, size_t n) +{ + if(n < 16) { + unsigned char d = 0x80 | (uint8_t)n; + msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); + } else if(n < 65536) { + unsigned char buf[3]; + buf[0] = 0xde; _msgpack_store16(&buf[1], (uint16_t)n); + msgpack_pack_append_buffer(x, buf, 3); + } else { + unsigned char buf[5]; + buf[0] = 0xdf; _msgpack_store32(&buf[1], (uint32_t)n); + msgpack_pack_append_buffer(x, buf, 5); + } +} + + +/* + * Str + */ + +msgpack_pack_inline_func(_str)(msgpack_pack_user x, size_t l) +{ + if(l < 32) { + unsigned char d = 0xa0 | (uint8_t)l; + msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); + } else if(l < 256) { + unsigned char buf[2]; + buf[0] = 0xd9; buf[1] = (uint8_t)l; + msgpack_pack_append_buffer(x, buf, 2); + } else if(l < 65536) { + unsigned char buf[3]; + buf[0] = 0xda; _msgpack_store16(&buf[1], (uint16_t)l); + msgpack_pack_append_buffer(x, buf, 3); + } else { + unsigned char buf[5]; + buf[0] = 0xdb; _msgpack_store32(&buf[1], (uint32_t)l); + msgpack_pack_append_buffer(x, buf, 5); + } +} + +msgpack_pack_inline_func(_str_body)(msgpack_pack_user x, const void* b, size_t l) +{ + msgpack_pack_append_buffer(x, (const unsigned char*)b, l); +} + +/* + * Bin + */ + +msgpack_pack_inline_func(_bin)(msgpack_pack_user x, size_t l) +{ + if(l < 256) { + unsigned char buf[2]; + buf[0] = 0xc4; buf[1] = (uint8_t)l; + msgpack_pack_append_buffer(x, buf, 2); + } else if(l < 65536) { + unsigned char buf[3]; + buf[0] = 0xc5; _msgpack_store16(&buf[1], (uint16_t)l); + msgpack_pack_append_buffer(x, buf, 3); + } else { + unsigned char buf[5]; + buf[0] = 0xc6; _msgpack_store32(&buf[1], (uint32_t)l); + msgpack_pack_append_buffer(x, buf, 5); + } +} + +msgpack_pack_inline_func(_bin_body)(msgpack_pack_user x, const void* b, size_t l) +{ + msgpack_pack_append_buffer(x, (const unsigned char*)b, l); +} + +/* + * Ext + */ + +msgpack_pack_inline_func(_ext)(msgpack_pack_user x, size_t l, int8_t type) +{ + switch(l) { + case 1: { + char buf[2]; + buf[0] = 0xd4; + buf[1] = type; + msgpack_pack_append_buffer(x, buf, 2); + } break; + case 2: { + char buf[2]; + buf[0] = 0xd5; + buf[1] = type; + msgpack_pack_append_buffer(x, buf, 2); + } break; + case 4: { + char buf[2]; + buf[0] = 0xd6; + buf[1] = type; + msgpack_pack_append_buffer(x, buf, 2); + } break; + case 8: { + char buf[2]; + buf[0] = 0xd7; + buf[1] = type; + msgpack_pack_append_buffer(x, buf, 2); + } break; + case 16: { + char buf[2]; + buf[0] = 0xd8; + buf[1] = type; + msgpack_pack_append_buffer(x, buf, 2); + } break; + default: + if(l < 256) { + char buf[3]; + buf[0] = 0xc7; + buf[1] = l; + buf[2] = type; + msgpack_pack_append_buffer(x, buf, 3); + } else if(l < 65536) { + char buf[4]; + buf[0] = 0xc8; + _msgpack_store16(&buf[1], l); + buf[3] = type; + msgpack_pack_append_buffer(x, buf, 4); + } else { + char buf[6]; + buf[0] = 0xc9; + _msgpack_store32(&buf[1], l); + buf[5] = type; + msgpack_pack_append_buffer(x, buf, 6); + } + break; + } +} + +msgpack_pack_inline_func(_ext_body)(msgpack_pack_user x, const void* b, size_t l) +{ + msgpack_pack_append_buffer(x, (const unsigned char*)b, l); +} + +#undef msgpack_pack_inline_func +#undef msgpack_pack_user +#undef msgpack_pack_append_buffer + +#undef TAKE8_8 +#undef TAKE8_16 +#undef TAKE8_32 +#undef TAKE8_64 + +#undef msgpack_pack_real_uint8 +#undef msgpack_pack_real_uint16 +#undef msgpack_pack_real_uint32 +#undef msgpack_pack_real_uint64 +#undef msgpack_pack_real_int8 +#undef msgpack_pack_real_int16 +#undef msgpack_pack_real_int32 +#undef msgpack_pack_real_int64 + diff --git a/src/msgpack/sbuffer.h b/include/msgpack/sbuffer.h similarity index 62% rename from src/msgpack/sbuffer.h rename to include/msgpack/sbuffer.h index 4ffb0b7c..edfb246f 100644 --- a/src/msgpack/sbuffer.h +++ b/include/msgpack/sbuffer.h @@ -15,8 +15,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#ifndef MSGPACK_SBUFFER_H__ -#define MSGPACK_SBUFFER_H__ +#ifndef MSGPACK_SBUFFER_H +#define MSGPACK_SBUFFER_H #include #include @@ -33,31 +33,31 @@ extern "C" { */ typedef struct msgpack_sbuffer { - size_t size; - char* data; - size_t alloc; + size_t size; + char* data; + size_t alloc; } msgpack_sbuffer; static inline void msgpack_sbuffer_init(msgpack_sbuffer* sbuf) { - memset(sbuf, 0, sizeof(msgpack_sbuffer)); + memset(sbuf, 0, sizeof(msgpack_sbuffer)); } static inline void msgpack_sbuffer_destroy(msgpack_sbuffer* sbuf) { - free(sbuf->data); + free(sbuf->data); } static inline msgpack_sbuffer* msgpack_sbuffer_new(void) { - return (msgpack_sbuffer*)calloc(1, sizeof(msgpack_sbuffer)); + return (msgpack_sbuffer*)calloc(1, sizeof(msgpack_sbuffer)); } static inline void msgpack_sbuffer_free(msgpack_sbuffer* sbuf) { - if(sbuf == NULL) { return; } - msgpack_sbuffer_destroy(sbuf); - free(sbuf); + if(sbuf == NULL) { return; } + msgpack_sbuffer_destroy(sbuf); + free(sbuf); } #ifndef MSGPACK_SBUFFER_INIT_SIZE @@ -66,39 +66,39 @@ static inline void msgpack_sbuffer_free(msgpack_sbuffer* sbuf) static inline int msgpack_sbuffer_write(void* data, const char* buf, size_t len) { - msgpack_sbuffer* sbuf = (msgpack_sbuffer*)data; + msgpack_sbuffer* sbuf = (msgpack_sbuffer*)data; - if(sbuf->alloc - sbuf->size < len) { - void* tmp; - size_t nsize = (sbuf->alloc) ? - sbuf->alloc * 2 : MSGPACK_SBUFFER_INIT_SIZE; + if(sbuf->alloc - sbuf->size < len) { + void* tmp; + size_t nsize = (sbuf->alloc) ? + sbuf->alloc * 2 : MSGPACK_SBUFFER_INIT_SIZE; - while(nsize < sbuf->size + len) { nsize *= 2; } + while(nsize < sbuf->size + len) { nsize *= 2; } - tmp = realloc(sbuf->data, nsize); - if(!tmp) { return -1; } + tmp = realloc(sbuf->data, nsize); + if(!tmp) { return -1; } - sbuf->data = (char*)tmp; - sbuf->alloc = nsize; - } + sbuf->data = (char*)tmp; + sbuf->alloc = nsize; + } - memcpy(sbuf->data + sbuf->size, buf, len); - sbuf->size += len; - return 0; + memcpy(sbuf->data + sbuf->size, buf, len); + sbuf->size += len; + return 0; } static inline char* msgpack_sbuffer_release(msgpack_sbuffer* sbuf) { - char* tmp = sbuf->data; - sbuf->size = 0; - sbuf->data = NULL; - sbuf->alloc = 0; - return tmp; + char* tmp = sbuf->data; + sbuf->size = 0; + sbuf->data = NULL; + sbuf->alloc = 0; + return tmp; } static inline void msgpack_sbuffer_clear(msgpack_sbuffer* sbuf) { - sbuf->size = 0; + sbuf->size = 0; } /** @} */ diff --git a/include/msgpack/sbuffer.hpp b/include/msgpack/sbuffer.hpp new file mode 100644 index 00000000..531f9f16 --- /dev/null +++ b/include/msgpack/sbuffer.hpp @@ -0,0 +1,120 @@ +// +// MessagePack for C++ simple buffer implementation +// +// 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_SBUFFER_HPP +#define MSGPACK_SBUFFER_HPP + +#include "msgpack/versioning.hpp" + +#include + +#ifndef MSGPACK_SBUFFER_INIT_SIZE +#define MSGPACK_SBUFFER_INIT_SIZE 8192 +#endif + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +class sbuffer { +public: + sbuffer(size_t initsz = MSGPACK_SBUFFER_INIT_SIZE):m_size(0), m_alloc(initsz) + { + if(initsz == 0) { + m_data = nullptr; + } else { + m_data = (char*)::malloc(initsz); + if(!m_data) { + throw std::bad_alloc(); + } + } + } + + ~sbuffer() + { + ::free(m_data); + } + +public: + void write(const char* buf, size_t len) + { + if(m_alloc - m_size < len) { + expand_buffer(len); + } + ::memcpy(m_data + m_size, buf, len); + m_size += len; + } + + char* data() + { + return m_data; + } + + const char* data() const + { + return m_data; + } + + size_t size() const + { + return m_size; + } + + char* release() + { + char* tmp = m_data; + m_size = 0; + m_data = nullptr; + m_alloc = 0; + return tmp; + } + + void clear() + { + m_size = 0; + } + +private: + void expand_buffer(size_t len) + { + size_t nsize = (m_alloc > 0) ? + m_alloc * 2 : MSGPACK_SBUFFER_INIT_SIZE; + + while(nsize < m_size + len) { nsize *= 2; } + + void* tmp = ::realloc(m_data, nsize); + if(!tmp) { + throw std::bad_alloc(); + } + + m_data = static_cast(tmp); + m_alloc = nsize; + } + +private: + sbuffer(const sbuffer&); +private: + size_t m_size; + char* m_data; + size_t m_alloc; +}; + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif /* msgpack/sbuffer.hpp */ diff --git a/src/msgpack/sysdep.h b/include/msgpack/sysdep.h similarity index 72% rename from src/msgpack/sysdep.h rename to include/msgpack/sysdep.h index 8f082160..5b8a739e 100644 --- a/src/msgpack/sysdep.h +++ b/include/msgpack/sysdep.h @@ -15,8 +15,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#ifndef MSGPACK_SYSDEP_H__ -#define MSGPACK_SYSDEP_H__ +#ifndef MSGPACK_SYSDEP_H +#define MSGPACK_SYSDEP_H #include #include @@ -42,7 +42,13 @@ typedef long _msgpack_atomic_counter_t; #define _msgpack_sync_decr_and_fetch(ptr) InterlockedDecrement(ptr) #define _msgpack_sync_incr_and_fetch(ptr) InterlockedIncrement(ptr) #elif defined(__GNUC__) && ((__GNUC__*10 + __GNUC_MINOR__) < 41) + +#if defined(__cplusplus) +#define _msgpack_atomic_counter_header "gcc_atomic.hpp" +#else #define _msgpack_atomic_counter_header "gcc_atomic.h" +#endif + #else typedef unsigned int _msgpack_atomic_counter_t; #define _msgpack_sync_decr_and_fetch(ptr) __sync_sub_and_fetch(ptr, 1) @@ -62,7 +68,12 @@ typedef unsigned int _msgpack_atomic_counter_t; #endif #else + #include /* __BYTE_ORDER */ +# if !defined(__APPLE__) +# include +# endif + #endif #if !defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__) @@ -126,53 +137,27 @@ typedef unsigned int _msgpack_atomic_counter_t; ((((uint64_t)x) >> 56) ) ) #endif -#define _msgpack_load16(cast, from) ((cast)( \ - (((uint16_t)((uint8_t*)(from))[0]) << 8) | \ - (((uint16_t)((uint8_t*)(from))[1]) ) )) - -#define _msgpack_load32(cast, from) ((cast)( \ - (((uint32_t)((uint8_t*)(from))[0]) << 24) | \ - (((uint32_t)((uint8_t*)(from))[1]) << 16) | \ - (((uint32_t)((uint8_t*)(from))[2]) << 8) | \ - (((uint32_t)((uint8_t*)(from))[3]) ) )) - -#define _msgpack_load64(cast, from) ((cast)( \ - (((uint64_t)((uint8_t*)(from))[0]) << 56) | \ - (((uint64_t)((uint8_t*)(from))[1]) << 48) | \ - (((uint64_t)((uint8_t*)(from))[2]) << 40) | \ - (((uint64_t)((uint8_t*)(from))[3]) << 32) | \ - (((uint64_t)((uint8_t*)(from))[4]) << 24) | \ - (((uint64_t)((uint8_t*)(from))[5]) << 16) | \ - (((uint64_t)((uint8_t*)(from))[6]) << 8) | \ - (((uint64_t)((uint8_t*)(from))[7]) ) )) - -#else +#else /* __LITTLE_ENDIAN__ */ #define _msgpack_be16(x) (x) #define _msgpack_be32(x) (x) #define _msgpack_be64(x) (x) -#define _msgpack_load16(cast, from) ((cast)( \ - (((uint16_t)((uint8_t*)from)[0]) << 8) | \ - (((uint16_t)((uint8_t*)from)[1]) ) )) - -#define _msgpack_load32(cast, from) ((cast)( \ - (((uint32_t)((uint8_t*)from)[0]) << 24) | \ - (((uint32_t)((uint8_t*)from)[1]) << 16) | \ - (((uint32_t)((uint8_t*)from)[2]) << 8) | \ - (((uint32_t)((uint8_t*)from)[3]) ) )) - -#define _msgpack_load64(cast, from) ((cast)( \ - (((uint64_t)((uint8_t*)from)[0]) << 56) | \ - (((uint64_t)((uint8_t*)from)[1]) << 48) | \ - (((uint64_t)((uint8_t*)from)[2]) << 40) | \ - (((uint64_t)((uint8_t*)from)[3]) << 32) | \ - (((uint64_t)((uint8_t*)from)[4]) << 24) | \ - (((uint64_t)((uint8_t*)from)[5]) << 16) | \ - (((uint64_t)((uint8_t*)from)[6]) << 8) | \ - (((uint64_t)((uint8_t*)from)[7]) ) )) #endif +#define _msgpack_load16(cast, from, to) do { \ + memcpy((cast*)(to), (from), sizeof(cast)); \ + *(to) = _msgpack_be16(*(to)); \ + } while (0); + +#define _msgpack_load32(cast, from, to) do { \ + memcpy((cast*)(to), (from), sizeof(cast)); \ + *(to) = _msgpack_be32(*(to)); \ + } while (0); +#define _msgpack_load64(cast, from, to) do { \ + memcpy((cast*)(to), (from), sizeof(cast)); \ + *(to) = _msgpack_be64(*(to)); \ + } while (0); #define _msgpack_store16(to, num) \ do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0) @@ -205,4 +190,3 @@ typedef unsigned int _msgpack_atomic_counter_t; #endif #endif /* msgpack/sysdep.h */ - diff --git a/include/msgpack/type.hpp b/include/msgpack/type.hpp new file mode 100644 index 00000000..ab10d9ed --- /dev/null +++ b/include/msgpack/type.hpp @@ -0,0 +1,29 @@ +#include "cpp_config.hpp" +#include "adaptor/bool.hpp" +#include "adaptor/char_ptr.hpp" +#include "adaptor/deque.hpp" +#include "adaptor/fixint.hpp" +#include "adaptor/float.hpp" +#include "adaptor/int.hpp" +#include "adaptor/list.hpp" +#include "adaptor/map.hpp" +#include "adaptor/nil.hpp" +#include "adaptor/pair.hpp" +#include "adaptor/raw.hpp" +#include "adaptor/set.hpp" +#include "adaptor/string.hpp" +#include "adaptor/vector.hpp" +#include "adaptor/vector_char.hpp" +#include "adaptor/msgpack_tuple.hpp" +#include "adaptor/define.hpp" +#include "adaptor/tr1/unordered_map.hpp" +#include "adaptor/tr1/unordered_set.hpp" + +#if !defined(MSGPACK_USE_CPP03) + +#include "adaptor/cpp11/array.hpp" +#include "adaptor/cpp11/array_char.hpp" +#include "adaptor/cpp11/forward_list.hpp" +#include "adaptor/cpp11/tuple.hpp" + +#endif // !defined(MSGPACK_USE_CPP03) diff --git a/src/msgpack/unpack.h b/include/msgpack/unpack.h similarity index 81% rename from src/msgpack/unpack.h rename to include/msgpack/unpack.h index c3380f81..66b0b0f6 100644 --- a/src/msgpack/unpack.h +++ b/include/msgpack/unpack.h @@ -15,8 +15,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#ifndef MSGPACK_UNPACKER_H__ -#define MSGPACK_UNPACKER_H__ +#ifndef MSGPACK_UNPACKER_H +#define MSGPACK_UNPACKER_H #include "zone.h" #include "object.h" @@ -34,12 +34,22 @@ extern "C" { */ typedef struct msgpack_unpacked { - msgpack_zone* zone; - msgpack_object data; + msgpack_zone* zone; + msgpack_object data; } msgpack_unpacked; -bool msgpack_unpack_next(msgpack_unpacked* result, - const char* data, size_t len, size_t* off); +typedef enum { + MSGPACK_UNPACK_SUCCESS = 2, + MSGPACK_UNPACK_EXTRA_BYTES = 1, + MSGPACK_UNPACK_CONTINUE = 0, + MSGPACK_UNPACK_PARSE_ERROR = -1, + MSGPACK_UNPACK_NOMEM_ERROR = -2 +} msgpack_unpack_return; + + +msgpack_unpack_return +msgpack_unpack_next(msgpack_unpacked* result, + const char* data, size_t len, size_t* off); /** @} */ @@ -51,14 +61,14 @@ bool msgpack_unpack_next(msgpack_unpacked* result, */ typedef struct msgpack_unpacker { - char* buffer; - size_t used; - size_t free; - size_t off; - size_t parsed; - msgpack_zone* z; - size_t initial_buffer_size; - void* ctx; + char* buffer; + size_t used; + size_t free; + size_t off; + size_t parsed; + msgpack_zone* z; + size_t initial_buffer_size; + void* ctx; } msgpack_unpacker; @@ -136,7 +146,7 @@ static inline void msgpack_unpacker_buffer_consumed(msgpack_unpacker* mpac, si * Returns true if it successes. Otherwise false is returned. * @param pac pointer to an initialized msgpack_unpacked object. */ -bool msgpack_unpacker_next(msgpack_unpacker* mpac, msgpack_unpacked* pac); +msgpack_unpack_return msgpack_unpacker_next(msgpack_unpacker* mpac, msgpack_unpacked* pac); /** * Initializes a msgpack_unpacked object. @@ -174,18 +184,12 @@ static inline size_t msgpack_unpacker_message_size(const msgpack_unpacker* mpac) /** @} */ -// obsolete -typedef enum { - MSGPACK_UNPACK_SUCCESS = 2, - MSGPACK_UNPACK_EXTRA_BYTES = 1, - MSGPACK_UNPACK_CONTINUE = 0, - MSGPACK_UNPACK_PARSE_ERROR = -1, -} msgpack_unpack_return; - // obsolete msgpack_unpack_return msgpack_unpack(const char* data, size_t len, size_t* off, - msgpack_zone* result_zone, msgpack_object* result); + msgpack_zone* result_zone, msgpack_object* result); + + static inline size_t msgpack_unpacker_parsed_size(const msgpack_unpacker* mpac); @@ -196,59 +200,59 @@ bool msgpack_unpacker_expand_buffer(msgpack_unpacker* mpac, size_t size); static inline bool msgpack_unpacker_reserve_buffer(msgpack_unpacker* mpac, size_t size) { - if(mpac->free >= size) { return true; } - return msgpack_unpacker_expand_buffer(mpac, size); + if(mpac->free >= size) { return true; } + return msgpack_unpacker_expand_buffer(mpac, size); } static inline char* msgpack_unpacker_buffer(msgpack_unpacker* mpac) { - return mpac->buffer + mpac->used; + return mpac->buffer + mpac->used; } static inline size_t msgpack_unpacker_buffer_capacity(const msgpack_unpacker* mpac) { - return mpac->free; + return mpac->free; } static inline void msgpack_unpacker_buffer_consumed(msgpack_unpacker* mpac, size_t size) { - mpac->used += size; - mpac->free -= size; + mpac->used += size; + mpac->free -= size; } static inline size_t msgpack_unpacker_message_size(const msgpack_unpacker* mpac) { - return mpac->parsed - mpac->off + mpac->used; + return mpac->parsed - mpac->off + mpac->used; } static inline size_t msgpack_unpacker_parsed_size(const msgpack_unpacker* mpac) { - return mpac->parsed; + return mpac->parsed; } static inline void msgpack_unpacked_init(msgpack_unpacked* result) { - memset(result, 0, sizeof(msgpack_unpacked)); + memset(result, 0, sizeof(msgpack_unpacked)); } static inline void msgpack_unpacked_destroy(msgpack_unpacked* result) { - if(result->zone != NULL) { - msgpack_zone_free(result->zone); - result->zone = NULL; - memset(&result->data, 0, sizeof(msgpack_object)); - } + if(result->zone != NULL) { + msgpack_zone_free(result->zone); + result->zone = NULL; + memset(&result->data, 0, sizeof(msgpack_object)); + } } static inline msgpack_zone* msgpack_unpacked_release_zone(msgpack_unpacked* result) { - if(result->zone != NULL) { - msgpack_zone* z = result->zone; - result->zone = NULL; - return z; - } - return NULL; + if(result->zone != NULL) { + msgpack_zone* z = result->zone; + result->zone = NULL; + return z; + } + return NULL; } diff --git a/include/msgpack/unpack.hpp b/include/msgpack/unpack.hpp new file mode 100644 index 00000000..28f1aea7 --- /dev/null +++ b/include/msgpack/unpack.hpp @@ -0,0 +1,1468 @@ +// +// MessagePack for C++ deserializing 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_UNPACK_HPP +#define MSGPACK_UNPACK_HPP + +#include "msgpack/versioning.hpp" +#include "object.hpp" +#include "zone.hpp" +#include "unpack_define.h" +#include "cpp_config.hpp" +#include "sysdep.h" + +#include +#include + + + +#define COUNTER_SIZE (sizeof(_msgpack_atomic_counter_t)) + +#ifndef MSGPACK_UNPACKER_INIT_BUFFER_SIZE +#define MSGPACK_UNPACKER_INIT_BUFFER_SIZE (64*1024) +#endif + +#ifndef MSGPACK_UNPACKER_RESERVE_SIZE +#define MSGPACK_UNPACKER_RESERVE_SIZE (32*1024) +#endif + + +// backward compatibility +#ifndef MSGPACK_UNPACKER_DEFAULT_INITIAL_BUFFER_SIZE +#define MSGPACK_UNPACKER_DEFAULT_INITIAL_BUFFER_SIZE MSGPACK_UNPACKER_INIT_BUFFER_SIZE +#endif + + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +typedef bool (*unpack_reference_func)(type::object_type, std::size_t, void*); + +namespace detail { + +class unpack_user { +public: + unpack_user(unpack_reference_func f = nullptr, void* user_data = nullptr) + :m_func(f), m_user_data(user_data) {} + msgpack::zone const& zone() const { return *m_zone; } + msgpack::zone& zone() { return *m_zone; } + void set_zone(msgpack::zone& zone) { m_zone = &zone; } + bool referenced() const { return m_referenced; } + void set_referenced(bool referenced) { m_referenced = referenced; } + unpack_reference_func reference_func() const { return m_func; } + void* user_data() const { return m_user_data; } +private: + msgpack::zone* m_zone; + bool m_referenced; + unpack_reference_func m_func; + void* m_user_data; +}; + +inline void unpack_uint8(uint8_t d, object& o) +{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } + +inline void unpack_uint16(uint16_t d, object& o) +{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } + +inline void unpack_uint32(uint32_t d, object& o) +{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } + +inline void unpack_uint64(uint64_t d, object& o) +{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } + +inline void unpack_int8(int8_t d, object& o) +{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } + else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } } + +inline void unpack_int16(int16_t d, object& o) +{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } + else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } } + +inline void unpack_int32(int32_t d, object& o) +{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } + else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } } + +inline void unpack_int64(int64_t d, object& o) +{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } + else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } } + +inline void unpack_float(float d, object& o) +{ o.type = type::DOUBLE; o.via.dec = d; } + +inline void unpack_double(double d, object& o) +{ o.type = type::DOUBLE; o.via.dec = d; } + +inline void unpack_nil(object& o) +{ o.type = type::NIL; } + +inline void unpack_true(object& o) +{ o.type = type::BOOLEAN; o.via.boolean = true; } + +inline void unpack_false(object& o) +{ o.type = type::BOOLEAN; o.via.boolean = false; } + +struct unpack_array { + void operator()(unpack_user& u, uint32_t n, object& o) const { + o.type = type::ARRAY; + o.via.array.size = 0; + o.via.array.ptr = static_cast(u.zone().allocate_align(n*sizeof(object))); + } +}; + +inline void unpack_array_item(object& c, object const& o) +{ +#if defined(__GNUC__) && !defined(__clang__) + std::memcpy(&c.via.array.ptr[c.via.array.size++], &o, sizeof(object)); +#else /* __GNUC__ && !__clang__ */ + c.via.array.ptr[c.via.array.size++] = o; +#endif /* __GNUC__ && !__clang__ */ +} + +struct unpack_map { + void operator()(unpack_user& u, uint32_t n, object& o) const { + o.type = type::MAP; + o.via.map.size = 0; + o.via.map.ptr = static_cast(u.zone().allocate_align(n*sizeof(object_kv))); + } +}; + +inline void unpack_map_item(object& c, object const& k, object const& v) +{ +#if defined(__GNUC__) && !defined(__clang__) + std::memcpy(&c.via.map.ptr[c.via.map.size].key, &k, sizeof(object)); + std::memcpy(&c.via.map.ptr[c.via.map.size].val, &v, sizeof(object)); +#else /* __GNUC__ && !__clang__ */ + c.via.map.ptr[c.via.map.size].key = k; + c.via.map.ptr[c.via.map.size].val = v; +#endif /* __GNUC__ && !__clang__ */ + ++c.via.map.size; +} + +inline void unpack_str(unpack_user& u, const char* p, uint32_t l, object& o) +{ + o.type = type::STR; + if (u.reference_func() && u.reference_func()(o.type, l, u.user_data())) { + o.via.str.ptr = p; + u.set_referenced(true); + } + else { + char* tmp = static_cast(u.zone().allocate_align(l)); + std::memcpy(tmp, p, l); + o.via.str.ptr = tmp; + } + o.via.str.size = l; +} + +inline void unpack_bin(unpack_user& u, const char* p, uint32_t l, object& o) +{ + o.type = type::BIN; + if (u.reference_func() && u.reference_func()(o.type, l, u.user_data())) { + o.via.bin.ptr = p; + u.set_referenced(true); + } + else { + char* tmp = static_cast(u.zone().allocate_align(l)); + std::memcpy(tmp, p, l); + o.via.bin.ptr = tmp; + } + o.via.bin.size = l; +} + +inline void unpack_ext(unpack_user& u, const char* p, uint32_t l, object& o) +{ + o.type = type::EXT; + if (u.reference_func() && u.reference_func()(o.type, l, u.user_data())) { + o.via.ext.ptr = p; + u.set_referenced(true); + } + else { + char* tmp = static_cast(u.zone().allocate_align(l)); + std::memcpy(tmp, p, l); + o.via.ext.ptr = tmp; + } + o.via.ext.size = l - 1; +} + + +class unpack_stack { +public: + object const& obj() const { return m_obj; } + object& obj() { return m_obj; } + void set_obj(object const& obj) { m_obj = obj; } + std::size_t count() const { return m_count; } + void set_count(std::size_t count) { m_count = count; } + std::size_t decl_count() { return --m_count; } + uint32_t container_type() const { return m_container_type; } + void set_container_type(uint32_t container_type) { m_container_type = container_type; } + object const& map_key() const { return m_map_key; } + void set_map_key(object const& map_key) { m_map_key = map_key; } +private: + object m_obj; + std::size_t m_count; + uint32_t m_container_type; + object m_map_key; +}; + +inline void init_count(void* buffer) +{ + *reinterpret_cast(buffer) = 1; +} + +inline void decl_count(void* buffer) +{ + if(_msgpack_sync_decr_and_fetch(reinterpret_cast(buffer)) == 0) { + free(buffer); + } +} + +inline void incr_count(void* buffer) +{ + _msgpack_sync_incr_and_fetch(reinterpret_cast(buffer)); +} + +inline _msgpack_atomic_counter_t get_count(void* buffer) +{ + return *reinterpret_cast(buffer); +} + +struct fix_tag { + char f1[65]; // FIXME unique size is required. or use is_same meta function. +}; + +template +struct value { + typedef T type; +}; +template <> +struct value { + typedef uint32_t type; +}; + +template +inline void load(uint32_t& dst, const char* n, typename msgpack::enable_if::type* = nullptr) { + dst = static_cast(*reinterpret_cast(n)) & 0x0f; +} + +template +inline void load(T& dst, const char* n, typename msgpack::enable_if::type* = nullptr) { + dst = static_cast(*reinterpret_cast(n)); +} + +template +inline void load(T& dst, const char* n, typename msgpack::enable_if::type* = nullptr) { + _msgpack_load16(T, n, &dst); +} + +template +inline void load(T& dst, const char* n, typename msgpack::enable_if::type* = nullptr) { + _msgpack_load32(T, n, &dst); +} + +template +inline void load(T& dst, const char* n, typename msgpack::enable_if::type* = nullptr) { + _msgpack_load64(T, n, &dst); +} + +class context { +public: + context(unpack_reference_func f, void* user_data):m_trail(0), m_user(f, user_data), m_cs(CS_HEADER), m_top(0) + { + m_stack[0].set_obj(object()); + } + + void init() + { + m_cs = CS_HEADER; + m_trail = 0; + m_top = 0; + m_stack[0].set_obj(object()); + } + + object const& data() const + { + return m_stack[0].obj(); + } + + unpack_user& user() + { + return m_user; + } + + unpack_user const& user() const + { + return m_user; + } + + int execute(const char* data, std::size_t len, std::size_t& off) + { + assert(len >= off); + + m_start = data; + m_current = data + off; + m_stack_idx = 0; + const char* const pe = data + len; + const char* n = nullptr; + + object obj; + + if(m_current == pe) { + off = m_current - m_start; + return 0; + } + bool fixed_trail_again = false; + do { + if (m_cs == CS_HEADER) { + fixed_trail_again = false; + int selector = *reinterpret_cast(m_current); + if (0x00 <= selector && selector <= 0x7f) { // Positive Fixnum + unpack_uint8(*reinterpret_cast(m_current), obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } else if(0xe0 <= selector && selector <= 0xff) { // Negative Fixnum + unpack_int8(*reinterpret_cast(m_current), obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } else if (0xc4 <= selector && selector <= 0xdf) { + const uint32_t trail[] = { + 1, // bin 8 0xc4 + 2, // bin 16 0xc5 + 4, // bin 32 0xc6 + 1, // ext 8 0xc7 + 2, // ext 16 0xc8 + 4, // ext 32 0xc9 + 4, // float 32 0xca + 8, // float 64 0xcb + 1, // uint 8 0xcc + 2, // uint 16 0xcd + 4, // uint 32 0xce + 8, // uint 64 0xcf + 1, // int 8 0xd0 + 2, // int 16 0xd1 + 4, // int 32 0xd2 + 8, // int 64 0xd3 + 2, // fixext 1 0xd4 + 3, // fixext 2 0xd5 + 5, // fixext 4 0xd6 + 9, // fixext 8 0xd7 + 17,// fixext 16 0xd8 + 1, // str 8 0xd9 + 2, // str 16 0xda + 4, // str 32 0xdb + 2, // array 16 0xdc + 4, // array 32 0xdd + 2, // map 16 0xde + 4, // map 32 0xdf + }; + m_trail = trail[selector - 0xc4]; + m_cs = next_cs(m_current); + fixed_trail_again = true; + } else if(0xa0 <= selector && selector <= 0xbf) { // FixStr + m_trail = static_cast(*m_current) & 0x1f; + if(m_trail == 0) { + unpack_str(m_user, n, m_trail, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } + else { + m_cs = ACS_STR_VALUE; + fixed_trail_again = true; + } + + } else if(0x90 <= selector && selector <= 0x9f) { // FixArray + int ret = push_aggregate( + unpack_array(), CT_ARRAY_ITEM, obj, m_current, off); + if (ret != 0) return ret; + } else if(0x80 <= selector && selector <= 0x8f) { // FixMap + int ret = push_aggregate( + unpack_map(), CT_MAP_KEY, obj, m_current, off); + if (ret != 0) return ret; + } else if(selector == 0xc2) { // false + unpack_false(obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } else if(selector == 0xc3) { // true + unpack_true(obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } else if(selector == 0xc0) { // nil + unpack_nil(obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } else { + off = m_current - m_start; + return -1; + } + // end CS_HEADER + } + if (m_cs != CS_HEADER || fixed_trail_again) { + if (fixed_trail_again) { + ++m_current; + fixed_trail_again = false; + } + if(static_cast(pe - m_current) < m_trail) { + off = m_current - m_start; + return 0; + } + n = m_current; + m_current += m_trail - 1; + switch(m_cs) { + //case CS_ + //case CS_ + case CS_FLOAT: { + union { uint32_t i; float f; } mem; + load(mem.i, n); + unpack_float(mem.f, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case CS_DOUBLE: { + union { uint64_t i; double f; } mem; + load(mem.i, n); +#if defined(__arm__) && !(__ARM_EABI__) // arm-oabi + // https://github.com/msgpack/msgpack-perl/pull/1 + mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); +#endif + unpack_double(mem.f, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case CS_UINT_8: { + uint8_t tmp; + load(tmp, n); + unpack_uint8(tmp, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case CS_UINT_16: { + uint16_t tmp; + load(tmp, n); + unpack_uint16(tmp, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case CS_UINT_32: { + uint32_t tmp; + load(tmp, n); + unpack_uint32(tmp, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case CS_UINT_64: { + uint64_t tmp; + load(tmp, n); + unpack_uint64(tmp, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case CS_INT_8: { + int8_t tmp; + load(tmp, n); + unpack_int8(tmp, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case CS_INT_16: { + int16_t tmp; + load(tmp, n); + unpack_int16(tmp, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case CS_INT_32: { + int32_t tmp; + load(tmp, n); + unpack_int32(tmp, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case CS_INT_64: { + int64_t tmp; + load(tmp, n); + unpack_int64(tmp, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case CS_FIXEXT_1: { + unpack_ext(m_user, n, 1+1, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case CS_FIXEXT_2: { + unpack_ext(m_user, n, 2+1, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case CS_FIXEXT_4: { + unpack_ext(m_user, n, 4+1, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case CS_FIXEXT_8: { + unpack_ext(m_user, n, 8+1, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case CS_FIXEXT_16: { + unpack_ext(m_user, n, 16+1, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case CS_STR_8: { + uint8_t tmp; + load(tmp, n); + m_trail = tmp; + if(m_trail == 0) { + unpack_str(m_user, n, m_trail, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } + else { + m_cs = ACS_STR_VALUE; + fixed_trail_again = true; + } + } break; + case CS_BIN_8: { + uint8_t tmp; + load(tmp, n); + m_trail = tmp; + if(m_trail == 0) { + unpack_bin(m_user, n, m_trail, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } + else { + m_cs = ACS_BIN_VALUE; + fixed_trail_again = true; + } + } break; + case CS_EXT_8: { + uint8_t tmp; + load(tmp, n); + m_trail = tmp + 1; + if(m_trail == 0) { + unpack_ext(m_user, n, m_trail, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } + else { + m_cs = ACS_EXT_VALUE; + fixed_trail_again = true; + } + } break; + case CS_STR_16: { + uint16_t tmp; + load(tmp, n); + m_trail = tmp; + if(m_trail == 0) { + unpack_str(m_user, n, m_trail, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } + else { + m_cs = ACS_STR_VALUE; + fixed_trail_again = true; + } + } break; + case CS_BIN_16: { + uint16_t tmp; + load(tmp, n); + m_trail = tmp; + if(m_trail == 0) { + unpack_bin(m_user, n, m_trail, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } + else { + m_cs = ACS_BIN_VALUE; + fixed_trail_again = true; + } + } break; + case CS_EXT_16: { + uint16_t tmp; + load(tmp, n); + m_trail = tmp + 1; + if(m_trail == 0) { + unpack_ext(m_user, n, m_trail, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } + else { + m_cs = ACS_EXT_VALUE; + fixed_trail_again = true; + } + } break; + case CS_STR_32: { + uint32_t tmp; + load(tmp, n); + m_trail = tmp; + if(m_trail == 0) { + unpack_str(m_user, n, m_trail, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } + else { + m_cs = ACS_STR_VALUE; + fixed_trail_again = true; + } + } break; + case CS_BIN_32: { + uint32_t tmp; + load(tmp, n); + m_trail = tmp; + if(m_trail == 0) { + unpack_bin(m_user, n, m_trail, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } + else { + m_cs = ACS_BIN_VALUE; + fixed_trail_again = true; + } + } break; + case CS_EXT_32: { + uint32_t tmp; + load(tmp, n); + m_trail = tmp + 1; + if(m_trail == 0) { + unpack_ext(m_user, n, m_trail, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } + else { + m_cs = ACS_EXT_VALUE; + fixed_trail_again = true; + } + } break; + case ACS_STR_VALUE: { + unpack_str(m_user, n, m_trail, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case ACS_BIN_VALUE: { + unpack_bin(m_user, n, m_trail, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case ACS_EXT_VALUE: { + unpack_ext(m_user, n, m_trail, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case CS_ARRAY_16: { + int ret = push_aggregate( + unpack_array(), CT_ARRAY_ITEM, obj, n, off); + if (ret != 0) return ret; + } break; + case CS_ARRAY_32: { + /* FIXME security guard */ + int ret = push_aggregate( + unpack_array(), CT_ARRAY_ITEM, obj, n, off); + if (ret != 0) return ret; + } break; + case CS_MAP_16: { + int ret = push_aggregate( + unpack_map(), CT_MAP_KEY, obj, n, off); + if (ret != 0) return ret; + } break; + case CS_MAP_32: { + /* FIXME security guard */ + int ret = push_aggregate( + unpack_map(), CT_MAP_KEY, obj, n, off); + if (ret != 0) return ret; + } break; + default: + off = m_current - m_start; + return -1; + } + } + } while(m_current != pe); + + off = m_current - m_start; + return 0; + } + +private: + template + static uint32_t next_cs(T p) + { + return static_cast(*p) & 0x1f; + } + + template + int push_aggregate( + Func const& f, + uint32_t container_type, + object& obj, + const char* load_pos, + std::size_t& off) { + if(m_top < MSGPACK_EMBED_STACK_SIZE /* FIXME */) { + typename value::type tmp; + load(tmp, load_pos); + f(m_user, tmp, m_stack[m_top].obj()); + if(tmp == 0) { + obj = m_stack[m_top].obj(); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } + else { + m_stack[m_top].set_container_type(container_type); + m_stack[m_top].set_count(tmp); + ++m_top; + m_cs = CS_HEADER; + ++m_current; + } + } + else { + off = m_current - m_start; + return -1; + } + return 0; + } + + int push_item(object& obj) { + bool finish = false; + while (!finish) { + if(m_top == 0) { + return 1; + } + m_stack_idx = m_top - 1; + unpack_stack* sp = &m_stack[m_stack_idx]; + switch(sp->container_type()) { + case CT_ARRAY_ITEM: + unpack_array_item(sp->obj(), obj); + if(sp->decl_count() == 0) { + obj = sp->obj(); + --m_top; + /*printf("stack pop %d\n", m_top);*/ + } + else { + finish = true; + } + break; + case CT_MAP_KEY: + sp->set_map_key(obj); + sp->set_container_type(CT_MAP_VALUE); + finish = true; + break; + case CT_MAP_VALUE: + unpack_map_item(sp->obj(), sp->map_key(), obj); + if(sp->decl_count() == 0) { + obj = sp->obj(); + --m_top; + /*printf("stack pop %d\n", m_top);*/ + } + else { + sp->set_container_type(CT_MAP_KEY); + finish = true; + } + break; + default: + return -1; + } + } + return 0; + } + + int push_proc(object& obj, std::size_t& off) { + int ret = push_item(obj); + if (ret > 0) { + m_stack[0].set_obj(obj); + ++m_current; + /*printf("-- finish --\n"); */ + off = m_current - m_start; + } + else if (ret < 0) { + off = m_current - m_start; + } + else { + m_cs = CS_HEADER; + ++m_current; + } + return ret; + } + +private: + char const* m_start; + char const* m_current; + + uint32_t m_trail; + unpack_user m_user; + uint32_t m_cs; + uint32_t m_top; + uint32_t m_stack_idx; + unpack_stack m_stack[MSGPACK_EMBED_STACK_SIZE]; +}; + +} // detail + + +struct unpack_error : public std::runtime_error { +#if defined(MSGPACK_USE_CPP03) + unpack_error(const std::string& msg) : + std::runtime_error(msg) { } +#else + unpack_error(const char* msg) : + std::runtime_error(msg) { } +#endif +}; + + +class unpacked { +public: + unpacked() {} + + unpacked(object const& obj, msgpack::unique_ptr z) : + m_obj(obj), m_zone(msgpack::move(z)) { } + + void set(object const& obj) + { m_obj = obj; } + + const object& get() const + { return m_obj; } + + msgpack::unique_ptr& zone() + { return m_zone; } + + const msgpack::unique_ptr& zone() const + { return m_zone; } + +private: + object m_obj; + msgpack::unique_ptr m_zone; +}; + + +class unpacker { +public: + unpacker(unpack_reference_func f = &unpacker::default_reference_func, + void* user_data = nullptr, + std::size_t init_buffer_size = MSGPACK_UNPACKER_INIT_BUFFER_SIZE); + +#if !defined(MSGPACK_USE_CPP03) + unpacker(unpacker&& other); + unpacker& operator=(unpacker&& other); +#endif // !defined(MSGPACK_USE_CPP03) + + ~unpacker(); + +public: + /*! 1. reserve buffer. at least `size' bytes of capacity will be ready */ + void reserve_buffer(std::size_t size = MSGPACK_UNPACKER_RESERVE_SIZE); + + /*! 2. read data to the buffer() up to buffer_capacity() bytes */ + char* buffer(); + std::size_t buffer_capacity() const; + + /*! 3. specify the number of bytes actually copied */ + void buffer_consumed(std::size_t size); + + /*! 4. repeat next() until it retunrs false */ + bool next(unpacked* result); + bool next(unpacked& result, bool& referenced); + bool next(unpacked& result); + + /*! 5. check if the size of message doesn't exceed assumption. */ + std::size_t message_size() const; + + // Basic usage of the unpacker is as following: + // + // unpacker pac; + // while( /* input is readable */ ) { + // + // // 1. + // pac.reserve_buffer(32*1024); + // + // // 2. + // std::size_t bytes = input.readsome(pac.buffer(), pac.buffer_capacity()); + // + // // error handling ... + // + // // 3. + // pac.buffer_consumed(bytes); + // + // // 4. + // unpacked result; + // while(pac.next(&result)) { + // // do some with the object with the zone. + // object obj = result.get(); + // std::auto_ptr z = result.zone(); + // on_message(obj, z); + // + // //// boost::shared_ptr is also usable: + // // boost::shared_ptr life(z.release()); + // // on_message(result.get(), life); + // } + // + // // 5. + // if(pac.message_size() > 10*1024*1024) { + // throw std::runtime_error("message is too large"); + // } + // } + // + + /*! for backward compatibility */ + bool execute(); + + /*! for backward compatibility */ + object const& data(); + + /*! for backward compatibility */ + zone* release_zone(); + + /*! for backward compatibility */ + void reset_zone(); + + /*! for backward compatibility */ + void reset(); + +public: + // These functions are usable when non-MessagePack message follows after + // MessagePack message. + std::size_t parsed_size() const; + + /*! get address of the buffer that is not parsed */ + char* nonparsed_buffer(); + std::size_t nonparsed_size() const; + + /*! skip specified size of non-parsed buffer, leaving the buffer */ + // Note that the `size' argument must be smaller than nonparsed_size() + void skip_nonparsed_buffer(std::size_t size); + + /*! remove unparsed buffer from unpacker */ + // Note that reset() leaves non-parsed buffer. + void remove_nonparsed_buffer(); + +private: + void expand_buffer(std::size_t size); + int execute_imp(); + bool flush_zone(); + static bool default_reference_func(type::object_type type, std::size_t len, void*); + +private: + char* m_buffer; + std::size_t m_used; + std::size_t m_free; + std::size_t m_off; + std::size_t m_parsed; + msgpack::unique_ptr m_z; + std::size_t m_initial_buffer_size; + detail::context m_ctx; + +private: + unpacker(const unpacker&); + unpacker& operator=(const unpacker&); +}; + +#if !defined(MSGPACK_USE_CPP03) + +inline unpacked unpack( + const char* data, std::size_t len, std::size_t& off, bool& referenced, + unpack_reference_func f = nullptr, void* user_data = nullptr); +inline unpacked unpack( + const char* data, std::size_t len, std::size_t& off, + unpack_reference_func f = nullptr, void* user_data = nullptr); +inline unpacked unpack( + const char* data, std::size_t len, bool& referenced, + unpack_reference_func f = nullptr, void* user_data = nullptr); +inline unpacked unpack( + const char* data, std::size_t len, + unpack_reference_func f = nullptr, void* user_data = nullptr); + +#endif // !defined(MSGPACK_USE_CPP03) + + +inline void unpack(unpacked& result, + const char* data, std::size_t len, std::size_t& off, bool& referenced, + unpack_reference_func f = nullptr, void* user_data = nullptr); +inline void unpack(unpacked& result, + const char* data, std::size_t len, std::size_t& off, + unpack_reference_func f = nullptr, void* user_data = nullptr); +inline void unpack(unpacked& result, + const char* data, std::size_t len, bool& referenced, + unpack_reference_func f = nullptr, void* user_data = nullptr); +inline void unpack(unpacked& result, + const char* data, std::size_t len, + unpack_reference_func f = nullptr, void* user_data = nullptr); + +// obsolete +inline void unpack(unpacked* result, + const char* data, std::size_t len, std::size_t* off = nullptr, bool* referenced = nullptr, + unpack_reference_func f = nullptr, void* user_data = nullptr); + + +// for internal use +typedef enum { + UNPACK_SUCCESS = 2, + UNPACK_EXTRA_BYTES = 1, + UNPACK_CONTINUE = 0, + UNPACK_PARSE_ERROR = -1 +} unpack_return; + +inline unpacker::unpacker(unpack_reference_func f, + void* user_data, + std::size_t initial_buffer_size) + :m_z(new zone), m_ctx(f, user_data) +{ + if(initial_buffer_size < COUNTER_SIZE) { + initial_buffer_size = COUNTER_SIZE; + } + + char* buffer = static_cast(::malloc(initial_buffer_size)); + if(!buffer) { + throw std::bad_alloc(); + } + + m_buffer = buffer; + m_used = COUNTER_SIZE; + m_free = initial_buffer_size - m_used; + m_off = COUNTER_SIZE; + m_parsed = 0; + m_initial_buffer_size = initial_buffer_size; + + detail::init_count(m_buffer); + + m_ctx.init(); + m_ctx.user().set_zone(*m_z); + m_ctx.user().set_referenced(false); +} + +#if !defined(MSGPACK_USE_CPP03) +// Move constructor and move assignment operator + +inline unpacker::unpacker(unpacker&& other) + :m_buffer(other.m_buffer), + m_used(other.m_used), + m_free(other.m_free), + m_off(other.m_off), + m_parsed(other.m_parsed), + m_z(std::move(other.m_z)), + m_initial_buffer_size(other.m_initial_buffer_size), + m_ctx(other.m_ctx) { + other.m_buffer = nullptr; +} + +inline unpacker& unpacker::operator=(unpacker&& other) { + this->~unpacker(); + new (this) unpacker(std::move(other)); + return *this; +} + +#endif // !defined(MSGPACK_USE_CPP03) + + +inline unpacker::~unpacker() +{ + // These checks are required for move operations. + if (m_buffer) detail::decl_count(m_buffer); +} + + +inline void unpacker::reserve_buffer(std::size_t size) +{ + if(m_free >= size) return; + expand_buffer(size); +} + +inline void unpacker::expand_buffer(std::size_t size) +{ + if(m_used == m_off && detail::get_count(m_buffer) == 1 + && !m_ctx.user().referenced()) { + // rewind buffer + m_free += m_used - COUNTER_SIZE; + m_used = COUNTER_SIZE; + m_off = COUNTER_SIZE; + + if(m_free >= size) return; + } + + if(m_off == COUNTER_SIZE) { + std::size_t next_size = (m_used + m_free) * 2; // include COUNTER_SIZE + while(next_size < size + m_used) { + next_size *= 2; + } + + char* tmp = static_cast(::realloc(m_buffer, next_size)); + if(!tmp) { + throw std::bad_alloc(); + } + + m_buffer = tmp; + m_free = next_size - m_used; + + } else { + std::size_t next_size = m_initial_buffer_size; // include COUNTER_SIZE + std::size_t not_parsed = m_used - m_off; + while(next_size < size + not_parsed + COUNTER_SIZE) { + next_size *= 2; + } + + char* tmp = static_cast(::malloc(next_size)); + if(!tmp) { + throw std::bad_alloc(); + } + + detail::init_count(tmp); + + std::memcpy(tmp+COUNTER_SIZE, m_buffer + m_off, not_parsed); + + if(m_ctx.user().referenced()) { + try { + m_z->push_finalizer(&detail::decl_count, m_buffer); + } + catch (...) { + ::free(tmp); + throw; + } + m_ctx.user().set_referenced(false); + } else { + detail::decl_count(m_buffer); + } + + m_buffer = tmp; + m_used = not_parsed + COUNTER_SIZE; + m_free = next_size - m_used; + m_off = COUNTER_SIZE; + } +} + +inline char* unpacker::buffer() +{ + return m_buffer + m_used; +} + +inline std::size_t unpacker::buffer_capacity() const +{ + return m_free; +} + +inline void unpacker::buffer_consumed(std::size_t size) +{ + m_used += size; + m_free -= size; +} + +inline bool unpacker::next(unpacked& result, bool& referenced) +{ + referenced = false; + int ret = execute_imp(); + if(ret < 0) { + throw unpack_error("parse error"); + } + + if(ret == 0) { + result.zone().reset(); + result.set(object()); + return false; + + } else { + referenced = m_ctx.user().referenced(); + result.zone().reset( release_zone() ); + result.set(data()); + reset(); + return true; + } +} + +inline bool unpacker::next(unpacked& result) +{ + bool referenced; + return next(result, referenced); +} + +inline bool unpacker::next(unpacked* result) +{ + return next(*result); +} + + +inline bool unpacker::execute() +{ + int ret = execute_imp(); + if(ret < 0) { + throw unpack_error("parse error"); + } else if(ret == 0) { + return false; + } else { + return true; + } +} + +inline int unpacker::execute_imp() +{ + std::size_t off = m_off; + int ret = m_ctx.execute(m_buffer, m_used, m_off); + if(m_off > off) { + m_parsed += m_off - off; + } + return ret; +} + +inline object const& unpacker::data() +{ + return m_ctx.data(); +} + +inline zone* unpacker::release_zone() +{ + if(!flush_zone()) { + return nullptr; + } + + zone* r = new zone; + zone* old = m_z.release(); + m_z.reset(r); + m_ctx.user().set_zone(*m_z); + + return old; +} + +inline void unpacker::reset_zone() +{ + m_z->clear(); +} + +inline bool unpacker::flush_zone() +{ + if(m_ctx.user().referenced()) { + try { + m_z->push_finalizer(&detail::decl_count, m_buffer); + } catch (...) { + return false; + } + m_ctx.user().set_referenced(false); + + detail::incr_count(m_buffer); + } + + return true; +} + +inline void unpacker::reset() +{ + m_ctx.init(); + // don't reset referenced flag + m_parsed = 0; +} + +inline std::size_t unpacker::message_size() const +{ + return m_parsed - m_off + m_used; +} + +inline std::size_t unpacker::parsed_size() const +{ + return m_parsed; +} + +inline char* unpacker::nonparsed_buffer() +{ + return m_buffer + m_off; +} + +inline std::size_t unpacker::nonparsed_size() const +{ + return m_used - m_off; +} + +inline void unpacker::skip_nonparsed_buffer(std::size_t size) +{ + m_off += size; +} + +inline void unpacker::remove_nonparsed_buffer() +{ + m_used = m_off; +} + +namespace detail { + +inline unpack_return +unpack_imp(const char* data, std::size_t len, std::size_t& off, + zone& result_zone, object& result, bool& referenced, + unpack_reference_func f = nullptr, void* user_data = nullptr) +{ + std::size_t noff = off; + + if(len <= noff) { + // FIXME + return UNPACK_CONTINUE; + } + + detail::context ctx(f, user_data); + ctx.init(); + + ctx.user().set_zone(result_zone); + ctx.user().set_referenced(false); + referenced = false; + + int e = ctx.execute(data, len, noff); + if(e < 0) { + return UNPACK_PARSE_ERROR; + } + + referenced = ctx.user().referenced(); + off = noff; + + if(e == 0) { + return UNPACK_CONTINUE; + } + + result = ctx.data(); + + if(noff < len) { + return UNPACK_EXTRA_BYTES; + } + + return UNPACK_SUCCESS; +} + +} // detail + +// reference version + +#if !defined(MSGPACK_USE_CPP03) + +inline unpacked unpack( + const char* data, std::size_t len, std::size_t& off, bool& referenced, + unpack_reference_func f, void* user_data) +{ + object obj; + msgpack::unique_ptr z(new zone); + referenced = false; + unpack_return ret = detail::unpack_imp( + data, len, off, *z, obj, referenced, f, user_data); + + switch(ret) { + case UNPACK_SUCCESS: + return unpacked(obj, msgpack::move(z)); + case UNPACK_EXTRA_BYTES: + return unpacked(obj, msgpack::move(z)); + case UNPACK_CONTINUE: + throw unpack_error("insufficient bytes"); + case UNPACK_PARSE_ERROR: + default: + throw unpack_error("parse error"); + } + return unpacked(); +} + +inline unpacked unpack( + const char* data, std::size_t len, std::size_t& off, + unpack_reference_func f, void* user_data) +{ + bool referenced; + return unpack(data, len, off, referenced, f, user_data); +} + +inline unpacked unpack( + const char* data, std::size_t len, bool& referenced, + unpack_reference_func f, void* user_data) +{ + std::size_t off = 0; + return unpack(data, len, off, referenced, f, user_data); +} + +inline unpacked unpack( + const char* data, std::size_t len, + unpack_reference_func f, void* user_data) +{ + bool referenced; + std::size_t off = 0; + return unpack(data, len, off, referenced, f, user_data); +} + +#endif // !defined(MSGPACK_USE_CPP03) + + +inline void unpack(unpacked& result, + const char* data, std::size_t len, std::size_t& off, bool& referenced, + unpack_reference_func f, void* user_data) +{ + object obj; + msgpack::unique_ptr z(new zone); + referenced = false; + unpack_return ret = detail::unpack_imp( + data, len, off, *z, obj, referenced, f, user_data); + + switch(ret) { + case UNPACK_SUCCESS: + result.set(obj); + result.zone() = msgpack::move(z); + return; + case UNPACK_EXTRA_BYTES: + result.set(obj); + result.zone() = msgpack::move(z); + return; + case UNPACK_CONTINUE: + throw unpack_error("insufficient bytes"); + case UNPACK_PARSE_ERROR: + default: + throw unpack_error("parse error"); + } +} + +inline void unpack(unpacked& result, + const char* data, std::size_t len, std::size_t& off, + unpack_reference_func f, void* user_data) +{ + bool referenced; + unpack(result, data, len, off, referenced, f, user_data); +} + +inline void unpack(unpacked& result, + const char* data, std::size_t len, bool& referenced, + unpack_reference_func f, void* user_data) +{ + std::size_t off = 0; + unpack(result, data, len, off, referenced, f, user_data); +} + +inline void unpack(unpacked& result, + const char* data, std::size_t len, + unpack_reference_func f, void* user_data) +{ + bool referenced; + std::size_t off = 0; + unpack(result, data, len, off, referenced, f, user_data); +} + +// obsolete +// pointer version +inline void unpack(unpacked* result, + const char* data, std::size_t len, std::size_t* off, bool* referenced, + unpack_reference_func f, void* user_data) +{ + if (off) + if (referenced) unpack(*result, data, len, *off, *referenced, f, user_data); + else unpack(*result, data, len, *off, f, user_data); + else + if (referenced) unpack(*result, data, len, *referenced, f, user_data); + else unpack(*result, data, len, f, user_data); +} + +inline bool unpacker::default_reference_func(type::object_type /*type*/, std::size_t /*len*/, void*) +{ + return true; +} + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + + +#endif /* msgpack/unpack.hpp */ diff --git a/include/msgpack/unpack_define.h b/include/msgpack/unpack_define.h new file mode 100644 index 00000000..d37183d3 --- /dev/null +++ b/include/msgpack/unpack_define.h @@ -0,0 +1,97 @@ +/* + * MessagePack unpacking routine template + * + * Copyright (C) 2008-2010 FURUHASHI Sadayuki + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * 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_UNPACK_DEFINE_H +#define MSGPACK_UNPACK_DEFINE_H + +#include "msgpack/sysdep.h" +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +#ifndef MSGPACK_EMBED_STACK_SIZE +#define MSGPACK_EMBED_STACK_SIZE 32 +#endif + + +typedef enum { + CS_HEADER = 0x00, // nil + + //CS_ = 0x01, + //CS_ = 0x02, // false + //CS_ = 0x03, // true + + CS_BIN_8 = 0x04, + CS_BIN_16 = 0x05, + CS_BIN_32 = 0x06, + + CS_EXT_8 = 0x07, + CS_EXT_16 = 0x08, + CS_EXT_32 = 0x09, + + CS_FLOAT = 0x0a, + CS_DOUBLE = 0x0b, + CS_UINT_8 = 0x0c, + CS_UINT_16 = 0x0d, + CS_UINT_32 = 0x0e, + CS_UINT_64 = 0x0f, + CS_INT_8 = 0x10, + CS_INT_16 = 0x11, + CS_INT_32 = 0x12, + CS_INT_64 = 0x13, + + CS_FIXEXT_1 = 0x14, + CS_FIXEXT_2 = 0x15, + CS_FIXEXT_4 = 0x16, + CS_FIXEXT_8 = 0x17, + CS_FIXEXT_16 = 0x18, + + CS_STR_8 = 0x19, // str8 + CS_STR_16 = 0x1a, // str16 + CS_STR_32 = 0x1b, // str32 + CS_ARRAY_16 = 0x1c, + CS_ARRAY_32 = 0x1d, + CS_MAP_16 = 0x1e, + CS_MAP_32 = 0x1f, + + //ACS_BIG_INT_VALUE, + //ACS_BIG_FLOAT_VALUE, + ACS_STR_VALUE, + ACS_BIN_VALUE, + ACS_EXT_VALUE +} msgpack_unpack_state; + + +typedef enum { + CT_ARRAY_ITEM, + CT_MAP_KEY, + CT_MAP_VALUE +} msgpack_container_type; + + +#ifdef __cplusplus +} +#endif + +#endif /* msgpack/unpack_define.h */ + diff --git a/include/msgpack/unpack_template.h b/include/msgpack/unpack_template.h new file mode 100644 index 00000000..28ceb9e4 --- /dev/null +++ b/include/msgpack/unpack_template.h @@ -0,0 +1,476 @@ +/* + * MessagePack unpacking routine template + * + * Copyright (C) 2008-2010 FURUHASHI Sadayuki + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * 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_unpack_func +#error msgpack_unpack_func template is not defined +#endif + +#ifndef msgpack_unpack_callback +#error msgpack_unpack_callback template is not defined +#endif + +#ifndef msgpack_unpack_struct +#error msgpack_unpack_struct template is not defined +#endif + +#ifndef msgpack_unpack_struct_decl +#define msgpack_unpack_struct_decl(name) msgpack_unpack_struct(name) +#endif + +#ifndef msgpack_unpack_object +#error msgpack_unpack_object type is not defined +#endif + +#ifndef msgpack_unpack_user +#error msgpack_unpack_user type is not defined +#endif + +#ifndef USE_CASE_RANGE +#if !defined(_MSC_VER) +#define USE_CASE_RANGE +#endif +#endif + +msgpack_unpack_struct_decl(_stack) { + msgpack_unpack_object obj; + size_t count; + unsigned int ct; + msgpack_unpack_object map_key; +}; + +msgpack_unpack_struct_decl(_context) { + msgpack_unpack_user user; + unsigned int cs; + unsigned int trail; + unsigned int top; + /* + msgpack_unpack_struct(_stack)* stack; + unsigned int stack_size; + msgpack_unpack_struct(_stack) embed_stack[MSGPACK_EMBED_STACK_SIZE]; + */ + msgpack_unpack_struct(_stack) stack[MSGPACK_EMBED_STACK_SIZE]; +}; + + +msgpack_unpack_func(void, _init)(msgpack_unpack_struct(_context)* ctx) +{ + ctx->cs = CS_HEADER; + ctx->trail = 0; + ctx->top = 0; + /* + ctx->stack = ctx->embed_stack; + ctx->stack_size = MSGPACK_EMBED_STACK_SIZE; + */ + ctx->stack[0].obj = msgpack_unpack_callback(_root)(&ctx->user); +} + +/* +msgpack_unpack_func(void, _destroy)(msgpack_unpack_struct(_context)* ctx) +{ + if(ctx->stack_size != MSGPACK_EMBED_STACK_SIZE) { + free(ctx->stack); + } +} +*/ + +msgpack_unpack_func(msgpack_unpack_object, _data)(msgpack_unpack_struct(_context)* ctx) +{ + return (ctx)->stack[0].obj; +} + + +msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const char* data, size_t len, size_t* off) +{ + assert(len >= *off); + + const unsigned char* p = (unsigned char*)data + *off; + const unsigned char* const pe = (unsigned char*)data + len; + const void* n = NULL; + + unsigned int trail = ctx->trail; + unsigned int cs = ctx->cs; + unsigned int top = ctx->top; + msgpack_unpack_struct(_stack)* stack = ctx->stack; + /* + unsigned int stack_size = ctx->stack_size; + */ + msgpack_unpack_user* user = &ctx->user; + + msgpack_unpack_object obj; + msgpack_unpack_struct(_stack)* c = NULL; + + int ret; + +#define push_simple_value(func) \ + if(msgpack_unpack_callback(func)(user, &obj) < 0) { goto _failed; } \ + goto _push +#define push_fixed_value(func, arg) \ + if(msgpack_unpack_callback(func)(user, arg, &obj) < 0) { goto _failed; } \ + goto _push +#define push_variable_value(func, base, pos, len) \ + if(msgpack_unpack_callback(func)(user, \ + (const char*)base, (const char*)pos, len, &obj) < 0) { goto _failed; } \ + goto _push + +#define again_fixed_trail(_cs, trail_len) \ + trail = trail_len; \ + cs = _cs; \ + goto _fixed_trail_again +#define again_fixed_trail_if_zero(_cs, trail_len, ifzero) \ + trail = trail_len; \ + if(trail == 0) { goto ifzero; } \ + cs = _cs; \ + goto _fixed_trail_again + +#define start_container(func, count_, ct_) \ + if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ \ + if(msgpack_unpack_callback(func)(user, count_, &stack[top].obj) < 0) { goto _failed; } \ + if((count_) == 0) { obj = stack[top].obj; goto _push; } \ + stack[top].ct = ct_; \ + stack[top].count = count_; \ + ++top; \ + /*printf("container %d count %d stack %d\n",stack[top].obj,count_,top);*/ \ + /*printf("stack push %d\n", top);*/ \ + /* FIXME \ + if(top >= stack_size) { \ + if(stack_size == MSGPACK_EMBED_STACK_SIZE) { \ + size_t csize = sizeof(msgpack_unpack_struct(_stack)) * MSGPACK_EMBED_STACK_SIZE; \ + size_t nsize = csize * 2; \ + msgpack_unpack_struct(_stack)* tmp = (msgpack_unpack_struct(_stack)*)malloc(nsize); \ + if(tmp == NULL) { goto _failed; } \ + memcpy(tmp, ctx->stack, csize); \ + ctx->stack = stack = tmp; \ + ctx->stack_size = stack_size = MSGPACK_EMBED_STACK_SIZE * 2; \ + } else { \ + size_t nsize = sizeof(msgpack_unpack_struct(_stack)) * ctx->stack_size * 2; \ + msgpack_unpack_struct(_stack)* tmp = (msgpack_unpack_struct(_stack)*)realloc(ctx->stack, nsize); \ + if(tmp == NULL) { goto _failed; } \ + ctx->stack = stack = tmp; \ + ctx->stack_size = stack_size = stack_size * 2; \ + } \ + } \ + */ \ + goto _header_again + +#define NEXT_CS(p) \ + ((unsigned int)*p & 0x1f) + +#ifdef USE_CASE_RANGE +#define SWITCH_RANGE_BEGIN switch(*p) { +#define SWITCH_RANGE(FROM, TO) case FROM ... TO: +#define SWITCH_RANGE_DEFAULT default: +#define SWITCH_RANGE_END } +#else +#define SWITCH_RANGE_BEGIN { if(0) { +#define SWITCH_RANGE(FROM, TO) } else if(FROM <= *p && *p <= TO) { +#define SWITCH_RANGE_DEFAULT } else { +#define SWITCH_RANGE_END } } +#endif + + if(p == pe) { goto _out; } + do { + switch(cs) { + case CS_HEADER: + SWITCH_RANGE_BEGIN + SWITCH_RANGE(0x00, 0x7f) // Positive Fixnum + push_fixed_value(_uint8, *(uint8_t*)p); + SWITCH_RANGE(0xe0, 0xff) // Negative Fixnum + push_fixed_value(_int8, *(int8_t*)p); + SWITCH_RANGE(0xc0, 0xdf) // Variable + switch(*p) { + case 0xc0: // nil + push_simple_value(_nil); + //case 0xc1: // string + // again_terminal_trail(NEXT_CS(p), p+1); + case 0xc2: // false + push_simple_value(_false); + case 0xc3: // true + push_simple_value(_true); + case 0xc4: // bin 8 + case 0xc5: // bin 16 + case 0xc6: // bin 32 + again_fixed_trail(NEXT_CS(p), 1 << (((unsigned int)*p) & 0x03)); + case 0xc7: // ext 8 + case 0xc8: // ext 16 + case 0xc9: // ext 32 + again_fixed_trail(NEXT_CS(p), 1 << ((((unsigned int)*p) + 1) & 0x03)); + case 0xca: // float + case 0xcb: // double + case 0xcc: // unsigned int 8 + case 0xcd: // unsigned int 16 + case 0xce: // unsigned int 32 + case 0xcf: // unsigned int 64 + case 0xd0: // signed int 8 + case 0xd1: // signed int 16 + case 0xd2: // signed int 32 + case 0xd3: // signed int 64 + again_fixed_trail(NEXT_CS(p), 1 << (((unsigned int)*p) & 0x03)); + case 0xd4: // fixext 1 + case 0xd5: // fixext 2 + case 0xd6: // fixext 4 + case 0xd7: // fixext 8 + again_fixed_trail_if_zero(ACS_EXT_VALUE, + (1 << (((unsigned int)*p) & 0x03)) + 1, _ext_zero); + case 0xd8: // fixext 16 + again_fixed_trail_if_zero(ACS_EXT_VALUE, 16+1, _ext_zero); + + case 0xd9: // str 8 + case 0xda: // str 16 + case 0xdb: // str 32 + again_fixed_trail(NEXT_CS(p), 1 << ((((unsigned int)*p) & 0x03) - 1)); + case 0xdc: // array 16 + case 0xdd: // array 32 + case 0xde: // map 16 + case 0xdf: // map 32 + again_fixed_trail(NEXT_CS(p), 2u << (((unsigned int)*p) & 0x01)); + default: + goto _failed; + } + SWITCH_RANGE(0xa0, 0xbf) // FixStr + again_fixed_trail_if_zero(ACS_STR_VALUE, ((unsigned int)*p & 0x1f), _str_zero); + SWITCH_RANGE(0x90, 0x9f) // FixArray + start_container(_array, ((unsigned int)*p) & 0x0f, CT_ARRAY_ITEM); + SWITCH_RANGE(0x80, 0x8f) // FixMap + start_container(_map, ((unsigned int)*p) & 0x0f, CT_MAP_KEY); + + SWITCH_RANGE_DEFAULT + goto _failed; + SWITCH_RANGE_END + // end CS_HEADER + + + _fixed_trail_again: + ++p; + + default: + if((size_t)(pe - p) < trail) { goto _out; } + n = p; p += trail - 1; + switch(cs) { + //case CS_ + //case CS_ + case CS_FLOAT: { + union { uint32_t i; float f; } mem; + _msgpack_load32(uint32_t, n, &mem.i); + push_fixed_value(_float, mem.f); } + case CS_DOUBLE: { + union { uint64_t i; double f; } mem; + _msgpack_load64(uint64_t, n, &mem.i); +#if defined(__arm__) && !(__ARM_EABI__) // arm-oabi + // https://github.com/msgpack/msgpack-perl/pull/1 + mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); +#endif + push_fixed_value(_double, mem.f); } + case CS_UINT_8: + push_fixed_value(_uint8, *(uint8_t*)n); + case CS_UINT_16:{ + uint16_t tmp; + _msgpack_load16(uint16_t,n,&tmp); + push_fixed_value(_uint16, tmp); + } + case CS_UINT_32:{ + uint32_t tmp; + _msgpack_load32(uint32_t,n,&tmp); + push_fixed_value(_uint32, tmp); + } + case CS_UINT_64:{ + uint64_t tmp; + _msgpack_load64(uint64_t,n,&tmp); + push_fixed_value(_uint64, tmp); + } + case CS_INT_8: + push_fixed_value(_int8, *(int8_t*)n); + case CS_INT_16:{ + int16_t tmp; + _msgpack_load16(int16_t,n,&tmp); + push_fixed_value(_int16, tmp); + } + case CS_INT_32:{ + int32_t tmp; + _msgpack_load32(int32_t,n,&tmp); + push_fixed_value(_int32, tmp); + } + case CS_INT_64:{ + int64_t tmp; + _msgpack_load64(int64_t,n,&tmp); + push_fixed_value(_int64, tmp); + } + case CS_FIXEXT_1: + again_fixed_trail_if_zero(ACS_EXT_VALUE, 1+1, _ext_zero); + case CS_FIXEXT_2: + again_fixed_trail_if_zero(ACS_EXT_VALUE, 2+1, _ext_zero); + case CS_FIXEXT_4: + again_fixed_trail_if_zero(ACS_EXT_VALUE, 4+1, _ext_zero); + case CS_FIXEXT_8: + again_fixed_trail_if_zero(ACS_EXT_VALUE, 8+1, _ext_zero); + case CS_FIXEXT_16: + again_fixed_trail_if_zero(ACS_EXT_VALUE, 16+1, _ext_zero); + case CS_STR_8: + again_fixed_trail_if_zero(ACS_STR_VALUE, *(uint8_t*)n, _str_zero); + case CS_BIN_8: + again_fixed_trail_if_zero(ACS_BIN_VALUE, *(uint8_t*)n, _bin_zero); + case CS_EXT_8: + again_fixed_trail_if_zero(ACS_EXT_VALUE, (*(uint8_t*)n) + 1, _ext_zero); + case CS_STR_16:{ + uint16_t tmp; + _msgpack_load16(uint16_t,n,&tmp); + again_fixed_trail_if_zero(ACS_STR_VALUE, tmp, _str_zero); + } + case CS_BIN_16:{ + uint16_t tmp; + _msgpack_load16(uint16_t,n,&tmp); + again_fixed_trail_if_zero(ACS_BIN_VALUE, tmp, _bin_zero); + } + case CS_EXT_16:{ + uint16_t tmp; + _msgpack_load16(uint16_t,n,&tmp); + again_fixed_trail_if_zero(ACS_EXT_VALUE, tmp + 1, _ext_zero); + } + case CS_STR_32:{ + uint32_t tmp; + _msgpack_load32(uint32_t,n,&tmp); + again_fixed_trail_if_zero(ACS_STR_VALUE, tmp, _str_zero); + } + case CS_BIN_32:{ + uint32_t tmp; + _msgpack_load32(uint32_t,n,&tmp); + again_fixed_trail_if_zero(ACS_BIN_VALUE, tmp, _bin_zero); + } + case CS_EXT_32:{ + uint32_t tmp; + _msgpack_load32(uint32_t,n,&tmp); + again_fixed_trail_if_zero(ACS_EXT_VALUE, tmp + 1, _ext_zero); + } + case ACS_STR_VALUE: + _str_zero: + push_variable_value(_str, data, n, trail); + case ACS_BIN_VALUE: + _bin_zero: + push_variable_value(_bin, data, n, trail); + case ACS_EXT_VALUE: + _ext_zero: + push_variable_value(_ext, data, n, trail); + + case CS_ARRAY_16:{ + uint16_t tmp; + _msgpack_load16(uint16_t,n,&tmp); + start_container(_array, tmp, CT_ARRAY_ITEM); + } + case CS_ARRAY_32:{ + /* FIXME security guard */ + uint32_t tmp; + _msgpack_load32(uint32_t,n,&tmp); + start_container(_array, tmp, CT_ARRAY_ITEM); + } + + case CS_MAP_16:{ + uint16_t tmp; + _msgpack_load16(uint16_t,n,&tmp); + start_container(_map, tmp, CT_MAP_KEY); + } + case CS_MAP_32:{ + /* FIXME security guard */ + uint32_t tmp; + _msgpack_load32(uint32_t,n,&tmp); + start_container(_map, tmp, CT_MAP_KEY); + } + + default: + goto _failed; + } + } + +_push: + if(top == 0) { goto _finish; } + c = &stack[top-1]; + switch(c->ct) { + case CT_ARRAY_ITEM: + if(msgpack_unpack_callback(_array_item)(user, &c->obj, obj) < 0) { goto _failed; } + if(--c->count == 0) { + obj = c->obj; + --top; + /*printf("stack pop %d\n", top);*/ + goto _push; + } + goto _header_again; + case CT_MAP_KEY: + c->map_key = obj; + c->ct = CT_MAP_VALUE; + goto _header_again; + case CT_MAP_VALUE: + if(msgpack_unpack_callback(_map_item)(user, &c->obj, c->map_key, obj) < 0) { goto _failed; } + if(--c->count == 0) { + obj = c->obj; + --top; + /*printf("stack pop %d\n", top);*/ + goto _push; + } + c->ct = CT_MAP_KEY; + goto _header_again; + + default: + goto _failed; + } + +_header_again: + cs = CS_HEADER; + ++p; + } while(p != pe); + goto _out; + + +_finish: + stack[0].obj = obj; + ++p; + ret = 1; + /*printf("-- finish --\n"); */ + goto _end; + +_failed: + /*printf("** FAILED **\n"); */ + ret = -1; + goto _end; + +_out: + ret = 0; + goto _end; + +_end: + ctx->cs = cs; + ctx->trail = trail; + ctx->top = top; + *off = (size_t)(p - (const unsigned char*)data); + + return ret; +} + + +#undef msgpack_unpack_func +#undef msgpack_unpack_callback +#undef msgpack_unpack_struct +#undef msgpack_unpack_object +#undef msgpack_unpack_user + +#undef push_simple_value +#undef push_fixed_value +#undef push_variable_value +#undef again_fixed_trail +#undef again_fixed_trail_if_zero +#undef start_container + +#undef NEXT_CS + diff --git a/include/msgpack/util.h b/include/msgpack/util.h new file mode 100644 index 00000000..89b98a18 --- /dev/null +++ b/include/msgpack/util.h @@ -0,0 +1,23 @@ +/* + * MessagePack for C utilities + * + * Copyright (C) 2014 FURUHASHI Sadayuki + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef MSGPACK_UTIL_H +#define MSGPACK_UTIL_H + +#define MSGPACK_UNUSED(a) (void)(a) + +#endif /* MSGPACK_UTIL_H */ diff --git a/src/msgpack/version.h.in b/include/msgpack/version.h similarity index 73% rename from src/msgpack/version.h.in rename to include/msgpack/version.h index f1feb331..233fa818 100644 --- a/src/msgpack/version.h.in +++ b/include/msgpack/version.h @@ -15,8 +15,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#ifndef MSGPACK_VERSION_H__ -#define MSGPACK_VERSION_H__ +#ifndef MSGPACK_VERSION_H +#define MSGPACK_VERSION_H #ifdef __cplusplus extern "C" { @@ -27,10 +27,12 @@ const char* msgpack_version(void); int msgpack_version_major(void); int msgpack_version_minor(void); -#define MSGPACK_VERSION "@VERSION@" -#define MSGPACK_VERSION_MAJOR @VERSION_MAJOR@ -#define MSGPACK_VERSION_MINOR @VERSION_MINOR@ +#include "version_master.h" +#define MSGPACK_STR(v) #v +#define MSGPACK_VERSION_I(maj, min, rev) MSGPACK_STR(maj) "." MSGPACK_STR(min) "." MSGPACK_STR(rev) + +#define MSGPACK_VERSION MSGPACK_VERSION_I(MSGPACK_VERSION_MAJOR, MSGPACK_VERSION_MINOR, MSGPACK_VERSION_REVISION) #ifdef __cplusplus } diff --git a/include/msgpack/version.hpp b/include/msgpack/version.hpp new file mode 100644 index 00000000..d1ccd89e --- /dev/null +++ b/include/msgpack/version.hpp @@ -0,0 +1,44 @@ +/* + * MessagePack for C++ version information + * + * Copyright (C) 2008-2013 FURUHASHI Sadayuki and Takatoshi Kondo + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef MSGPACK_VERSION_HPP +#define MSGPACK_VERSION_HPP + +#include "version_master.h" + +#define MSGPACK_STR(v) #v +#define MSGPACK_VERSION_I(maj, min, rev) MSGPACK_STR(maj) "." MSGPACK_STR(min) "." MSGPACK_STR(rev) + +#define MSGPACK_VERSION MSGPACK_VERSION_I(MSGPACK_VERSION_MAJOR, MSGPACK_VERSION_MINOR, MSGPACK_VERSION_REVISION) + +inline const char* msgpack_version(void) { + return MSGPACK_VERSION; +} + +inline int msgpack_version_major(void) { + return MSGPACK_VERSION_MAJOR; +} + +inline int msgpack_version_minor(void) { + return MSGPACK_VERSION_MINOR; +} + +inline int msgpack_version_revision(void) { + return MSGPACK_VERSION_REVISION; +} + +#endif /* msgpack/version.hpp */ diff --git a/include/msgpack/version_master.h b/include/msgpack/version_master.h new file mode 100644 index 00000000..c3154805 --- /dev/null +++ b/include/msgpack/version_master.h @@ -0,0 +1,3 @@ +#define MSGPACK_VERSION_MAJOR 0 +#define MSGPACK_VERSION_MINOR 6 +#define MSGPACK_VERSION_REVISION 0 diff --git a/include/msgpack/versioning.hpp b/include/msgpack/versioning.hpp new file mode 100644 index 00000000..cb589ea3 --- /dev/null +++ b/include/msgpack/versioning.hpp @@ -0,0 +1,77 @@ +/* + * MessagePack for C++ version switcher + * + * Copyright (C) 2014 KONDO Takatoshi + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef MSGPACK_VERSIONING_HPP +#define MSGPACK_VERSIONING_HPP + +#if !defined(MSGPACK_DEFAULT_API_VERSION) +#define MSGPACK_DEFAULT_API_VERSION 1 +#endif + +#define MSGPACK_DEFAULT_API_NS MSGPACK_PP_CAT(v, MSGPACK_DEFAULT_API_VERSION) + +#if MSGPACK_DEFAULT_API_VERSION == 1 +#define MSGPACK_PP_ENABLE_NS_v1 () +//#elif MSGPACK_DEFAULT_API_VERSION == 2 +//#define MSGPACK_PP_ENABLE_NS_v2 () +#else +#error +#endif + +#define MSGPACK_PP_CAT(a, ...) MSGPACK_PP_PRIMITIVE_CAT(a, __VA_ARGS__) +#define MSGPACK_PP_PRIMITIVE_CAT(a, ...) a ## __VA_ARGS__ + +#define MSGPACK_PP_IIF(c) MSGPACK_PP_PRIMITIVE_CAT(MSGPACK_PP_IIF_, c) +#define MSGPACK_PP_IIF_0(t, ...) __VA_ARGS__ +#define MSGPACK_PP_IIF_1(t, ...) t + +#define MSGPACK_PP_PROBE(x) x, 1 + +#if defined(__MSC_VER) + +#define MSGPACK_PP_MSVC_VA_ARGS_WORKAROUND(define, args) define args +#define MSGPACK_PP_CHECK(...) MSGPACK_PP_MSVC_VA_ARGS_WORKAROUND(MSGPACK_PP_CHECK_N, (__VA_ARGS__, 0)) +#define MSGPACK_PP_CHECK_N(x, n, ...) n + +#else // defined(__MSC_VER) + +#define MSGPACK_PP_CHECK(...) MSGPACK_PP_CHECK_N(__VA_ARGS__, 0) +#define MSGPACK_PP_CHECK_N(x, n, ...) n + +#endif // defined(__MSC_VER) + + +#define MSGPACK_PP_NS_ENABLED_PROBE(ns) MSGPACK_PP_NS_ENABLED_PROBE_PROXY( MSGPACK_PP_ENABLE_NS_##ns ) +#define MSGPACK_PP_NS_ENABLED_PROBE_PROXY(...) MSGPACK_PP_NS_ENABLED_PROBE_PRIMIVIE(__VA_ARGS__) +#define MSGPACK_PP_NS_ENABLED_PROBE_PRIMIVIE(x) MSGPACK_PP_NS_ENABLED_PROBE_COMBINE_ x +#define MSGPACK_PP_NS_ENABLED_PROBE_COMBINE_(...) MSGPACK_PP_PROBE(~) + +#define MSGPACK_PP_IS_NS_ENABLED(ns) MSGPACK_PP_CHECK(MSGPACK_PP_NS_ENABLED_PROBE(ns)) + +#if __cplusplus < 201103 +#define MSGPACK_API_VERSION_NAMESPACE(ns) MSGPACK_PP_IIF(MSGPACK_PP_IS_NS_ENABLED(ns)) \ + (namespace ns{}; using namespace ns; namespace ns, \ + namespace ns) + +#else // __cplusplus < 201103 + +#define MSGPACK_API_VERSION_NAMESPACE(ns) MSGPACK_PP_IIF(MSGPACK_PP_IS_NS_ENABLED(ns)) \ + (inline namespace ns, namespace ns) + +#endif // __cplusplus < 201103 + +#endif // MSGPACK_VERSIONING_HPP diff --git a/src/msgpack/vrefbuffer.h b/include/msgpack/vrefbuffer.h similarity index 70% rename from src/msgpack/vrefbuffer.h rename to include/msgpack/vrefbuffer.h index 23022a84..e16e9051 100644 --- a/src/msgpack/vrefbuffer.h +++ b/include/msgpack/vrefbuffer.h @@ -15,8 +15,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#ifndef MSGPACK_VREFBUFFER_H__ -#define MSGPACK_VREFBUFFER_H__ +#ifndef MSGPACK_VREFBUFFER_H +#define MSGPACK_VREFBUFFER_H #include "zone.h" #include @@ -25,8 +25,8 @@ #include #else struct iovec { - void *iov_base; - size_t iov_len; + void *iov_base; + size_t iov_len; }; #endif @@ -45,20 +45,20 @@ struct msgpack_vrefbuffer_chunk; typedef struct msgpack_vrefbuffer_chunk msgpack_vrefbuffer_chunk; typedef struct msgpack_vrefbuffer_inner_buffer { - size_t free; - char* ptr; - msgpack_vrefbuffer_chunk* head; + size_t free; + char* ptr; + msgpack_vrefbuffer_chunk* head; } msgpack_vrefbuffer_inner_buffer; typedef struct msgpack_vrefbuffer { - struct iovec* tail; - struct iovec* end; - struct iovec* array; + struct iovec* tail; + struct iovec* end; + struct iovec* array; - size_t chunk_size; - size_t ref_size; + size_t chunk_size; + size_t ref_size; - msgpack_vrefbuffer_inner_buffer inner_buffer; + msgpack_vrefbuffer_inner_buffer inner_buffer; } msgpack_vrefbuffer; @@ -71,7 +71,7 @@ typedef struct msgpack_vrefbuffer { #endif bool msgpack_vrefbuffer_init(msgpack_vrefbuffer* vbuf, - size_t ref_size, size_t chunk_size); + size_t ref_size, size_t chunk_size); void msgpack_vrefbuffer_destroy(msgpack_vrefbuffer* vbuf); static inline msgpack_vrefbuffer* msgpack_vrefbuffer_new(size_t ref_size, size_t chunk_size); @@ -83,10 +83,10 @@ static inline const struct iovec* msgpack_vrefbuffer_vec(const msgpack_vrefbuffe static inline size_t msgpack_vrefbuffer_veclen(const msgpack_vrefbuffer* vref); int msgpack_vrefbuffer_append_copy(msgpack_vrefbuffer* vbuf, - const char* buf, size_t len); + const char* buf, size_t len); int msgpack_vrefbuffer_append_ref(msgpack_vrefbuffer* vbuf, - const char* buf, size_t len); + const char* buf, size_t len); int msgpack_vrefbuffer_migrate(msgpack_vrefbuffer* vbuf, msgpack_vrefbuffer* to); @@ -97,41 +97,41 @@ void msgpack_vrefbuffer_clear(msgpack_vrefbuffer* vref); static inline msgpack_vrefbuffer* msgpack_vrefbuffer_new(size_t ref_size, size_t chunk_size) { - msgpack_vrefbuffer* vbuf = (msgpack_vrefbuffer*)malloc(sizeof(msgpack_vrefbuffer)); - if (vbuf == NULL) return NULL; - if(!msgpack_vrefbuffer_init(vbuf, ref_size, chunk_size)) { - free(vbuf); - return NULL; - } - return vbuf; + msgpack_vrefbuffer* vbuf = (msgpack_vrefbuffer*)malloc(sizeof(msgpack_vrefbuffer)); + if (vbuf == NULL) return NULL; + if(!msgpack_vrefbuffer_init(vbuf, ref_size, chunk_size)) { + free(vbuf); + return NULL; + } + return vbuf; } static inline void msgpack_vrefbuffer_free(msgpack_vrefbuffer* vbuf) { - if(vbuf == NULL) { return; } - msgpack_vrefbuffer_destroy(vbuf); - free(vbuf); + if(vbuf == NULL) { return; } + msgpack_vrefbuffer_destroy(vbuf); + free(vbuf); } static inline int msgpack_vrefbuffer_write(void* data, const char* buf, size_t len) { - msgpack_vrefbuffer* vbuf = (msgpack_vrefbuffer*)data; + msgpack_vrefbuffer* vbuf = (msgpack_vrefbuffer*)data; - if(len < vbuf->ref_size) { - return msgpack_vrefbuffer_append_copy(vbuf, buf, len); - } else { - return msgpack_vrefbuffer_append_ref(vbuf, buf, len); - } + if(len < vbuf->ref_size) { + return msgpack_vrefbuffer_append_copy(vbuf, buf, len); + } else { + return msgpack_vrefbuffer_append_ref(vbuf, buf, len); + } } static inline const struct iovec* msgpack_vrefbuffer_vec(const msgpack_vrefbuffer* vref) { - return vref->array; + return vref->array; } static inline size_t msgpack_vrefbuffer_veclen(const msgpack_vrefbuffer* vref) { - return (size_t)(vref->tail - vref->array); + return (size_t)(vref->tail - vref->array); } diff --git a/include/msgpack/vrefbuffer.hpp b/include/msgpack/vrefbuffer.hpp new file mode 100644 index 00000000..28cd31ca --- /dev/null +++ b/include/msgpack/vrefbuffer.hpp @@ -0,0 +1,285 @@ +// +// MessagePack for C++ zero-copy buffer implementation +// +// 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_VREFBUFFER_HPP +#define MSGPACK_VREFBUFFER_HPP + +#include "msgpack/versioning.hpp" + +#include + +#ifndef MSGPACK_VREFBUFFER_REF_SIZE +#define MSGPACK_VREFBUFFER_REF_SIZE 32 +#endif + +#ifndef MSGPACK_VREFBUFFER_CHUNK_SIZE +#define MSGPACK_VREFBUFFER_CHUNK_SIZE 8192 +#endif + +#ifndef _WIN32 +#include +#else +struct iovec { + void *iov_base; + size_t iov_len; +}; +#endif + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +namespace detail { + // int64, uint64, double + std::size_t const packer_max_buffer_size = 9; +} // detail + +class vrefbuffer { +private: + struct chunk { + chunk* next; + }; + struct inner_buffer { + size_t free; + char* ptr; + chunk* head; + }; +public: + vrefbuffer(size_t ref_size = MSGPACK_VREFBUFFER_REF_SIZE, + size_t chunk_size = MSGPACK_VREFBUFFER_CHUNK_SIZE) + :m_ref_size(std::max(ref_size, detail::packer_max_buffer_size + 1)), + m_chunk_size(chunk_size) + { + size_t nfirst = (sizeof(iovec) < 72/2) ? + 72 / sizeof(iovec) : 8; + + iovec* array = static_cast(::malloc( + sizeof(iovec) * nfirst)); + if(!array) { + throw std::bad_alloc(); + } + + m_tail = array; + m_end = array + nfirst; + m_array = array; + + chunk* c = static_cast(::malloc(sizeof(chunk) + chunk_size)); + if(!c) { + ::free(array); + throw std::bad_alloc(); + } + inner_buffer* const ib = &m_inner_buffer; + + ib->free = chunk_size; + ib->ptr = reinterpret_cast(c) + sizeof(chunk); + ib->head = c; + c->next = nullptr; + + } + + ~vrefbuffer() + { + chunk* c = m_inner_buffer.head; + while(true) { + chunk* n = c->next; + ::free(c); + if(n != NULL) { + c = n; + } else { + break; + } + } + ::free(m_array); + } + +public: + void write(const char* buf, size_t len) + { + if(len < m_ref_size) { + append_copy(buf, len); + } else { + append_ref(buf, len); + } + } + + void append_ref(const char* buf, size_t len) + { + if(m_tail == m_end) { + const size_t nused = m_tail - m_array; + const size_t nnext = nused * 2; + + iovec* nvec = static_cast(::realloc( + m_array, sizeof(iovec)*nnext)); + if(!nvec) { + throw std::bad_alloc(); + } + + m_array = nvec; + m_end = nvec + nnext; + m_tail = nvec + nused; + } + + m_tail->iov_base = const_cast(buf); + m_tail->iov_len = len; + ++m_tail; + } + + void append_copy(const char* buf, size_t len) + { + inner_buffer* const ib = &m_inner_buffer; + + if(ib->free < len) { + size_t sz = m_chunk_size; + if(sz < len) { + sz = len; + } + + chunk* c = static_cast(::malloc(sizeof(chunk) + sz)); + if(!c) { + throw std::bad_alloc(); + } + + c->next = ib->head; + ib->head = c; + ib->free = sz; + ib->ptr = reinterpret_cast(c) + sizeof(chunk); + } + + char* m = ib->ptr; + ::memcpy(m, buf, len); + ib->free -= len; + ib->ptr += len; + + if(m_tail != m_array && m == + static_cast( + const_cast((m_tail - 1)->iov_base) + ) + (m_tail - 1)->iov_len) { + (m_tail - 1)->iov_len += len; + return; + } else { + append_ref( m, len); + } + } + + const struct iovec* vector() const + { + return m_array; + } + + size_t vector_size() const + { + return m_tail - m_array; + } + + void migrate(vrefbuffer* to) + { + size_t sz = m_chunk_size; + + chunk* empty = static_cast(::malloc(sizeof(chunk) + sz)); + if(!empty) { + throw std::bad_alloc(); + } + + empty->next = nullptr; + + const size_t nused = m_tail - m_array; + if(to->m_tail + nused < m_end) { + const size_t tosize = to->m_tail - to->m_array; + const size_t reqsize = nused + tosize; + size_t nnext = (to->m_end - to->m_array) * 2; + while(nnext < reqsize) { + nnext *= 2; + } + + iovec* nvec = static_cast(::realloc( + to->m_array, sizeof(iovec)*nnext)); + if(!nvec) { + ::free(empty); + throw std::bad_alloc(); + } + + to->m_array = nvec; + to->m_end = nvec + nnext; + to->m_tail = nvec + tosize; + } + + ::memcpy(to->m_tail, m_array, sizeof(iovec)*nused); + + to->m_tail += nused; + m_tail = m_array; + + + inner_buffer* const ib = &m_inner_buffer; + inner_buffer* const toib = &to->m_inner_buffer; + + chunk* last = ib->head; + while(last->next) { + last = last->next; + } + last->next = toib->head; + toib->head = ib->head; + + if(toib->free < ib->free) { + toib->free = ib->free; + toib->ptr = ib->ptr; + } + + ib->head = empty; + ib->free = sz; + ib->ptr = reinterpret_cast(empty) + sizeof(chunk); + + } + + void clear() + { + chunk* c = m_inner_buffer.head->next; + chunk* n; + while(c) { + n = c->next; + ::free(c); + c = n; + } + + inner_buffer* const ib = &m_inner_buffer; + c = ib->head; + c->next = nullptr; + ib->free = m_chunk_size; + ib->ptr = reinterpret_cast(c) + sizeof(chunk); + + m_tail = m_array; + } + +private: + vrefbuffer(const vrefbuffer&); + +private: + iovec* m_tail; + iovec* m_end; + iovec* m_array; + + size_t m_ref_size; + size_t m_chunk_size; + + inner_buffer m_inner_buffer; + +}; + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif /* msgpack/vrefbuffer.hpp */ diff --git a/src/msgpack/zbuffer.h b/include/msgpack/zbuffer.h similarity index 52% rename from src/msgpack/zbuffer.h rename to include/msgpack/zbuffer.h index 965d389b..dbad72c5 100644 --- a/src/msgpack/zbuffer.h +++ b/include/msgpack/zbuffer.h @@ -15,8 +15,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#ifndef MSGPACK_ZBUFFER_H__ -#define MSGPACK_ZBUFFER_H__ +#ifndef MSGPACK_ZBUFFER_H +#define MSGPACK_ZBUFFER_H #include "sysdep.h" #include @@ -35,17 +35,17 @@ extern "C" { */ typedef struct msgpack_zbuffer { - z_stream stream; - char* data; - size_t init_size; + z_stream stream; + char* data; + size_t init_size; } msgpack_zbuffer; #ifndef MSGPACK_ZBUFFER_INIT_SIZE #define MSGPACK_ZBUFFER_INIT_SIZE 8192 #endif -static inline bool msgpack_zbuffer_init(msgpack_zbuffer* zbuf, - int level, size_t init_size); +static inline bool msgpack_zbuffer_init( + msgpack_zbuffer* zbuf, int level, size_t init_size); static inline void msgpack_zbuffer_destroy(msgpack_zbuffer* zbuf); static inline msgpack_zbuffer* msgpack_zbuffer_new(int level, size_t init_size); @@ -71,130 +71,130 @@ static inline bool msgpack_zbuffer_expand(msgpack_zbuffer* zbuf); bool msgpack_zbuffer_init(msgpack_zbuffer* zbuf, - int level, size_t init_size) + int level, size_t init_size) { - memset(zbuf, 0, sizeof(msgpack_zbuffer)); - zbuf->init_size = init_size; - if(deflateInit(&zbuf->stream, level) != Z_OK) { - free(zbuf->data); - return false; - } - return true; + memset(zbuf, 0, sizeof(msgpack_zbuffer)); + zbuf->init_size = init_size; + if(deflateInit(&zbuf->stream, level) != Z_OK) { + free(zbuf->data); + return false; + } + return true; } void msgpack_zbuffer_destroy(msgpack_zbuffer* zbuf) { - deflateEnd(&zbuf->stream); - free(zbuf->data); + deflateEnd(&zbuf->stream); + free(zbuf->data); } msgpack_zbuffer* msgpack_zbuffer_new(int level, size_t init_size) { - msgpack_zbuffer* zbuf = (msgpack_zbuffer*)malloc(sizeof(msgpack_zbuffer)); - if (zbuf == NULL) return NULL; - if(!msgpack_zbuffer_init(zbuf, level, init_size)) { - free(zbuf); - return NULL; - } - return zbuf; + msgpack_zbuffer* zbuf = (msgpack_zbuffer*)malloc(sizeof(msgpack_zbuffer)); + if (zbuf == NULL) return NULL; + if(!msgpack_zbuffer_init(zbuf, level, init_size)) { + free(zbuf); + return NULL; + } + return zbuf; } void msgpack_zbuffer_free(msgpack_zbuffer* zbuf) { - if(zbuf == NULL) { return; } - msgpack_zbuffer_destroy(zbuf); - free(zbuf); + if(zbuf == NULL) { return; } + msgpack_zbuffer_destroy(zbuf); + free(zbuf); } bool msgpack_zbuffer_expand(msgpack_zbuffer* zbuf) { - size_t used = (char*)zbuf->stream.next_out - zbuf->data; - size_t csize = used + zbuf->stream.avail_out; - size_t nsize = (csize == 0) ? zbuf->init_size : csize * 2; + size_t used = (char*)zbuf->stream.next_out - zbuf->data; + size_t csize = used + zbuf->stream.avail_out; + size_t nsize = (csize == 0) ? zbuf->init_size : csize * 2; - char* tmp = (char*)realloc(zbuf->data, nsize); - if(tmp == NULL) { - return false; - } + char* tmp = (char*)realloc(zbuf->data, nsize); + if(tmp == NULL) { + return false; + } - zbuf->data = tmp; - zbuf->stream.next_out = (Bytef*)(tmp + used); - zbuf->stream.avail_out = nsize - used; + zbuf->data = tmp; + zbuf->stream.next_out = (Bytef*)(tmp + used); + zbuf->stream.avail_out = nsize - used; - return true; + return true; } int msgpack_zbuffer_write(void* data, const char* buf, size_t len) { - msgpack_zbuffer* zbuf = (msgpack_zbuffer*)data; + msgpack_zbuffer* zbuf = (msgpack_zbuffer*)data; - zbuf->stream.next_in = (Bytef*)buf; - zbuf->stream.avail_in = len; + zbuf->stream.next_in = (Bytef*)buf; + zbuf->stream.avail_in = len; - do { - if(zbuf->stream.avail_out < MSGPACK_ZBUFFER_RESERVE_SIZE) { - if(!msgpack_zbuffer_expand(zbuf)) { - return -1; - } - } + do { + if(zbuf->stream.avail_out < MSGPACK_ZBUFFER_RESERVE_SIZE) { + if(!msgpack_zbuffer_expand(zbuf)) { + return -1; + } + } - if(deflate(&zbuf->stream, Z_NO_FLUSH) != Z_OK) { - return -1; - } - } while(zbuf->stream.avail_in > 0); + if(deflate(&zbuf->stream, Z_NO_FLUSH) != Z_OK) { + return -1; + } + } while(zbuf->stream.avail_in > 0); - return 0; + return 0; } char* msgpack_zbuffer_flush(msgpack_zbuffer* zbuf) { - while(true) { - switch(deflate(&zbuf->stream, Z_FINISH)) { - case Z_STREAM_END: - return zbuf->data; - case Z_OK: - if(!msgpack_zbuffer_expand(zbuf)) { - return NULL; - } - break; - default: - return NULL; - } - } + while(true) { + switch(deflate(&zbuf->stream, Z_FINISH)) { + case Z_STREAM_END: + return zbuf->data; + case Z_OK: + if(!msgpack_zbuffer_expand(zbuf)) { + return NULL; + } + break; + default: + return NULL; + } + } } const char* msgpack_zbuffer_data(const msgpack_zbuffer* zbuf) { - return zbuf->data; + return zbuf->data; } size_t msgpack_zbuffer_size(const msgpack_zbuffer* zbuf) { - return (char*)zbuf->stream.next_out - zbuf->data; + return (char*)zbuf->stream.next_out - zbuf->data; } void msgpack_zbuffer_reset_buffer(msgpack_zbuffer* zbuf) { - zbuf->stream.avail_out += (char*)zbuf->stream.next_out - zbuf->data; - zbuf->stream.next_out = (Bytef*)zbuf->data; + zbuf->stream.avail_out += (char*)zbuf->stream.next_out - zbuf->data; + zbuf->stream.next_out = (Bytef*)zbuf->data; } bool msgpack_zbuffer_reset(msgpack_zbuffer* zbuf) { - if(deflateReset(&zbuf->stream) != Z_OK) { - return false; - } - msgpack_zbuffer_reset_buffer(zbuf); - return true; + if(deflateReset(&zbuf->stream) != Z_OK) { + return false; + } + msgpack_zbuffer_reset_buffer(zbuf); + return true; } char* msgpack_zbuffer_release_buffer(msgpack_zbuffer* zbuf) { - char* tmp = zbuf->data; - zbuf->data = NULL; - zbuf->stream.next_out = NULL; - zbuf->stream.avail_out = 0; - return tmp; + char* tmp = zbuf->data; + zbuf->data = NULL; + zbuf->stream.next_out = NULL; + zbuf->stream.avail_out = 0; + return tmp; } /** @} */ diff --git a/include/msgpack/zbuffer.hpp b/include/msgpack/zbuffer.hpp new file mode 100644 index 00000000..43a9d77b --- /dev/null +++ b/include/msgpack/zbuffer.hpp @@ -0,0 +1,165 @@ +// +// MessagePack for C++ deflate buffer implementation +// +// Copyright (C) 2010-2013 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// 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_ZBUFFER_HPP +#define MSGPACK_ZBUFFER_HPP + +#include "msgpack/versioning.hpp" + +#include +#include + +#ifndef MSGPACK_ZBUFFER_RESERVE_SIZE +#define MSGPACK_ZBUFFER_RESERVE_SIZE 512 +#endif + +#ifndef MSGPACK_ZBUFFER_INIT_SIZE +#define MSGPACK_ZBUFFER_INIT_SIZE 8192 +#endif + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +class zbuffer { +public: + zbuffer(int level = Z_DEFAULT_COMPRESSION, + size_t init_size = MSGPACK_ZBUFFER_INIT_SIZE) + : m_data(nullptr), m_init_size(init_size) + { + m_stream.zalloc = Z_NULL; + m_stream.zfree = Z_NULL; + m_stream.opaque = Z_NULL; + m_stream.next_out = Z_NULL; + m_stream.avail_out = 0; + if(deflateInit(&m_stream, level) != Z_OK) { + throw std::bad_alloc(); + } + } + + ~zbuffer() + { + deflateEnd(&m_stream); + ::free(m_data); + } + +public: + void write(const char* buf, size_t len) + { + m_stream.next_in = reinterpret_cast(const_cast(buf)); + m_stream.avail_in = len; + + do { + if(m_stream.avail_out < MSGPACK_ZBUFFER_RESERVE_SIZE) { + if(!expand()) { + throw std::bad_alloc(); + } + } + + if(deflate(&m_stream, Z_NO_FLUSH) != Z_OK) { + throw std::bad_alloc(); + } + } while(m_stream.avail_in > 0); + } + + char* flush() + { + while(true) { + switch(deflate(&m_stream, Z_FINISH)) { + case Z_STREAM_END: + return m_data; + case Z_OK: + if(!expand()) { + throw std::bad_alloc(); + } + break; + default: + throw std::bad_alloc(); + } + } + } + + char* data() + { + return m_data; + } + + const char* data() const + { + return m_data; + } + + size_t size() const + { + return reinterpret_cast(m_stream.next_out) - m_data; + } + + void reset() + { + if(deflateReset(&m_stream) != Z_OK) { + throw std::bad_alloc(); + } + reset_buffer(); + } + + void reset_buffer() + { + m_stream.avail_out += reinterpret_cast(m_stream.next_out) - m_data; + m_stream.next_out = reinterpret_cast(m_data); + } + + char* release_buffer() + { + char* tmp = m_data; + m_data = nullptr; + m_stream.next_out = nullptr; + m_stream.avail_out = 0; + return tmp; + } + +private: + bool expand() + { + size_t used = reinterpret_cast(m_stream.next_out) - m_data; + size_t csize = used + m_stream.avail_out; + size_t nsize = (csize == 0) ? m_init_size : csize * 2; + + char* tmp = static_cast(::realloc(m_data, nsize)); + if(tmp == nullptr) { + return false; + } + + m_data = tmp; + m_stream.next_out = reinterpret_cast(tmp + used); + m_stream.avail_out = nsize - used; + + return true; + } +private: + zbuffer(const zbuffer&); + +private: + z_stream m_stream; + char* m_data; + size_t m_init_size; +}; + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif /* msgpack/zbuffer.hpp */ diff --git a/src/msgpack/zone.h b/include/msgpack/zone.h similarity index 66% rename from src/msgpack/zone.h rename to include/msgpack/zone.h index aa2a1470..177750af 100644 --- a/src/msgpack/zone.h +++ b/include/msgpack/zone.h @@ -15,8 +15,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#ifndef MSGPACK_ZONE_H__ -#define MSGPACK_ZONE_H__ +#ifndef MSGPACK_ZONE_H +#define MSGPACK_ZONE_H #include "sysdep.h" @@ -32,29 +32,29 @@ extern "C" { */ typedef struct msgpack_zone_finalizer { - void (*func)(void* data); - void* data; + void (*func)(void* data); + void* data; } msgpack_zone_finalizer; typedef struct msgpack_zone_finalizer_array { - msgpack_zone_finalizer* tail; - msgpack_zone_finalizer* end; - msgpack_zone_finalizer* array; + msgpack_zone_finalizer* tail; + msgpack_zone_finalizer* end; + msgpack_zone_finalizer* array; } msgpack_zone_finalizer_array; struct msgpack_zone_chunk; typedef struct msgpack_zone_chunk msgpack_zone_chunk; typedef struct msgpack_zone_chunk_list { - size_t free; - char* ptr; - msgpack_zone_chunk* head; + size_t free; + char* ptr; + msgpack_zone_chunk* head; } msgpack_zone_chunk_list; typedef struct msgpack_zone { - msgpack_zone_chunk_list chunk_list; - msgpack_zone_finalizer_array finalizer_array; - size_t chunk_size; + msgpack_zone_chunk_list chunk_list; + msgpack_zone_finalizer_array finalizer_array; + size_t chunk_size; } msgpack_zone; #ifndef MSGPACK_ZONE_CHUNK_SIZE @@ -71,7 +71,7 @@ static inline void* msgpack_zone_malloc(msgpack_zone* zone, size_t size); static inline void* msgpack_zone_malloc_no_align(msgpack_zone* zone, size_t size); static inline bool msgpack_zone_push_finalizer(msgpack_zone* zone, - void (*func)(void* data), void* data); + void (*func)(void* data), void* data); static inline void msgpack_zone_swap(msgpack_zone* a, msgpack_zone* b); @@ -90,53 +90,53 @@ void* msgpack_zone_malloc_expand(msgpack_zone* zone, size_t size); void* msgpack_zone_malloc_no_align(msgpack_zone* zone, size_t size) { - char* ptr; - msgpack_zone_chunk_list* cl = &zone->chunk_list; + char* ptr; + msgpack_zone_chunk_list* cl = &zone->chunk_list; - if(zone->chunk_list.free < size) { - return msgpack_zone_malloc_expand(zone, size); - } + if(zone->chunk_list.free < size) { + return msgpack_zone_malloc_expand(zone, size); + } - ptr = cl->ptr; - cl->free -= size; - cl->ptr += size; + ptr = cl->ptr; + cl->free -= size; + cl->ptr += size; - return ptr; + return ptr; } static inline void* msgpack_zone_malloc(msgpack_zone* zone, size_t size) { - return msgpack_zone_malloc_no_align(zone, - ((size)+((MSGPACK_ZONE_ALIGN)-1)) & ~((MSGPACK_ZONE_ALIGN)-1)); + return msgpack_zone_malloc_no_align(zone, + ((size)+((MSGPACK_ZONE_ALIGN)-1)) & ~((MSGPACK_ZONE_ALIGN)-1)); } bool msgpack_zone_push_finalizer_expand(msgpack_zone* zone, - void (*func)(void* data), void* data); + void (*func)(void* data), void* data); static inline bool msgpack_zone_push_finalizer(msgpack_zone* zone, - void (*func)(void* data), void* data) + void (*func)(void* data), void* data) { - msgpack_zone_finalizer_array* const fa = &zone->finalizer_array; - msgpack_zone_finalizer* fin = fa->tail; + msgpack_zone_finalizer_array* const fa = &zone->finalizer_array; + msgpack_zone_finalizer* fin = fa->tail; - if(fin == fa->end) { - return msgpack_zone_push_finalizer_expand(zone, func, data); - } + if(fin == fa->end) { + return msgpack_zone_push_finalizer_expand(zone, func, data); + } - fin->func = func; - fin->data = data; + fin->func = func; + fin->data = data; - ++fa->tail; + ++fa->tail; - return true; + return true; } static inline void msgpack_zone_swap(msgpack_zone* a, msgpack_zone* b) { - msgpack_zone tmp = *a; - *a = *b; - *b = tmp; + msgpack_zone tmp = *a; + *a = *b; + *b = tmp; } diff --git a/include/msgpack/zone.hpp b/include/msgpack/zone.hpp new file mode 100644 index 00000000..9a23af9e --- /dev/null +++ b/include/msgpack/zone.hpp @@ -0,0 +1,29 @@ +// +// MessagePack for C++ memory pool +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_ZONE_HPP +#define MSGPACK_ZONE_HPP + +#include "msgpack/cpp_config.hpp" + +#if defined(MSGPACK_USE_CPP03) +#include "detail/cpp03_zone.hpp" +#else // MSGPACK_USE_CPP03 +#include "detail/cpp11_zone.hpp" +#endif // MSGPACK_USE_CPP03 + +#endif // MSGPACK_ZONE_HPP diff --git a/include/msgpack_fwd.hpp b/include/msgpack_fwd.hpp new file mode 100644 index 00000000..f42ae169 --- /dev/null +++ b/include/msgpack_fwd.hpp @@ -0,0 +1,27 @@ +/* + * MessagePack for C++ version switcher + * + * Copyright (C) 2014 KONDO Takatoshi + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef MSGPACK_FWD_HPP +#define MSGPACK_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/zone.hpp" +#include "msgpack/object_fwd.hpp" +#include "msgpack/adaptor/define.hpp" +#include "msgpack/pack.hpp" + +#endif // MSGPACK_FWD_HPP diff --git a/preprocess b/preprocess index 96280d59..e25eff3f 100755 --- a/preprocess +++ b/preprocess @@ -8,10 +8,11 @@ preprocess() { echo "" exit 1 else - mv $1.tmp $1 + mv $1.tmp $2 fi } -preprocess src/msgpack/type/tuple.hpp -preprocess src/msgpack/type/define.hpp -preprocess src/msgpack/zone.hpp +preprocess erb/cpp03_msgpack_tuple.hpp include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp +preprocess erb/cpp03_msgpack_tuple_fwd.hpp include/msgpack/adaptor/detail/cpp03_msgpack_tuple_fwd.hpp +preprocess erb/cpp03_define.hpp include/msgpack/adaptor/detail/cpp03_define.hpp +preprocess erb/cpp03_zone.hpp include/msgpack/detail/cpp03_zone.hpp diff --git a/src/Makefile.am b/src/Makefile.am index 37993f26..2c1ba1d7 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -1,6 +1,7 @@ - lib_LTLIBRARIES = libmsgpack.la +AM_CPPFLAGS = -I../include + libmsgpack_la_SOURCES = \ unpack.c \ objectc.c \ @@ -8,19 +9,13 @@ libmsgpack_la_SOURCES = \ vrefbuffer.c \ zone.c -if ENABLE_CXX -libmsgpack_la_SOURCES += \ - object.cpp -endif - if ENABLE_GCC_CXX_ATOMIC -libmsgpack_la_SOURCES += \ - gcc_atomic.cpp + CXXFLAGS="$CXXFLAGS -DENABLE_GCC_CXX_ATOMIC" endif # -version-info CURRENT:REVISION:AGE -libmsgpack_la_LDFLAGS = -version-info 3:0:0 -no-undefined +libmsgpack_la_LDFLAGS = -version-info 4:0:0 -no-undefined # backward compatibility @@ -37,58 +32,100 @@ libmsgpackc_la_LDFLAGS = -version-info 2:0:0 -no-undefined nobase_include_HEADERS = \ - msgpack/pack_define.h \ - msgpack/pack_template.h \ - msgpack/unpack_define.h \ - msgpack/unpack_template.h \ - msgpack/sysdep.h \ - msgpack.h \ - msgpack/sbuffer.h \ - msgpack/version.h \ - msgpack/vrefbuffer.h \ - msgpack/zbuffer.h \ - msgpack/fbuffer.h \ - msgpack/pack.h \ - msgpack/unpack.h \ - msgpack/object.h \ - msgpack/zone.h + ../include/msgpack/pack_define.h \ + ../include/msgpack/pack_template.h \ + ../include/msgpack/unpack_define.h \ + ../include/msgpack/unpack_template.h \ + ../include/msgpack/util.h \ + ../include/msgpack/sysdep.h \ + ../include/msgpack.h \ + ../include/msgpack/sbuffer.h \ + ../include/msgpack/version.h \ + ../include/msgpack/version_master.h \ + ../include/msgpack/vrefbuffer.h \ + ../include/msgpack/zbuffer.h \ + ../include/msgpack/fbuffer.h \ + ../include/msgpack/pack.h \ + ../include/msgpack/unpack.h \ + ../include/msgpack/object.h \ + ../include/msgpack/zone.h if ENABLE_CXX nobase_include_HEADERS += \ - msgpack.hpp \ - msgpack/sbuffer.hpp \ - msgpack/vrefbuffer.hpp \ - msgpack/zbuffer.hpp \ - msgpack/fbuffer.hpp \ - msgpack/pack.hpp \ - msgpack/unpack.hpp \ - msgpack/object.hpp \ - msgpack/zone.hpp \ - msgpack/type.hpp \ - msgpack/type/bool.hpp \ - msgpack/type/deque.hpp \ - msgpack/type/float.hpp \ - msgpack/type/fixint.hpp \ - msgpack/type/int.hpp \ - msgpack/type/list.hpp \ - msgpack/type/map.hpp \ - msgpack/type/nil.hpp \ - msgpack/type/pair.hpp \ - msgpack/type/raw.hpp \ - msgpack/type/set.hpp \ - msgpack/type/string.hpp \ - msgpack/type/vector.hpp \ - msgpack/type/tuple.hpp \ - msgpack/type/define.hpp \ - msgpack/type/tr1/unordered_map.hpp \ - msgpack/type/tr1/unordered_set.hpp + ../include/msgpack.hpp \ + ../include/msgpack_fwd.hpp \ + ../include/msgpack/adaptor/bool.hpp \ + ../include/msgpack/adaptor/bool_fwd.hpp \ + ../include/msgpack/adaptor/char_ptr.hpp \ + ../include/msgpack/adaptor/char_ptr_fwd.hpp \ + ../include/msgpack/adaptor/cpp11/array.hpp \ + ../include/msgpack/adaptor/cpp11/array_fwd.hpp \ + ../include/msgpack/adaptor/cpp11/array_char.hpp \ + ../include/msgpack/adaptor/cpp11/array_char_fwd.hpp \ + ../include/msgpack/adaptor/cpp11/forward_list.hpp \ + ../include/msgpack/adaptor/cpp11/forward_list_fwd.hpp \ + ../include/msgpack/adaptor/cpp11/tuple.hpp \ + ../include/msgpack/adaptor/cpp11/tuple_fwd.hpp \ + ../include/msgpack/adaptor/define.hpp \ + ../include/msgpack/adaptor/deque.hpp \ + ../include/msgpack/adaptor/deque_fwd.hpp \ + ../include/msgpack/adaptor/detail/cpp03_define.hpp \ + ../include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp \ + ../include/msgpack/adaptor/detail/cpp03_msgpack_tuple_fwd.hpp \ + ../include/msgpack/adaptor/detail/cpp11_define.hpp \ + ../include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp \ + ../include/msgpack/adaptor/detail/cpp11_msgpack_tuple_fwd.hpp \ + ../include/msgpack/adaptor/fixint.hpp \ + ../include/msgpack/adaptor/fixint_fwd.hpp \ + ../include/msgpack/adaptor/float.hpp \ + ../include/msgpack/adaptor/float_fwd.hpp \ + ../include/msgpack/adaptor/int.hpp \ + ../include/msgpack/adaptor/int_fwd.hpp \ + ../include/msgpack/adaptor/list.hpp \ + ../include/msgpack/adaptor/list_fwd.hpp \ + ../include/msgpack/adaptor/map.hpp \ + ../include/msgpack/adaptor/map_fwd.hpp \ + ../include/msgpack/adaptor/msgpack_tuple.hpp \ + ../include/msgpack/adaptor/msgpack_tuple_fwd.hpp \ + ../include/msgpack/adaptor/nil.hpp \ + ../include/msgpack/adaptor/nil_fwd.hpp \ + ../include/msgpack/adaptor/pair.hpp \ + ../include/msgpack/adaptor/pair_fwd.hpp \ + ../include/msgpack/adaptor/raw.hpp \ + ../include/msgpack/adaptor/raw_fwd.hpp \ + ../include/msgpack/adaptor/set.hpp \ + ../include/msgpack/adaptor/set_fwd.hpp \ + ../include/msgpack/adaptor/string.hpp \ + ../include/msgpack/adaptor/string_fwd.hpp \ + ../include/msgpack/adaptor/tr1/unordered_map.hpp \ + ../include/msgpack/adaptor/tr1/unordered_map_fwd.hpp \ + ../include/msgpack/adaptor/tr1/unordered_set.hpp \ + ../include/msgpack/adaptor/tr1/unordered_set_fwd.hpp \ + ../include/msgpack/adaptor/vector.hpp \ + ../include/msgpack/adaptor/vector_fwd.hpp \ + ../include/msgpack/adaptor/vector_char.hpp \ + ../include/msgpack/adaptor/vector_char_fwd.hpp \ + ../include/msgpack/cpp_config.hpp \ + ../include/msgpack/detail/cpp03_zone.hpp \ + ../include/msgpack/detail/cpp11_zone.hpp \ + ../include/msgpack/fbuffer.hpp \ + ../include/msgpack/object.hpp \ + ../include/msgpack/object_fwd.hpp \ + ../include/msgpack/pack.hpp \ + ../include/msgpack/sbuffer.hpp \ + ../include/msgpack/type.hpp \ + ../include/msgpack/unpack.hpp \ + ../include/msgpack/version.hpp \ + ../include/msgpack/versioning.hpp \ + ../include/msgpack/vrefbuffer.hpp \ + ../include/msgpack/zbuffer.hpp \ + ../include/msgpack/zone.hpp endif EXTRA_DIST = \ - msgpack/version.h.in \ - msgpack/zone.hpp.erb \ - msgpack/type/define.hpp.erb \ - msgpack/type/tuple.hpp.erb + ../erb/cpp03_zone.hpp.erb \ + ../erb/cpp03_define.hpp.erb \ + ../erb/cpp03_msgpack_tuple.hpp.erb doxygen_c: @@ -106,4 +143,3 @@ doxygen_cpp: doxygen Doxyfile_cpp doxygen: doxygen_c doxygen_cpp - diff --git a/src/gcc_atomic.cpp b/src/gcc_atomic.hpp similarity index 67% rename from src/gcc_atomic.cpp rename to src/gcc_atomic.hpp index 4389d0e8..7e6dc00d 100644 --- a/src/gcc_atomic.cpp +++ b/src/gcc_atomic.hpp @@ -1,7 +1,7 @@ // -// MessagePack for C++ atomic operations +// MessagePack for C++ old gcc workaround for atomic operation // -// Copyright (C) 2008-2013 FURUHASHI Sadayuki +// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -16,20 +16,26 @@ // limitations under the License. // +#ifndef MSGPACK_GCC_ATOMIC_HPP +#define MSGPACK_GCC_ATOMIC_HPP + +#ifdef ENABLE_GCC_CXX_ATOMIC #if defined(__GNUC__) && ((__GNUC__*10 + __GNUC_MINOR__) < 41) -#include "gcc_atomic.h" +#include "msgpack/gcc_atomic.h" #include int _msgpack_sync_decr_and_fetch(volatile _msgpack_atomic_counter_t* ptr) { - return __gnu_cxx::__exchange_and_add(ptr, -1) - 1; + return __gnu_cxx::__exchange_and_add(ptr, -1) - 1; } int _msgpack_sync_incr_and_fetch(volatile _msgpack_atomic_counter_t* ptr) { - return __gnu_cxx::__exchange_and_add(ptr, 1) + 1; + return __gnu_cxx::__exchange_and_add(ptr, 1) + 1; } - #endif // old gcc workaround +#endif // ENABLE_GCC_CXX_ATOMIC + +#endif /* gcc_atomic.hpp */ diff --git a/src/msgpack/object.hpp b/src/msgpack/object.hpp deleted file mode 100644 index 8c160eaf..00000000 --- a/src/msgpack/object.hpp +++ /dev/null @@ -1,480 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2008-2010 FURUHASHI Sadayuki -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_OBJECT_HPP__ -#define MSGPACK_OBJECT_HPP__ - -#include "object.h" -#include "pack.hpp" -#include "zone.hpp" -#include -#include -#include -#include -#include - -namespace msgpack { - - -class type_error : public std::bad_cast { }; - - -namespace type { - enum object_type { - NIL = MSGPACK_OBJECT_NIL, - BOOLEAN = MSGPACK_OBJECT_BOOLEAN, - POSITIVE_INTEGER = MSGPACK_OBJECT_POSITIVE_INTEGER, - NEGATIVE_INTEGER = MSGPACK_OBJECT_NEGATIVE_INTEGER, - DOUBLE = MSGPACK_OBJECT_DOUBLE, - RAW = MSGPACK_OBJECT_RAW, - ARRAY = MSGPACK_OBJECT_ARRAY, - MAP = MSGPACK_OBJECT_MAP, - }; -} - - -struct object; -struct object_kv; - -struct object_array { - uint32_t size; - object* ptr; -}; - -struct object_map { - uint32_t size; - object_kv* ptr; -}; - -struct object_raw { - uint32_t size; - const char* ptr; -}; - -struct object { - union union_type { - bool boolean; - uint64_t u64; - int64_t i64; - double dec; - object_array array; - object_map map; - object_raw raw; - object_raw ref; // obsolete - }; - - type::object_type type; - union_type via; - - bool is_nil() const { return type == type::NIL; } - - template - T as() const; - - template - void convert(T* v) const; - - object(); - - object(msgpack_object o); - - template - explicit object(const T& v); - - template - object(const T& v, zone* z); - - template - object& operator=(const T& v); - - operator msgpack_object() const; - - struct with_zone; - -private: - struct implicit_type; - -public: - implicit_type convert() const; -}; - -struct object_kv { - object key; - object val; -}; - -struct object::with_zone : object { - with_zone(msgpack::zone* zone) : zone(zone) { } - msgpack::zone* zone; -private: - with_zone(); -}; - - -bool operator==(const object x, const object y); -bool operator!=(const object x, const object y); - -template -bool operator==(const object x, const T& y); - -template -bool operator==(const T& y, const object x); - -template -bool operator!=(const object x, const T& y); - -template -bool operator!=(const T& y, const object x); - -std::ostream& operator<< (std::ostream& s, const object o); - - -// serialize operator -template -packer& operator<< (packer& o, const T& v); - -// convert operator -template -T& operator>> (object o, T& v); - -// deconvert operator -template -void operator<< (object::with_zone& o, const T& v); - - -struct object::implicit_type { - implicit_type(object o) : obj(o) { } - ~implicit_type() { } - - template - operator T() { return obj.as(); } - -private: - object obj; -}; - - -// obsolete -template -class define : public Type { -public: - typedef Type msgpack_type; - typedef define define_type; - - define() {} - define(const msgpack_type& v) : msgpack_type(v) {} - - template - void msgpack_pack(Packer& o) const - { - o << static_cast(*this); - } - - void msgpack_unpack(object o) - { - o >> static_cast(*this); - } -}; - - -template -template -inline packer& packer::pack(const T& v) -{ - *this << v; - return *this; -} - -inline object& operator>> (object o, object& v) -{ - v = o; - return v; -} - -template -inline T& operator>> (object o, T& v) -{ - v.msgpack_unpack(o.convert()); - return v; -} - -namespace detail { -template -struct packer_serializer { - static packer& pack(packer& o, const T& v) { - v.msgpack_pack(o); - return o; - } -}; -} - -template -inline packer& operator<< (packer& o, const T& v) -{ - return detail::packer_serializer::pack(o, v); -} - -template -void operator<< (object::with_zone& o, const T& v) -{ - v.msgpack_object(static_cast(&o), o.zone); -} - -template <> -inline void operator<< (object::with_zone& o, const object& v) -{ - o.type = v.type; - - switch(v.type) { - case type::NIL: - case type::BOOLEAN: - case type::POSITIVE_INTEGER: - case type::NEGATIVE_INTEGER: - case type::DOUBLE: - ::memcpy(&o.via, &v.via, sizeof(v.via)); - return; - - case type::RAW: - o.via.raw.ptr = static_cast(o.zone->malloc(v.via.raw.size)); - o.via.raw.size = v.via.raw.size; - ::memcpy(const_cast(o.via.raw.ptr), v.via.raw.ptr, v.via.raw.size); - return; - - case type::ARRAY: - o.via.array.ptr = static_cast(o.zone->malloc(sizeof(object) * v.via.array.size)); - o.via.array.size = v.via.array.size; - for(object* po(o.via.array.ptr), * pv(v.via.array.ptr), - * const pvend(v.via.array.ptr + v.via.array.size); - pv < pvend; ++po, ++pv) { - new (po) object(*pv, o.zone); - } - return; - - case type::MAP: - o.via.map.ptr = static_cast(o.zone->malloc(sizeof(object_kv) * v.via.map.size)); - o.via.map.size = v.via.map.size; - for(object_kv* po(o.via.map.ptr), * pv(v.via.map.ptr), - * const pvend(v.via.map.ptr + v.via.map.size); - pv < pvend; ++po, ++pv) { - object_kv* kv = new (po) object_kv; - new (&kv->key) object(pv->key, o.zone); - new (&kv->val) object(pv->val, o.zone); - } - return; - - default: - throw type_error(); - } -} - -template <> -inline void operator<< (object::with_zone& o, const object::with_zone& v) -{ - return o << static_cast(v); -} - - -inline bool operator==(const object x, const object y) -{ - return msgpack_object_equal(x, y); -} - -template -inline bool operator==(const object x, const T& y) -try { - return x == object(y); -} catch (msgpack::type_error&) { - return false; -} - -inline bool operator!=(const object x, const object y) -{ return !(x == y); } - -template -inline bool operator==(const T& y, const object x) -{ return x == y; } - -template -inline bool operator!=(const object x, const T& y) -{ return !(x == y); } - -template -inline bool operator!=(const T& y, const object x) -{ return x != y; } - - -inline object::implicit_type object::convert() const -{ - return implicit_type(*this); -} - -template -inline void object::convert(T* v) const -{ - *this >> *v; -} - -template -inline T object::as() const -{ - T v; - convert(&v); - return v; -} - - -inline object::object() -{ - type = type::NIL; -} - -template -inline object::object(const T& v) -{ - *this << v; -} - -template -inline object& object::operator=(const T& v) -{ - *this = object(v); - return *this; -} - -template -object::object(const T& v, zone* z) -{ - with_zone oz(z); - oz << v; - type = oz.type; - via = oz.via; -} - - -inline object::object(msgpack_object o) -{ - // FIXME beter way? - ::memcpy(this, &o, sizeof(o)); -} - -inline void operator<< (object& o, msgpack_object v) -{ - // FIXME beter way? - ::memcpy(&o, &v, sizeof(v)); -} - -inline object::operator msgpack_object() const -{ - // FIXME beter way? - msgpack_object obj; - ::memcpy(&obj, this, sizeof(obj)); - return obj; -} - - -// obsolete -template -inline void convert(T& v, object o) -{ - o.convert(&v); -} - -// obsolete -template -inline void pack(packer& o, const T& v) -{ - o.pack(v); -} - -// obsolete -template -inline void pack_copy(packer& o, T v) -{ - pack(o, v); -} - - -template -packer& operator<< (packer& o, const object& v) -{ - switch(v.type) { - case type::NIL: - o.pack_nil(); - return o; - - case type::BOOLEAN: - if(v.via.boolean) { - o.pack_true(); - } else { - o.pack_false(); - } - return o; - - case type::POSITIVE_INTEGER: - o.pack_uint64(v.via.u64); - return o; - - case type::NEGATIVE_INTEGER: - o.pack_int64(v.via.i64); - return o; - - case type::DOUBLE: - o.pack_double(v.via.dec); - return o; - - case type::RAW: - o.pack_raw(v.via.raw.size); - o.pack_raw_body(v.via.raw.ptr, v.via.raw.size); - return o; - - case type::ARRAY: - o.pack_array(v.via.array.size); - for(object* p(v.via.array.ptr), - * const pend(v.via.array.ptr + v.via.array.size); - p < pend; ++p) { - o << *p; - } - return o; - - case type::MAP: - o.pack_map(v.via.map.size); - for(object_kv* p(v.via.map.ptr), - * const pend(v.via.map.ptr + v.via.map.size); - p < pend; ++p) { - o << p->key; - o << p->val; - } - return o; - - default: - throw type_error(); - } -} - -template -packer& operator<< (packer& o, const object::with_zone& v) -{ - return o << static_cast(v); -} - - -} // namespace msgpack - -#include "msgpack/type.hpp" - -#endif /* msgpack/object.hpp */ - diff --git a/src/msgpack/pack.hpp b/src/msgpack/pack.hpp deleted file mode 100644 index 7507eeff..00000000 --- a/src/msgpack/pack.hpp +++ /dev/null @@ -1,337 +0,0 @@ -// -// MessagePack for C++ serializing routine -// -// Copyright (C) 2008-2010 FURUHASHI Sadayuki -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// 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_PACK_HPP__ -#define MSGPACK_PACK_HPP__ - -#include "pack_define.h" -#include -#include - -namespace msgpack { - - -template -class packer { -public: - packer(Stream* s); - packer(Stream& s); - ~packer(); - -public: - template - packer& pack(const T& v); - - packer& pack_uint8(uint8_t d); - packer& pack_uint16(uint16_t d); - packer& pack_uint32(uint32_t d); - packer& pack_uint64(uint64_t d); - packer& pack_int8(int8_t d); - packer& pack_int16(int16_t d); - packer& pack_int32(int32_t d); - packer& pack_int64(int64_t d); - - packer& pack_fix_uint8(uint8_t d); - packer& pack_fix_uint16(uint16_t d); - packer& pack_fix_uint32(uint32_t d); - packer& pack_fix_uint64(uint64_t d); - packer& pack_fix_int8(int8_t d); - packer& pack_fix_int16(int16_t d); - packer& pack_fix_int32(int32_t d); - packer& pack_fix_int64(int64_t d); - - packer& pack_char(char d); - packer& pack_signed_char(signed char d); - packer& pack_short(short d); - packer& pack_int(int d); - packer& pack_long(long d); - packer& pack_long_long(long long d); - packer& pack_unsigned_char(unsigned char d); - packer& pack_unsigned_short(unsigned short d); - packer& pack_unsigned_int(unsigned int d); - packer& pack_unsigned_long(unsigned long d); - packer& pack_unsigned_long_long(unsigned long long d); - - packer& pack_float(float d); - packer& pack_double(double d); - - packer& pack_nil(); - packer& pack_true(); - packer& pack_false(); - - packer& pack_array(size_t n); - - packer& pack_map(size_t n); - - packer& pack_raw(size_t l); - packer& pack_raw_body(const char* b, size_t l); - -private: - static void _pack_uint8(Stream& x, uint8_t d); - static void _pack_uint16(Stream& x, uint16_t d); - static void _pack_uint32(Stream& x, uint32_t d); - static void _pack_uint64(Stream& x, uint64_t d); - static void _pack_int8(Stream& x, int8_t d); - static void _pack_int16(Stream& x, int16_t d); - static void _pack_int32(Stream& x, int32_t d); - static void _pack_int64(Stream& x, int64_t d); - - static void _pack_fix_uint8(Stream& x, uint8_t d); - static void _pack_fix_uint16(Stream& x, uint16_t d); - static void _pack_fix_uint32(Stream& x, uint32_t d); - static void _pack_fix_uint64(Stream& x, uint64_t d); - static void _pack_fix_int8(Stream& x, int8_t d); - static void _pack_fix_int16(Stream& x, int16_t d); - static void _pack_fix_int32(Stream& x, int32_t d); - static void _pack_fix_int64(Stream& x, int64_t d); - - static void _pack_char(Stream& x, char d); - - static void _pack_signed_char(Stream& x, signed char d); - static void _pack_short(Stream& x, short d); - static void _pack_int(Stream& x, int d); - static void _pack_long(Stream& x, long d); - static void _pack_long_long(Stream& x, long long d); - static void _pack_unsigned_char(Stream& x, unsigned char d); - static void _pack_unsigned_short(Stream& x, unsigned short d); - static void _pack_unsigned_int(Stream& x, unsigned int d); - static void _pack_unsigned_long(Stream& x, unsigned long d); - static void _pack_unsigned_long_long(Stream& x, unsigned long long d); - - static void _pack_float(Stream& x, float d); - static void _pack_double(Stream& x, double d); - - static void _pack_nil(Stream& x); - static void _pack_true(Stream& x); - static void _pack_false(Stream& x); - - static void _pack_array(Stream& x, size_t n); - - static void _pack_map(Stream& x, size_t n); - - static void _pack_raw(Stream& x, size_t l); - static void _pack_raw_body(Stream& x, const void* b, size_t l); - - static void append_buffer(Stream& x, const unsigned char* buf, size_t len) - { x.write((const char*)buf, len); } - -private: - Stream& m_stream; - -private: - packer(); -}; - - -template -inline void pack(Stream* s, const T& v) -{ - packer(s).pack(v); -} - -template -inline void pack(Stream& s, const T& v) -{ - packer(s).pack(v); -} - - -#define msgpack_pack_inline_func(name) \ - template \ - inline void packer::_pack ## name - -#define msgpack_pack_inline_func_cint(name) \ - template \ - inline void packer::_pack ## name - -#define msgpack_pack_inline_func_fixint(name) \ - template \ - inline void packer::_pack_fix ## name - -#define msgpack_pack_user Stream& - -#define msgpack_pack_append_buffer append_buffer - -#include "pack_template.h" - - -template -packer::packer(Stream* s) : m_stream(*s) { } - -template -packer::packer(Stream& s) : m_stream(s) { } - -template -packer::~packer() { } - - -template -inline packer& packer::pack_uint8(uint8_t d) -{ _pack_uint8(m_stream, d); return *this; } - -template -inline packer& packer::pack_uint16(uint16_t d) -{ _pack_uint16(m_stream, d); return *this; } - -template -inline packer& packer::pack_uint32(uint32_t d) -{ _pack_uint32(m_stream, d); return *this; } - -template -inline packer& packer::pack_uint64(uint64_t d) -{ _pack_uint64(m_stream, d); return *this; } - -template -inline packer& packer::pack_int8(int8_t d) -{ _pack_int8(m_stream, d); return *this; } - -template -inline packer& packer::pack_int16(int16_t d) -{ _pack_int16(m_stream, d); return *this; } - -template -inline packer& packer::pack_int32(int32_t d) -{ _pack_int32(m_stream, d); return *this; } - -template -inline packer& packer::pack_int64(int64_t d) -{ _pack_int64(m_stream, d); return *this;} - - -template -inline packer& packer::pack_fix_uint8(uint8_t d) -{ _pack_fix_uint8(m_stream, d); return *this; } - -template -inline packer& packer::pack_fix_uint16(uint16_t d) -{ _pack_fix_uint16(m_stream, d); return *this; } - -template -inline packer& packer::pack_fix_uint32(uint32_t d) -{ _pack_fix_uint32(m_stream, d); return *this; } - -template -inline packer& packer::pack_fix_uint64(uint64_t d) -{ _pack_fix_uint64(m_stream, d); return *this; } - -template -inline packer& packer::pack_fix_int8(int8_t d) -{ _pack_fix_int8(m_stream, d); return *this; } - -template -inline packer& packer::pack_fix_int16(int16_t d) -{ _pack_fix_int16(m_stream, d); return *this; } - -template -inline packer& packer::pack_fix_int32(int32_t d) -{ _pack_fix_int32(m_stream, d); return *this; } - -template -inline packer& packer::pack_fix_int64(int64_t d) -{ _pack_fix_int64(m_stream, d); return *this;} - - -template -inline packer& packer::pack_char(char d) -{ _pack_char(m_stream, d); return *this; } - -template -inline packer& packer::pack_signed_char(signed char d) -{ _pack_signed_char(m_stream, d); return *this; } - -template -inline packer& packer::pack_short(short d) -{ _pack_short(m_stream, d); return *this; } - -template -inline packer& packer::pack_int(int d) -{ _pack_int(m_stream, d); return *this; } - -template -inline packer& packer::pack_long(long d) -{ _pack_long(m_stream, d); return *this; } - -template -inline packer& packer::pack_long_long(long long d) -{ _pack_long_long(m_stream, d); return *this; } - -template -inline packer& packer::pack_unsigned_char(unsigned char d) -{ _pack_unsigned_char(m_stream, d); return *this; } - -template -inline packer& packer::pack_unsigned_short(unsigned short d) -{ _pack_unsigned_short(m_stream, d); return *this; } - -template -inline packer& packer::pack_unsigned_int(unsigned int d) -{ _pack_unsigned_int(m_stream, d); return *this; } - -template -inline packer& packer::pack_unsigned_long(unsigned long d) -{ _pack_unsigned_long(m_stream, d); return *this; } - -template -inline packer& packer::pack_unsigned_long_long(unsigned long long d) -{ _pack_unsigned_long_long(m_stream, d); return *this; } - - -template -inline packer& packer::pack_float(float d) -{ _pack_float(m_stream, d); return *this; } - -template -inline packer& packer::pack_double(double d) -{ _pack_double(m_stream, d); return *this; } - - -template -inline packer& packer::pack_nil() -{ _pack_nil(m_stream); return *this; } - -template -inline packer& packer::pack_true() -{ _pack_true(m_stream); return *this; } - -template -inline packer& packer::pack_false() -{ _pack_false(m_stream); return *this; } - - -template -inline packer& packer::pack_array(size_t n) -{ _pack_array(m_stream, n); return *this; } - - -template -inline packer& packer::pack_map(size_t n) -{ _pack_map(m_stream, n); return *this; } - - -template -inline packer& packer::pack_raw(size_t l) -{ _pack_raw(m_stream, l); return *this; } - -template -inline packer& packer::pack_raw_body(const char* b, size_t l) -{ _pack_raw_body(m_stream, b, l); return *this; } - - -} // namespace msgpack - -#endif /* msgpack/pack.hpp */ - diff --git a/src/msgpack/pack_template.h b/src/msgpack/pack_template.h deleted file mode 100644 index 0c975b47..00000000 --- a/src/msgpack/pack_template.h +++ /dev/null @@ -1,793 +0,0 @@ -/* - * MessagePack packing routine template - * - * Copyright (C) 2008-2010 FURUHASHI Sadayuki - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * 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. - */ - -#if defined(__LITTLE_ENDIAN__) -#define TAKE8_8(d) ((uint8_t*)&d)[0] -#define TAKE8_16(d) ((uint8_t*)&d)[0] -#define TAKE8_32(d) ((uint8_t*)&d)[0] -#define TAKE8_64(d) ((uint8_t*)&d)[0] -#elif defined(__BIG_ENDIAN__) -#define TAKE8_8(d) ((uint8_t*)&d)[0] -#define TAKE8_16(d) ((uint8_t*)&d)[1] -#define TAKE8_32(d) ((uint8_t*)&d)[3] -#define TAKE8_64(d) ((uint8_t*)&d)[7] -#endif - -#ifndef msgpack_pack_inline_func -#error msgpack_pack_inline_func template is not defined -#endif - -#ifndef msgpack_pack_user -#error msgpack_pack_user type is not defined -#endif - -#ifndef msgpack_pack_append_buffer -#error msgpack_pack_append_buffer callback is not defined -#endif - - -/* - * Integer - */ - -#define msgpack_pack_real_uint8(x, d) \ -do { \ - if(d < (1<<7)) { \ - /* fixnum */ \ - msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); \ - } else { \ - /* unsigned 8 */ \ - unsigned char buf[2] = {0xcc, TAKE8_8(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } \ -} while(0) - -#define msgpack_pack_real_uint16(x, d) \ -do { \ - if(d < (1<<7)) { \ - /* fixnum */ \ - msgpack_pack_append_buffer(x, &TAKE8_16(d), 1); \ - } else if(d < (1<<8)) { \ - /* unsigned 8 */ \ - unsigned char buf[2] = {0xcc, TAKE8_16(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } else { \ - /* unsigned 16 */ \ - unsigned char buf[3]; \ - buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ - msgpack_pack_append_buffer(x, buf, 3); \ - } \ -} while(0) - -#define msgpack_pack_real_uint32(x, d) \ -do { \ - if(d < (1<<8)) { \ - if(d < (1<<7)) { \ - /* fixnum */ \ - msgpack_pack_append_buffer(x, &TAKE8_32(d), 1); \ - } else { \ - /* unsigned 8 */ \ - unsigned char buf[2] = {0xcc, TAKE8_32(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } \ - } else { \ - if(d < (1<<16)) { \ - /* unsigned 16 */ \ - unsigned char buf[3]; \ - buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ - msgpack_pack_append_buffer(x, buf, 3); \ - } else { \ - /* unsigned 32 */ \ - unsigned char buf[5]; \ - buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \ - msgpack_pack_append_buffer(x, buf, 5); \ - } \ - } \ -} while(0) - -#define msgpack_pack_real_uint64(x, d) \ -do { \ - if(d < (1ULL<<8)) { \ - if(d < (1ULL<<7)) { \ - /* fixnum */ \ - msgpack_pack_append_buffer(x, &TAKE8_64(d), 1); \ - } else { \ - /* unsigned 8 */ \ - unsigned char buf[2] = {0xcc, TAKE8_64(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } \ - } else { \ - if(d < (1ULL<<16)) { \ - /* unsigned 16 */ \ - unsigned char buf[3]; \ - buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ - msgpack_pack_append_buffer(x, buf, 3); \ - } else if(d < (1ULL<<32)) { \ - /* unsigned 32 */ \ - unsigned char buf[5]; \ - buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \ - msgpack_pack_append_buffer(x, buf, 5); \ - } else { \ - /* unsigned 64 */ \ - unsigned char buf[9]; \ - buf[0] = 0xcf; _msgpack_store64(&buf[1], d); \ - msgpack_pack_append_buffer(x, buf, 9); \ - } \ - } \ -} while(0) - -#define msgpack_pack_real_int8(x, d) \ -do { \ - if(d < -(1<<5)) { \ - /* signed 8 */ \ - unsigned char buf[2] = {0xd0, TAKE8_8(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } else { \ - /* fixnum */ \ - msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); \ - } \ -} while(0) - -#define msgpack_pack_real_int16(x, d) \ -do { \ - if(d < -(1<<5)) { \ - if(d < -(1<<7)) { \ - /* signed 16 */ \ - unsigned char buf[3]; \ - buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \ - msgpack_pack_append_buffer(x, buf, 3); \ - } else { \ - /* signed 8 */ \ - unsigned char buf[2] = {0xd0, TAKE8_16(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } \ - } else if(d < (1<<7)) { \ - /* fixnum */ \ - msgpack_pack_append_buffer(x, &TAKE8_16(d), 1); \ - } else { \ - if(d < (1<<8)) { \ - /* unsigned 8 */ \ - unsigned char buf[2] = {0xcc, TAKE8_16(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } else { \ - /* unsigned 16 */ \ - unsigned char buf[3]; \ - buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ - msgpack_pack_append_buffer(x, buf, 3); \ - } \ - } \ -} while(0) - -#define msgpack_pack_real_int32(x, d) \ -do { \ - if(d < -(1<<5)) { \ - if(d < -(1<<15)) { \ - /* signed 32 */ \ - unsigned char buf[5]; \ - buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); \ - msgpack_pack_append_buffer(x, buf, 5); \ - } else if(d < -(1<<7)) { \ - /* signed 16 */ \ - unsigned char buf[3]; \ - buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \ - msgpack_pack_append_buffer(x, buf, 3); \ - } else { \ - /* signed 8 */ \ - unsigned char buf[2] = {0xd0, TAKE8_32(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } \ - } else if(d < (1<<7)) { \ - /* fixnum */ \ - msgpack_pack_append_buffer(x, &TAKE8_32(d), 1); \ - } else { \ - if(d < (1<<8)) { \ - /* unsigned 8 */ \ - unsigned char buf[2] = {0xcc, TAKE8_32(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } else if(d < (1<<16)) { \ - /* unsigned 16 */ \ - unsigned char buf[3]; \ - buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ - msgpack_pack_append_buffer(x, buf, 3); \ - } else { \ - /* unsigned 32 */ \ - unsigned char buf[5]; \ - buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \ - msgpack_pack_append_buffer(x, buf, 5); \ - } \ - } \ -} while(0) - -#define msgpack_pack_real_int64(x, d) \ -do { \ - if(d < -(1LL<<5)) { \ - if(d < -(1LL<<15)) { \ - if(d < -(1LL<<31)) { \ - /* signed 64 */ \ - unsigned char buf[9]; \ - buf[0] = 0xd3; _msgpack_store64(&buf[1], d); \ - msgpack_pack_append_buffer(x, buf, 9); \ - } else { \ - /* signed 32 */ \ - unsigned char buf[5]; \ - buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); \ - msgpack_pack_append_buffer(x, buf, 5); \ - } \ - } else { \ - if(d < -(1<<7)) { \ - /* signed 16 */ \ - unsigned char buf[3]; \ - buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \ - msgpack_pack_append_buffer(x, buf, 3); \ - } else { \ - /* signed 8 */ \ - unsigned char buf[2] = {0xd0, TAKE8_64(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } \ - } \ - } else if(d < (1<<7)) { \ - /* fixnum */ \ - msgpack_pack_append_buffer(x, &TAKE8_64(d), 1); \ - } else { \ - if(d < (1LL<<16)) { \ - if(d < (1<<8)) { \ - /* unsigned 8 */ \ - unsigned char buf[2] = {0xcc, TAKE8_64(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } else { \ - /* unsigned 16 */ \ - unsigned char buf[3]; \ - buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ - msgpack_pack_append_buffer(x, buf, 3); \ - } \ - } else { \ - if(d < (1LL<<32)) { \ - /* unsigned 32 */ \ - unsigned char buf[5]; \ - buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \ - msgpack_pack_append_buffer(x, buf, 5); \ - } else { \ - /* unsigned 64 */ \ - unsigned char buf[9]; \ - buf[0] = 0xcf; _msgpack_store64(&buf[1], d); \ - msgpack_pack_append_buffer(x, buf, 9); \ - } \ - } \ - } \ -} while(0) - - -#ifdef msgpack_pack_inline_func_fixint - -msgpack_pack_inline_func_fixint(_uint8)(msgpack_pack_user x, uint8_t d) -{ - unsigned char buf[2] = {0xcc, TAKE8_8(d)}; - msgpack_pack_append_buffer(x, buf, 2); -} - -msgpack_pack_inline_func_fixint(_uint16)(msgpack_pack_user x, uint16_t d) -{ - unsigned char buf[3]; - buf[0] = 0xcd; _msgpack_store16(&buf[1], d); - msgpack_pack_append_buffer(x, buf, 3); -} - -msgpack_pack_inline_func_fixint(_uint32)(msgpack_pack_user x, uint32_t d) -{ - unsigned char buf[5]; - buf[0] = 0xce; _msgpack_store32(&buf[1], d); - msgpack_pack_append_buffer(x, buf, 5); -} - -msgpack_pack_inline_func_fixint(_uint64)(msgpack_pack_user x, uint64_t d) -{ - unsigned char buf[9]; - buf[0] = 0xcf; _msgpack_store64(&buf[1], d); - msgpack_pack_append_buffer(x, buf, 9); -} - -msgpack_pack_inline_func_fixint(_int8)(msgpack_pack_user x, int8_t d) -{ - unsigned char buf[2] = {0xd0, TAKE8_8(d)}; - msgpack_pack_append_buffer(x, buf, 2); -} - -msgpack_pack_inline_func_fixint(_int16)(msgpack_pack_user x, int16_t d) -{ - unsigned char buf[3]; - buf[0] = 0xd1; _msgpack_store16(&buf[1], d); - msgpack_pack_append_buffer(x, buf, 3); -} - -msgpack_pack_inline_func_fixint(_int32)(msgpack_pack_user x, int32_t d) -{ - unsigned char buf[5]; - buf[0] = 0xd2; _msgpack_store32(&buf[1], d); - msgpack_pack_append_buffer(x, buf, 5); -} - -msgpack_pack_inline_func_fixint(_int64)(msgpack_pack_user x, int64_t d) -{ - unsigned char buf[9]; - buf[0] = 0xd3; _msgpack_store64(&buf[1], d); - msgpack_pack_append_buffer(x, buf, 9); -} - -#undef msgpack_pack_inline_func_fixint -#endif - - -msgpack_pack_inline_func(_uint8)(msgpack_pack_user x, uint8_t d) -{ - msgpack_pack_real_uint8(x, d); -} - -msgpack_pack_inline_func(_uint16)(msgpack_pack_user x, uint16_t d) -{ - msgpack_pack_real_uint16(x, d); -} - -msgpack_pack_inline_func(_uint32)(msgpack_pack_user x, uint32_t d) -{ - msgpack_pack_real_uint32(x, d); -} - -msgpack_pack_inline_func(_uint64)(msgpack_pack_user x, uint64_t d) -{ - msgpack_pack_real_uint64(x, d); -} - -msgpack_pack_inline_func(_int8)(msgpack_pack_user x, int8_t d) -{ - msgpack_pack_real_int8(x, d); -} - -msgpack_pack_inline_func(_int16)(msgpack_pack_user x, int16_t d) -{ - msgpack_pack_real_int16(x, d); -} - -msgpack_pack_inline_func(_int32)(msgpack_pack_user x, int32_t d) -{ - msgpack_pack_real_int32(x, d); -} - -msgpack_pack_inline_func(_int64)(msgpack_pack_user x, int64_t d) -{ - msgpack_pack_real_int64(x, d); -} - -msgpack_pack_inline_func(_char)(msgpack_pack_user x, char d) -{ -#if defined(CHAR_MIN) -#if CHAR_MIN < 0 - msgpack_pack_real_int8(x, d); -#else - msgpack_pack_real_uint8(x, d); -#endif -#else -#error CHAR_MIN is not defined -#endif -} - -msgpack_pack_inline_func(_signed_char)(msgpack_pack_user x, signed char d) -{ - msgpack_pack_real_int8(x, d); -} - -msgpack_pack_inline_func(_unsigned_char)(msgpack_pack_user x, unsigned char d) -{ - msgpack_pack_real_uint8(x, d); -} - -#ifdef msgpack_pack_inline_func_cint - -msgpack_pack_inline_func_cint(_short)(msgpack_pack_user x, short d) -{ -#if defined(SIZEOF_SHORT) -#if SIZEOF_SHORT == 2 - msgpack_pack_real_int16(x, d); -#elif SIZEOF_SHORT == 4 - msgpack_pack_real_int32(x, d); -#else - msgpack_pack_real_int64(x, d); -#endif - -#elif defined(SHRT_MAX) -#if SHRT_MAX == 0x7fff - msgpack_pack_real_int16(x, d); -#elif SHRT_MAX == 0x7fffffff - msgpack_pack_real_int32(x, d); -#else - msgpack_pack_real_int64(x, d); -#endif - -#else -if(sizeof(short) == 2) { - msgpack_pack_real_int16(x, d); -} else if(sizeof(short) == 4) { - msgpack_pack_real_int32(x, d); -} else { - msgpack_pack_real_int64(x, d); -} -#endif -} - -msgpack_pack_inline_func_cint(_int)(msgpack_pack_user x, int d) -{ -#if defined(SIZEOF_INT) -#if SIZEOF_INT == 2 - msgpack_pack_real_int16(x, d); -#elif SIZEOF_INT == 4 - msgpack_pack_real_int32(x, d); -#else - msgpack_pack_real_int64(x, d); -#endif - -#elif defined(INT_MAX) -#if INT_MAX == 0x7fff - msgpack_pack_real_int16(x, d); -#elif INT_MAX == 0x7fffffff - msgpack_pack_real_int32(x, d); -#else - msgpack_pack_real_int64(x, d); -#endif - -#else -if(sizeof(int) == 2) { - msgpack_pack_real_int16(x, d); -} else if(sizeof(int) == 4) { - msgpack_pack_real_int32(x, d); -} else { - msgpack_pack_real_int64(x, d); -} -#endif -} - -msgpack_pack_inline_func_cint(_long)(msgpack_pack_user x, long d) -{ -#if defined(SIZEOF_LONG) -#if SIZEOF_LONG == 2 - msgpack_pack_real_int16(x, d); -#elif SIZEOF_LONG == 4 - msgpack_pack_real_int32(x, d); -#else - msgpack_pack_real_int64(x, d); -#endif - -#elif defined(LONG_MAX) -#if LONG_MAX == 0x7fffL - msgpack_pack_real_int16(x, d); -#elif LONG_MAX == 0x7fffffffL - msgpack_pack_real_int32(x, d); -#else - msgpack_pack_real_int64(x, d); -#endif - -#else -if(sizeof(long) == 2) { - msgpack_pack_real_int16(x, d); -} else if(sizeof(long) == 4) { - msgpack_pack_real_int32(x, d); -} else { - msgpack_pack_real_int64(x, d); -} -#endif -} - -msgpack_pack_inline_func_cint(_long_long)(msgpack_pack_user x, long long d) -{ -#if defined(SIZEOF_LONG_LONG) -#if SIZEOF_LONG_LONG == 2 - msgpack_pack_real_int16(x, d); -#elif SIZEOF_LONG_LONG == 4 - msgpack_pack_real_int32(x, d); -#else - msgpack_pack_real_int64(x, d); -#endif - -#elif defined(LLONG_MAX) -#if LLONG_MAX == 0x7fffL - msgpack_pack_real_int16(x, d); -#elif LLONG_MAX == 0x7fffffffL - msgpack_pack_real_int32(x, d); -#else - msgpack_pack_real_int64(x, d); -#endif - -#else -if(sizeof(long long) == 2) { - msgpack_pack_real_int16(x, d); -} else if(sizeof(long long) == 4) { - msgpack_pack_real_int32(x, d); -} else { - msgpack_pack_real_int64(x, d); -} -#endif -} - -msgpack_pack_inline_func_cint(_unsigned_short)(msgpack_pack_user x, unsigned short d) -{ -#if defined(SIZEOF_SHORT) -#if SIZEOF_SHORT == 2 - msgpack_pack_real_uint16(x, d); -#elif SIZEOF_SHORT == 4 - msgpack_pack_real_uint32(x, d); -#else - msgpack_pack_real_uint64(x, d); -#endif - -#elif defined(USHRT_MAX) -#if USHRT_MAX == 0xffffU - msgpack_pack_real_uint16(x, d); -#elif USHRT_MAX == 0xffffffffU - msgpack_pack_real_uint32(x, d); -#else - msgpack_pack_real_uint64(x, d); -#endif - -#else -if(sizeof(unsigned short) == 2) { - msgpack_pack_real_uint16(x, d); -} else if(sizeof(unsigned short) == 4) { - msgpack_pack_real_uint32(x, d); -} else { - msgpack_pack_real_uint64(x, d); -} -#endif -} - -msgpack_pack_inline_func_cint(_unsigned_int)(msgpack_pack_user x, unsigned int d) -{ -#if defined(SIZEOF_INT) -#if SIZEOF_INT == 2 - msgpack_pack_real_uint16(x, d); -#elif SIZEOF_INT == 4 - msgpack_pack_real_uint32(x, d); -#else - msgpack_pack_real_uint64(x, d); -#endif - -#elif defined(UINT_MAX) -#if UINT_MAX == 0xffffU - msgpack_pack_real_uint16(x, d); -#elif UINT_MAX == 0xffffffffU - msgpack_pack_real_uint32(x, d); -#else - msgpack_pack_real_uint64(x, d); -#endif - -#else -if(sizeof(unsigned int) == 2) { - msgpack_pack_real_uint16(x, d); -} else if(sizeof(unsigned int) == 4) { - msgpack_pack_real_uint32(x, d); -} else { - msgpack_pack_real_uint64(x, d); -} -#endif -} - -msgpack_pack_inline_func_cint(_unsigned_long)(msgpack_pack_user x, unsigned long d) -{ -#if defined(SIZEOF_LONG) -#if SIZEOF_LONG == 2 - msgpack_pack_real_uint16(x, d); -#elif SIZEOF_LONG == 4 - msgpack_pack_real_uint32(x, d); -#else - msgpack_pack_real_uint64(x, d); -#endif - -#elif defined(ULONG_MAX) -#if ULONG_MAX == 0xffffUL - msgpack_pack_real_uint16(x, d); -#elif ULONG_MAX == 0xffffffffUL - msgpack_pack_real_uint32(x, d); -#else - msgpack_pack_real_uint64(x, d); -#endif - -#else -if(sizeof(unsigned long) == 2) { - msgpack_pack_real_uint16(x, d); -} else if(sizeof(unsigned long) == 4) { - msgpack_pack_real_uint32(x, d); -} else { - msgpack_pack_real_uint64(x, d); -} -#endif -} - -msgpack_pack_inline_func_cint(_unsigned_long_long)(msgpack_pack_user x, unsigned long long d) -{ -#if defined(SIZEOF_LONG_LONG) -#if SIZEOF_LONG_LONG == 2 - msgpack_pack_real_uint16(x, d); -#elif SIZEOF_LONG_LONG == 4 - msgpack_pack_real_uint32(x, d); -#else - msgpack_pack_real_uint64(x, d); -#endif - -#elif defined(ULLONG_MAX) -#if ULLONG_MAX == 0xffffUL - msgpack_pack_real_uint16(x, d); -#elif ULLONG_MAX == 0xffffffffUL - msgpack_pack_real_uint32(x, d); -#else - msgpack_pack_real_uint64(x, d); -#endif - -#else -if(sizeof(unsigned long long) == 2) { - msgpack_pack_real_uint16(x, d); -} else if(sizeof(unsigned long long) == 4) { - msgpack_pack_real_uint32(x, d); -} else { - msgpack_pack_real_uint64(x, d); -} -#endif -} - -#undef msgpack_pack_inline_func_cint -#endif - - - -/* - * Float - */ - -msgpack_pack_inline_func(_float)(msgpack_pack_user x, float d) -{ - unsigned char buf[5]; - union { float f; uint32_t i; } mem; - mem.f = d; - buf[0] = 0xca; _msgpack_store32(&buf[1], mem.i); - msgpack_pack_append_buffer(x, buf, 5); -} - -msgpack_pack_inline_func(_double)(msgpack_pack_user x, double d) -{ - unsigned char buf[9]; - union { double f; uint64_t i; } mem; - mem.f = d; - buf[0] = 0xcb; -#if defined(__arm__) && !(__ARM_EABI__) // arm-oabi - // https://github.com/msgpack/msgpack-perl/pull/1 - mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); -#endif - _msgpack_store64(&buf[1], mem.i); - msgpack_pack_append_buffer(x, buf, 9); -} - - -/* - * Nil - */ - -msgpack_pack_inline_func(_nil)(msgpack_pack_user x) -{ - static const unsigned char d = 0xc0; - msgpack_pack_append_buffer(x, &d, 1); -} - - -/* - * Boolean - */ - -msgpack_pack_inline_func(_true)(msgpack_pack_user x) -{ - static const unsigned char d = 0xc3; - msgpack_pack_append_buffer(x, &d, 1); -} - -msgpack_pack_inline_func(_false)(msgpack_pack_user x) -{ - static const unsigned char d = 0xc2; - msgpack_pack_append_buffer(x, &d, 1); -} - - -/* - * Array - */ - -msgpack_pack_inline_func(_array)(msgpack_pack_user x, size_t n) -{ - if(n < 16) { - unsigned char d = 0x90 | (uint8_t)n; - msgpack_pack_append_buffer(x, &d, 1); - } else if(n < 65536) { - unsigned char buf[3]; - buf[0] = 0xdc; _msgpack_store16(&buf[1], (uint16_t)n); - msgpack_pack_append_buffer(x, buf, 3); - } else { - unsigned char buf[5]; - buf[0] = 0xdd; _msgpack_store32(&buf[1], (uint32_t)n); - msgpack_pack_append_buffer(x, buf, 5); - } -} - - -/* - * Map - */ - -msgpack_pack_inline_func(_map)(msgpack_pack_user x, size_t n) -{ - if(n < 16) { - unsigned char d = 0x80 | (uint8_t)n; - msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); - } else if(n < 65536) { - unsigned char buf[3]; - buf[0] = 0xde; _msgpack_store16(&buf[1], (uint16_t)n); - msgpack_pack_append_buffer(x, buf, 3); - } else { - unsigned char buf[5]; - buf[0] = 0xdf; _msgpack_store32(&buf[1], (uint32_t)n); - msgpack_pack_append_buffer(x, buf, 5); - } -} - - -/* - * Raw - */ - -msgpack_pack_inline_func(_raw)(msgpack_pack_user x, size_t l) -{ - if(l < 32) { - unsigned char d = 0xa0 | (uint8_t)l; - msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); - } else if(l < 65536) { - unsigned char buf[3]; - buf[0] = 0xda; _msgpack_store16(&buf[1], (uint16_t)l); - msgpack_pack_append_buffer(x, buf, 3); - } else { - unsigned char buf[5]; - buf[0] = 0xdb; _msgpack_store32(&buf[1], (uint32_t)l); - msgpack_pack_append_buffer(x, buf, 5); - } -} - -msgpack_pack_inline_func(_raw_body)(msgpack_pack_user x, const void* b, size_t l) -{ - msgpack_pack_append_buffer(x, (const unsigned char*)b, l); -} - -#undef msgpack_pack_inline_func -#undef msgpack_pack_user -#undef msgpack_pack_append_buffer - -#undef TAKE8_8 -#undef TAKE8_16 -#undef TAKE8_32 -#undef TAKE8_64 - -#undef msgpack_pack_real_uint8 -#undef msgpack_pack_real_uint16 -#undef msgpack_pack_real_uint32 -#undef msgpack_pack_real_uint64 -#undef msgpack_pack_real_int8 -#undef msgpack_pack_real_int16 -#undef msgpack_pack_real_int32 -#undef msgpack_pack_real_int64 - diff --git a/src/msgpack/sbuffer.hpp b/src/msgpack/sbuffer.hpp deleted file mode 100644 index fce56ad5..00000000 --- a/src/msgpack/sbuffer.hpp +++ /dev/null @@ -1,112 +0,0 @@ -// -// MessagePack for C++ simple buffer implementation -// -// 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_SBUFFER_HPP__ -#define MSGPACK_SBUFFER_HPP__ - -#include "sbuffer.h" -#include - -namespace msgpack { - - -class sbuffer : public msgpack_sbuffer { -public: - sbuffer(size_t initsz = MSGPACK_SBUFFER_INIT_SIZE) - { - if(initsz == 0) { - base::data = NULL; - } else { - base::data = (char*)::malloc(initsz); - if(!base::data) { - throw std::bad_alloc(); - } - } - - base::size = 0; - base::alloc = initsz; - } - - ~sbuffer() - { - ::free(base::data); - } - -public: - void write(const char* buf, size_t len) - { - if(base::alloc - base::size < len) { - expand_buffer(len); - } - memcpy(base::data + base::size, buf, len); - base::size += len; - } - - char* data() - { - return base::data; - } - - const char* data() const - { - return base::data; - } - - size_t size() const - { - return base::size; - } - - char* release() - { - return msgpack_sbuffer_release(this); - } - - void clear() - { - msgpack_sbuffer_clear(this); - } - -private: - void expand_buffer(size_t len) - { - size_t nsize = (base::alloc > 0) ? - base::alloc * 2 : MSGPACK_SBUFFER_INIT_SIZE; - - while(nsize < base::size + len) { nsize *= 2; } - - void* tmp = realloc(base::data, nsize); - if(!tmp) { - throw std::bad_alloc(); - } - - base::data = (char*)tmp; - base::alloc = nsize; - } - -private: - typedef msgpack_sbuffer base; - -private: - sbuffer(const sbuffer&); -}; - - -} // namespace msgpack - -#endif /* msgpack/sbuffer.hpp */ - diff --git a/src/msgpack/type.hpp b/src/msgpack/type.hpp deleted file mode 100644 index 1f51319a..00000000 --- a/src/msgpack/type.hpp +++ /dev/null @@ -1,17 +0,0 @@ -#include "type/bool.hpp" -#include "type/deque.hpp" -#include "type/fixint.hpp" -#include "type/float.hpp" -#include "type/int.hpp" -#include "type/list.hpp" -#include "type/map.hpp" -#include "type/nil.hpp" -#include "type/pair.hpp" -#include "type/raw.hpp" -#include "type/set.hpp" -#include "type/string.hpp" -#include "type/vector.hpp" -#include "type/tuple.hpp" -#include "type/define.hpp" -#include "type/tr1/unordered_map.hpp" -#include "type/tr1/unordered_set.hpp" diff --git a/src/msgpack/type/define.hpp b/src/msgpack/type/define.hpp deleted file mode 100644 index bb8e2137..00000000 --- a/src/msgpack/type/define.hpp +++ /dev/null @@ -1,3465 +0,0 @@ -// -// 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_DEFINE_HPP__ -#define MSGPACK_TYPE_DEFINE_HPP__ - -#define MSGPACK_DEFINE(...) \ - template \ - void msgpack_pack(Packer& pk) const \ - { \ - msgpack::type::make_define(__VA_ARGS__).msgpack_pack(pk); \ - } \ - void msgpack_unpack(msgpack::object o) \ - { \ - msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \ - }\ - template \ - void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone* z) const \ - { \ - msgpack::type::make_define(__VA_ARGS__).msgpack_object(o, z); \ - } - -// MSGPACK_ADD_ENUM must be used in the global namespace. -#define MSGPACK_ADD_ENUM(enum) \ - namespace msgpack { \ - template <> \ - inline enum& operator>> (object o, enum& v) \ - { \ - int tmp; \ - o >> tmp; \ - v = static_cast(tmp); \ - return v; \ - } \ - template <> \ - inline void operator<< (object::with_zone& o, const enum& v) \ - { \ - o << static_cast(v); \ - } \ - namespace detail { \ - template \ - struct packer_serializer { \ - static packer& pack(packer& o, const enum& v) { \ - return o << static_cast(v); \ - } \ - }; \ - } \ - } - -namespace msgpack { -namespace type { - - - -template -struct define; - - -template <> -struct define<> { - typedef define<> value_type; - typedef tuple<> tuple_type; - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(0); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = NULL; - o->via.array.size = 0; - } -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0) : - a0(_a0) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(1); - - pk.pack(a0); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*1); - o->via.array.size = 1; - - o->via.array.ptr[0] = object(a0, z); - } - - A0& a0; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1) : - a0(_a0), a1(_a1) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(2); - - pk.pack(a0); - pk.pack(a1); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*2); - o->via.array.size = 2; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - } - - A0& a0; - A1& a1; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2) : - a0(_a0), a1(_a1), a2(_a2) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(3); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*3); - o->via.array.size = 3; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - } - - A0& a0; - A1& a1; - A2& a2; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(4); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*4); - o->via.array.size = 4; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(5); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*5); - o->via.array.size = 5; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(6); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*6); - o->via.array.size = 6; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(7); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*7); - o->via.array.size = 7; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(8); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*8); - o->via.array.size = 8; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(9); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 9: ptr[8].convert(&a8); - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*9); - o->via.array.size = 9; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(10); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 10: ptr[9].convert(&a9); - case 9: ptr[8].convert(&a8); - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*10); - o->via.array.size = 10; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(11); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 11: ptr[10].convert(&a10); - case 10: ptr[9].convert(&a9); - case 9: ptr[8].convert(&a8); - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*11); - o->via.array.size = 11; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(12); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 12: ptr[11].convert(&a11); - case 11: ptr[10].convert(&a10); - case 10: ptr[9].convert(&a9); - case 9: ptr[8].convert(&a8); - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*12); - o->via.array.size = 12; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(13); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 13: ptr[12].convert(&a12); - case 12: ptr[11].convert(&a11); - case 11: ptr[10].convert(&a10); - case 10: ptr[9].convert(&a9); - case 9: ptr[8].convert(&a8); - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*13); - o->via.array.size = 13; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(14); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 14: ptr[13].convert(&a13); - case 13: ptr[12].convert(&a12); - case 12: ptr[11].convert(&a11); - case 11: ptr[10].convert(&a10); - case 10: ptr[9].convert(&a9); - case 9: ptr[8].convert(&a8); - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*14); - o->via.array.size = 14; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(15); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 15: ptr[14].convert(&a14); - case 14: ptr[13].convert(&a13); - case 13: ptr[12].convert(&a12); - case 12: ptr[11].convert(&a11); - case 11: ptr[10].convert(&a10); - case 10: ptr[9].convert(&a9); - case 9: ptr[8].convert(&a8); - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*15); - o->via.array.size = 15; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(16); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 16: ptr[15].convert(&a15); - case 15: ptr[14].convert(&a14); - case 14: ptr[13].convert(&a13); - case 13: ptr[12].convert(&a12); - case 12: ptr[11].convert(&a11); - case 11: ptr[10].convert(&a10); - case 10: ptr[9].convert(&a9); - case 9: ptr[8].convert(&a8); - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*16); - o->via.array.size = 16; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(17); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 17: ptr[16].convert(&a16); - case 16: ptr[15].convert(&a15); - case 15: ptr[14].convert(&a14); - case 14: ptr[13].convert(&a13); - case 13: ptr[12].convert(&a12); - case 12: ptr[11].convert(&a11); - case 11: ptr[10].convert(&a10); - case 10: ptr[9].convert(&a9); - case 9: ptr[8].convert(&a8); - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*17); - o->via.array.size = 17; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(18); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 18: ptr[17].convert(&a17); - case 17: ptr[16].convert(&a16); - case 16: ptr[15].convert(&a15); - case 15: ptr[14].convert(&a14); - case 14: ptr[13].convert(&a13); - case 13: ptr[12].convert(&a12); - case 12: ptr[11].convert(&a11); - case 11: ptr[10].convert(&a10); - case 10: ptr[9].convert(&a9); - case 9: ptr[8].convert(&a8); - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*18); - o->via.array.size = 18; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - o->via.array.ptr[17] = object(a17, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; - A17& a17; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(19); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 19: ptr[18].convert(&a18); - case 18: ptr[17].convert(&a17); - case 17: ptr[16].convert(&a16); - case 16: ptr[15].convert(&a15); - case 15: ptr[14].convert(&a14); - case 14: ptr[13].convert(&a13); - case 13: ptr[12].convert(&a12); - case 12: ptr[11].convert(&a11); - case 11: ptr[10].convert(&a10); - case 10: ptr[9].convert(&a9); - case 9: ptr[8].convert(&a8); - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*19); - o->via.array.size = 19; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - o->via.array.ptr[17] = object(a17, z); - o->via.array.ptr[18] = object(a18, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; - A17& a17; - A18& a18; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(20); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 20: ptr[19].convert(&a19); - case 19: ptr[18].convert(&a18); - case 18: ptr[17].convert(&a17); - case 17: ptr[16].convert(&a16); - case 16: ptr[15].convert(&a15); - case 15: ptr[14].convert(&a14); - case 14: ptr[13].convert(&a13); - case 13: ptr[12].convert(&a12); - case 12: ptr[11].convert(&a11); - case 11: ptr[10].convert(&a10); - case 10: ptr[9].convert(&a9); - case 9: ptr[8].convert(&a8); - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*20); - o->via.array.size = 20; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - o->via.array.ptr[17] = object(a17, z); - o->via.array.ptr[18] = object(a18, z); - o->via.array.ptr[19] = object(a19, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; - A17& a17; - A18& a18; - A19& a19; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(21); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 21: ptr[20].convert(&a20); - case 20: ptr[19].convert(&a19); - case 19: ptr[18].convert(&a18); - case 18: ptr[17].convert(&a17); - case 17: ptr[16].convert(&a16); - case 16: ptr[15].convert(&a15); - case 15: ptr[14].convert(&a14); - case 14: ptr[13].convert(&a13); - case 13: ptr[12].convert(&a12); - case 12: ptr[11].convert(&a11); - case 11: ptr[10].convert(&a10); - case 10: ptr[9].convert(&a9); - case 9: ptr[8].convert(&a8); - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*21); - o->via.array.size = 21; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - o->via.array.ptr[17] = object(a17, z); - o->via.array.ptr[18] = object(a18, z); - o->via.array.ptr[19] = object(a19, z); - o->via.array.ptr[20] = object(a20, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; - A17& a17; - A18& a18; - A19& a19; - A20& a20; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(22); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 22: ptr[21].convert(&a21); - case 21: ptr[20].convert(&a20); - case 20: ptr[19].convert(&a19); - case 19: ptr[18].convert(&a18); - case 18: ptr[17].convert(&a17); - case 17: ptr[16].convert(&a16); - case 16: ptr[15].convert(&a15); - case 15: ptr[14].convert(&a14); - case 14: ptr[13].convert(&a13); - case 13: ptr[12].convert(&a12); - case 12: ptr[11].convert(&a11); - case 11: ptr[10].convert(&a10); - case 10: ptr[9].convert(&a9); - case 9: ptr[8].convert(&a8); - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*22); - o->via.array.size = 22; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - o->via.array.ptr[17] = object(a17, z); - o->via.array.ptr[18] = object(a18, z); - o->via.array.ptr[19] = object(a19, z); - o->via.array.ptr[20] = object(a20, z); - o->via.array.ptr[21] = object(a21, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; - A17& a17; - A18& a18; - A19& a19; - A20& a20; - A21& a21; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(23); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - pk.pack(a22); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 23: ptr[22].convert(&a22); - case 22: ptr[21].convert(&a21); - case 21: ptr[20].convert(&a20); - case 20: ptr[19].convert(&a19); - case 19: ptr[18].convert(&a18); - case 18: ptr[17].convert(&a17); - case 17: ptr[16].convert(&a16); - case 16: ptr[15].convert(&a15); - case 15: ptr[14].convert(&a14); - case 14: ptr[13].convert(&a13); - case 13: ptr[12].convert(&a12); - case 12: ptr[11].convert(&a11); - case 11: ptr[10].convert(&a10); - case 10: ptr[9].convert(&a9); - case 9: ptr[8].convert(&a8); - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*23); - o->via.array.size = 23; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - o->via.array.ptr[17] = object(a17, z); - o->via.array.ptr[18] = object(a18, z); - o->via.array.ptr[19] = object(a19, z); - o->via.array.ptr[20] = object(a20, z); - o->via.array.ptr[21] = object(a21, z); - o->via.array.ptr[22] = object(a22, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; - A17& a17; - A18& a18; - A19& a19; - A20& a20; - A21& a21; - A22& a22; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(24); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - pk.pack(a22); - pk.pack(a23); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 24: ptr[23].convert(&a23); - case 23: ptr[22].convert(&a22); - case 22: ptr[21].convert(&a21); - case 21: ptr[20].convert(&a20); - case 20: ptr[19].convert(&a19); - case 19: ptr[18].convert(&a18); - case 18: ptr[17].convert(&a17); - case 17: ptr[16].convert(&a16); - case 16: ptr[15].convert(&a15); - case 15: ptr[14].convert(&a14); - case 14: ptr[13].convert(&a13); - case 13: ptr[12].convert(&a12); - case 12: ptr[11].convert(&a11); - case 11: ptr[10].convert(&a10); - case 10: ptr[9].convert(&a9); - case 9: ptr[8].convert(&a8); - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*24); - o->via.array.size = 24; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - o->via.array.ptr[17] = object(a17, z); - o->via.array.ptr[18] = object(a18, z); - o->via.array.ptr[19] = object(a19, z); - o->via.array.ptr[20] = object(a20, z); - o->via.array.ptr[21] = object(a21, z); - o->via.array.ptr[22] = object(a22, z); - o->via.array.ptr[23] = object(a23, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; - A17& a17; - A18& a18; - A19& a19; - A20& a20; - A21& a21; - A22& a22; - A23& a23; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(25); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - pk.pack(a22); - pk.pack(a23); - pk.pack(a24); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 25: ptr[24].convert(&a24); - case 24: ptr[23].convert(&a23); - case 23: ptr[22].convert(&a22); - case 22: ptr[21].convert(&a21); - case 21: ptr[20].convert(&a20); - case 20: ptr[19].convert(&a19); - case 19: ptr[18].convert(&a18); - case 18: ptr[17].convert(&a17); - case 17: ptr[16].convert(&a16); - case 16: ptr[15].convert(&a15); - case 15: ptr[14].convert(&a14); - case 14: ptr[13].convert(&a13); - case 13: ptr[12].convert(&a12); - case 12: ptr[11].convert(&a11); - case 11: ptr[10].convert(&a10); - case 10: ptr[9].convert(&a9); - case 9: ptr[8].convert(&a8); - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*25); - o->via.array.size = 25; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - o->via.array.ptr[17] = object(a17, z); - o->via.array.ptr[18] = object(a18, z); - o->via.array.ptr[19] = object(a19, z); - o->via.array.ptr[20] = object(a20, z); - o->via.array.ptr[21] = object(a21, z); - o->via.array.ptr[22] = object(a22, z); - o->via.array.ptr[23] = object(a23, z); - o->via.array.ptr[24] = object(a24, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; - A17& a17; - A18& a18; - A19& a19; - A20& a20; - A21& a21; - A22& a22; - A23& a23; - A24& a24; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(26); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - pk.pack(a22); - pk.pack(a23); - pk.pack(a24); - pk.pack(a25); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 26: ptr[25].convert(&a25); - case 25: ptr[24].convert(&a24); - case 24: ptr[23].convert(&a23); - case 23: ptr[22].convert(&a22); - case 22: ptr[21].convert(&a21); - case 21: ptr[20].convert(&a20); - case 20: ptr[19].convert(&a19); - case 19: ptr[18].convert(&a18); - case 18: ptr[17].convert(&a17); - case 17: ptr[16].convert(&a16); - case 16: ptr[15].convert(&a15); - case 15: ptr[14].convert(&a14); - case 14: ptr[13].convert(&a13); - case 13: ptr[12].convert(&a12); - case 12: ptr[11].convert(&a11); - case 11: ptr[10].convert(&a10); - case 10: ptr[9].convert(&a9); - case 9: ptr[8].convert(&a8); - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*26); - o->via.array.size = 26; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - o->via.array.ptr[17] = object(a17, z); - o->via.array.ptr[18] = object(a18, z); - o->via.array.ptr[19] = object(a19, z); - o->via.array.ptr[20] = object(a20, z); - o->via.array.ptr[21] = object(a21, z); - o->via.array.ptr[22] = object(a22, z); - o->via.array.ptr[23] = object(a23, z); - o->via.array.ptr[24] = object(a24, z); - o->via.array.ptr[25] = object(a25, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; - A17& a17; - A18& a18; - A19& a19; - A20& a20; - A21& a21; - A22& a22; - A23& a23; - A24& a24; - A25& a25; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(27); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - pk.pack(a22); - pk.pack(a23); - pk.pack(a24); - pk.pack(a25); - pk.pack(a26); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 27: ptr[26].convert(&a26); - case 26: ptr[25].convert(&a25); - case 25: ptr[24].convert(&a24); - case 24: ptr[23].convert(&a23); - case 23: ptr[22].convert(&a22); - case 22: ptr[21].convert(&a21); - case 21: ptr[20].convert(&a20); - case 20: ptr[19].convert(&a19); - case 19: ptr[18].convert(&a18); - case 18: ptr[17].convert(&a17); - case 17: ptr[16].convert(&a16); - case 16: ptr[15].convert(&a15); - case 15: ptr[14].convert(&a14); - case 14: ptr[13].convert(&a13); - case 13: ptr[12].convert(&a12); - case 12: ptr[11].convert(&a11); - case 11: ptr[10].convert(&a10); - case 10: ptr[9].convert(&a9); - case 9: ptr[8].convert(&a8); - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*27); - o->via.array.size = 27; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - o->via.array.ptr[17] = object(a17, z); - o->via.array.ptr[18] = object(a18, z); - o->via.array.ptr[19] = object(a19, z); - o->via.array.ptr[20] = object(a20, z); - o->via.array.ptr[21] = object(a21, z); - o->via.array.ptr[22] = object(a22, z); - o->via.array.ptr[23] = object(a23, z); - o->via.array.ptr[24] = object(a24, z); - o->via.array.ptr[25] = object(a25, z); - o->via.array.ptr[26] = object(a26, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; - A17& a17; - A18& a18; - A19& a19; - A20& a20; - A21& a21; - A22& a22; - A23& a23; - A24& a24; - A25& a25; - A26& a26; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(28); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - pk.pack(a22); - pk.pack(a23); - pk.pack(a24); - pk.pack(a25); - pk.pack(a26); - pk.pack(a27); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 28: ptr[27].convert(&a27); - case 27: ptr[26].convert(&a26); - case 26: ptr[25].convert(&a25); - case 25: ptr[24].convert(&a24); - case 24: ptr[23].convert(&a23); - case 23: ptr[22].convert(&a22); - case 22: ptr[21].convert(&a21); - case 21: ptr[20].convert(&a20); - case 20: ptr[19].convert(&a19); - case 19: ptr[18].convert(&a18); - case 18: ptr[17].convert(&a17); - case 17: ptr[16].convert(&a16); - case 16: ptr[15].convert(&a15); - case 15: ptr[14].convert(&a14); - case 14: ptr[13].convert(&a13); - case 13: ptr[12].convert(&a12); - case 12: ptr[11].convert(&a11); - case 11: ptr[10].convert(&a10); - case 10: ptr[9].convert(&a9); - case 9: ptr[8].convert(&a8); - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*28); - o->via.array.size = 28; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - o->via.array.ptr[17] = object(a17, z); - o->via.array.ptr[18] = object(a18, z); - o->via.array.ptr[19] = object(a19, z); - o->via.array.ptr[20] = object(a20, z); - o->via.array.ptr[21] = object(a21, z); - o->via.array.ptr[22] = object(a22, z); - o->via.array.ptr[23] = object(a23, z); - o->via.array.ptr[24] = object(a24, z); - o->via.array.ptr[25] = object(a25, z); - o->via.array.ptr[26] = object(a26, z); - o->via.array.ptr[27] = object(a27, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; - A17& a17; - A18& a18; - A19& a19; - A20& a20; - A21& a21; - A22& a22; - A23& a23; - A24& a24; - A25& a25; - A26& a26; - A27& a27; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27, A28& _a28) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(29); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - pk.pack(a22); - pk.pack(a23); - pk.pack(a24); - pk.pack(a25); - pk.pack(a26); - pk.pack(a27); - pk.pack(a28); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 29: ptr[28].convert(&a28); - case 28: ptr[27].convert(&a27); - case 27: ptr[26].convert(&a26); - case 26: ptr[25].convert(&a25); - case 25: ptr[24].convert(&a24); - case 24: ptr[23].convert(&a23); - case 23: ptr[22].convert(&a22); - case 22: ptr[21].convert(&a21); - case 21: ptr[20].convert(&a20); - case 20: ptr[19].convert(&a19); - case 19: ptr[18].convert(&a18); - case 18: ptr[17].convert(&a17); - case 17: ptr[16].convert(&a16); - case 16: ptr[15].convert(&a15); - case 15: ptr[14].convert(&a14); - case 14: ptr[13].convert(&a13); - case 13: ptr[12].convert(&a12); - case 12: ptr[11].convert(&a11); - case 11: ptr[10].convert(&a10); - case 10: ptr[9].convert(&a9); - case 9: ptr[8].convert(&a8); - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*29); - o->via.array.size = 29; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - o->via.array.ptr[17] = object(a17, z); - o->via.array.ptr[18] = object(a18, z); - o->via.array.ptr[19] = object(a19, z); - o->via.array.ptr[20] = object(a20, z); - o->via.array.ptr[21] = object(a21, z); - o->via.array.ptr[22] = object(a22, z); - o->via.array.ptr[23] = object(a23, z); - o->via.array.ptr[24] = object(a24, z); - o->via.array.ptr[25] = object(a25, z); - o->via.array.ptr[26] = object(a26, z); - o->via.array.ptr[27] = object(a27, z); - o->via.array.ptr[28] = object(a28, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; - A17& a17; - A18& a18; - A19& a19; - A20& a20; - A21& a21; - A22& a22; - A23& a23; - A24& a24; - A25& a25; - A26& a26; - A27& a27; - A28& a28; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27, A28& _a28, A29& _a29) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28), a29(_a29) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(30); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - pk.pack(a22); - pk.pack(a23); - pk.pack(a24); - pk.pack(a25); - pk.pack(a26); - pk.pack(a27); - pk.pack(a28); - pk.pack(a29); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 30: ptr[29].convert(&a29); - case 29: ptr[28].convert(&a28); - case 28: ptr[27].convert(&a27); - case 27: ptr[26].convert(&a26); - case 26: ptr[25].convert(&a25); - case 25: ptr[24].convert(&a24); - case 24: ptr[23].convert(&a23); - case 23: ptr[22].convert(&a22); - case 22: ptr[21].convert(&a21); - case 21: ptr[20].convert(&a20); - case 20: ptr[19].convert(&a19); - case 19: ptr[18].convert(&a18); - case 18: ptr[17].convert(&a17); - case 17: ptr[16].convert(&a16); - case 16: ptr[15].convert(&a15); - case 15: ptr[14].convert(&a14); - case 14: ptr[13].convert(&a13); - case 13: ptr[12].convert(&a12); - case 12: ptr[11].convert(&a11); - case 11: ptr[10].convert(&a10); - case 10: ptr[9].convert(&a9); - case 9: ptr[8].convert(&a8); - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*30); - o->via.array.size = 30; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - o->via.array.ptr[17] = object(a17, z); - o->via.array.ptr[18] = object(a18, z); - o->via.array.ptr[19] = object(a19, z); - o->via.array.ptr[20] = object(a20, z); - o->via.array.ptr[21] = object(a21, z); - o->via.array.ptr[22] = object(a22, z); - o->via.array.ptr[23] = object(a23, z); - o->via.array.ptr[24] = object(a24, z); - o->via.array.ptr[25] = object(a25, z); - o->via.array.ptr[26] = object(a26, z); - o->via.array.ptr[27] = object(a27, z); - o->via.array.ptr[28] = object(a28, z); - o->via.array.ptr[29] = object(a29, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; - A17& a17; - A18& a18; - A19& a19; - A20& a20; - A21& a21; - A22& a22; - A23& a23; - A24& a24; - A25& a25; - A26& a26; - A27& a27; - A28& a28; - A29& a29; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27, A28& _a28, A29& _a29, A30& _a30) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28), a29(_a29), a30(_a30) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(31); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - pk.pack(a22); - pk.pack(a23); - pk.pack(a24); - pk.pack(a25); - pk.pack(a26); - pk.pack(a27); - pk.pack(a28); - pk.pack(a29); - pk.pack(a30); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 31: ptr[30].convert(&a30); - case 30: ptr[29].convert(&a29); - case 29: ptr[28].convert(&a28); - case 28: ptr[27].convert(&a27); - case 27: ptr[26].convert(&a26); - case 26: ptr[25].convert(&a25); - case 25: ptr[24].convert(&a24); - case 24: ptr[23].convert(&a23); - case 23: ptr[22].convert(&a22); - case 22: ptr[21].convert(&a21); - case 21: ptr[20].convert(&a20); - case 20: ptr[19].convert(&a19); - case 19: ptr[18].convert(&a18); - case 18: ptr[17].convert(&a17); - case 17: ptr[16].convert(&a16); - case 16: ptr[15].convert(&a15); - case 15: ptr[14].convert(&a14); - case 14: ptr[13].convert(&a13); - case 13: ptr[12].convert(&a12); - case 12: ptr[11].convert(&a11); - case 11: ptr[10].convert(&a10); - case 10: ptr[9].convert(&a9); - case 9: ptr[8].convert(&a8); - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*31); - o->via.array.size = 31; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - o->via.array.ptr[17] = object(a17, z); - o->via.array.ptr[18] = object(a18, z); - o->via.array.ptr[19] = object(a19, z); - o->via.array.ptr[20] = object(a20, z); - o->via.array.ptr[21] = object(a21, z); - o->via.array.ptr[22] = object(a22, z); - o->via.array.ptr[23] = object(a23, z); - o->via.array.ptr[24] = object(a24, z); - o->via.array.ptr[25] = object(a25, z); - o->via.array.ptr[26] = object(a26, z); - o->via.array.ptr[27] = object(a27, z); - o->via.array.ptr[28] = object(a28, z); - o->via.array.ptr[29] = object(a29, z); - o->via.array.ptr[30] = object(a30, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; - A17& a17; - A18& a18; - A19& a19; - A20& a20; - A21& a21; - A22& a22; - A23& a23; - A24& a24; - A25& a25; - A26& a26; - A27& a27; - A28& a28; - A29& a29; - A30& a30; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27, A28& _a28, A29& _a29, A30& _a30, A31& _a31) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28), a29(_a29), a30(_a30), a31(_a31) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(32); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - pk.pack(a22); - pk.pack(a23); - pk.pack(a24); - pk.pack(a25); - pk.pack(a26); - pk.pack(a27); - pk.pack(a28); - pk.pack(a29); - pk.pack(a30); - pk.pack(a31); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 32: ptr[31].convert(&a31); - case 31: ptr[30].convert(&a30); - case 30: ptr[29].convert(&a29); - case 29: ptr[28].convert(&a28); - case 28: ptr[27].convert(&a27); - case 27: ptr[26].convert(&a26); - case 26: ptr[25].convert(&a25); - case 25: ptr[24].convert(&a24); - case 24: ptr[23].convert(&a23); - case 23: ptr[22].convert(&a22); - case 22: ptr[21].convert(&a21); - case 21: ptr[20].convert(&a20); - case 20: ptr[19].convert(&a19); - case 19: ptr[18].convert(&a18); - case 18: ptr[17].convert(&a17); - case 17: ptr[16].convert(&a16); - case 16: ptr[15].convert(&a15); - case 15: ptr[14].convert(&a14); - case 14: ptr[13].convert(&a13); - case 13: ptr[12].convert(&a12); - case 12: ptr[11].convert(&a11); - case 11: ptr[10].convert(&a10); - case 10: ptr[9].convert(&a9); - case 9: ptr[8].convert(&a8); - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*32); - o->via.array.size = 32; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - o->via.array.ptr[17] = object(a17, z); - o->via.array.ptr[18] = object(a18, z); - o->via.array.ptr[19] = object(a19, z); - o->via.array.ptr[20] = object(a20, z); - o->via.array.ptr[21] = object(a21, z); - o->via.array.ptr[22] = object(a22, z); - o->via.array.ptr[23] = object(a23, z); - o->via.array.ptr[24] = object(a24, z); - o->via.array.ptr[25] = object(a25, z); - o->via.array.ptr[26] = object(a26, z); - o->via.array.ptr[27] = object(a27, z); - o->via.array.ptr[28] = object(a28, z); - o->via.array.ptr[29] = object(a29, z); - o->via.array.ptr[30] = object(a30, z); - o->via.array.ptr[31] = object(a31, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; - A17& a17; - A18& a18; - A19& a19; - A20& a20; - A21& a21; - A22& a22; - A23& a23; - A24& a24; - A25& a25; - A26& a26; - A27& a27; - A28& a28; - A29& a29; - A30& a30; - A31& a31; -}; - - -inline define<> make_define() -{ - return define<>(); -} - -template -define make_define(A0& a0) -{ - return define(a0); -} - -template -define make_define(A0& a0, A1& a1) -{ - return define(a0, a1); -} - -template -define make_define(A0& a0, A1& a1, A2& a2) -{ - return define(a0, a1, a2); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3) -{ - return define(a0, a1, a2, a3); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4) -{ - return define(a0, a1, a2, a3, a4); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) -{ - return define(a0, a1, a2, a3, a4, a5); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) -{ - return define(a0, a1, a2, a3, a4, a5, a6); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28, A29& a29) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28, A29& a29, A30& a30) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28, A29& a29, A30& a30, A31& a31) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31); -} - - -} // namespace type -} // namespace msgpack - - -#endif /* msgpack/type/define.hpp */ - diff --git a/src/msgpack/type/define.hpp.erb b/src/msgpack/type/define.hpp.erb deleted file mode 100644 index cc06be9c..00000000 --- a/src/msgpack/type/define.hpp.erb +++ /dev/null @@ -1,148 +0,0 @@ -// -// 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_DEFINE_HPP__ -#define MSGPACK_TYPE_DEFINE_HPP__ - -#define MSGPACK_DEFINE(...) \ - template \ - void msgpack_pack(Packer& pk) const \ - { \ - msgpack::type::make_define(__VA_ARGS__).msgpack_pack(pk); \ - } \ - void msgpack_unpack(msgpack::object o) \ - { \ - msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \ - }\ - template \ - void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone* z) const \ - { \ - msgpack::type::make_define(__VA_ARGS__).msgpack_object(o, z); \ - } - -// MSGPACK_ADD_ENUM must be used in the global namespace. -#define MSGPACK_ADD_ENUM(enum) \ - namespace msgpack { \ - template <> \ - inline enum& operator>> (object o, enum& v) \ - { \ - int tmp; \ - o >> tmp; \ - v = static_cast(tmp); \ - return v; \ - } \ - template <> \ - inline void operator<< (object::with_zone& o, const enum& v) \ - { \ - o << static_cast(v); \ - } \ - namespace detail { \ - template \ - struct packer_serializer { \ - static packer& pack(packer& o, const enum& v) { \ - return o << static_cast(v); \ - } \ - }; \ - } \ - } - -namespace msgpack { -namespace type { - - -<% GENERATION_LIMIT = 31 %> -template , typename A<%=i%> = void<%}%>> -struct define; - - -template <> -struct define<> { - typedef define<> value_type; - typedef tuple<> tuple_type; - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(0); - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = NULL; - o->via.array.size = 0; - } -}; -<%0.upto(GENERATION_LIMIT) {|i|%> -template , typename A<%=j%><%}%>> -struct define, A<%=j%><%}%>> { - typedef define, A<%=j%><%}%>> value_type; - typedef tuple, A<%=j%><%}%>> tuple_type; - define(A0& _a0<%1.upto(i) {|j|%>, A<%=j%>& _a<%=j%><%}%>) : - a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(<%=i+1%>); - <%0.upto(i) {|j|%> - pk.pack(a<%=j%>);<%}%> - } - void msgpack_unpack(msgpack::object o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default:<%(i).downto(0) {|j|%> - case <%=j+1%>: ptr[<%=j%>].convert(&a<%=j%>);<%}%> - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*<%=i+1%>); - o->via.array.size = <%=i+1%>; - <%0.upto(i) {|j|%> - o->via.array.ptr[<%=j%>] = object(a<%=j%>, z);<%}%> - } - <%0.upto(i) {|j|%> - A<%=j%>& a<%=j%>;<%}%> -}; -<%}%> - -inline define<> make_define() -{ - return define<>(); -} -<%0.upto(GENERATION_LIMIT) {|i|%> -template , typename A<%=j%><%}%>> -define, A<%=j%><%}%>> make_define(A0& a0<%1.upto(i) {|j|%>, A<%=j%>& a<%=j%><%}%>) -{ - return define, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>); -} -<%}%> - -} // namespace type -} // namespace msgpack - - -#endif /* msgpack/type/define.hpp */ - diff --git a/src/msgpack/type/deque.hpp b/src/msgpack/type/deque.hpp deleted file mode 100644 index d21ceeae..00000000 --- a/src/msgpack/type/deque.hpp +++ /dev/null @@ -1,77 +0,0 @@ -// -// 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_DEQUE_HPP__ -#define MSGPACK_TYPE_DEQUE_HPP__ - -#include "msgpack/object.hpp" -#include - -namespace msgpack { - - -template -inline std::deque& operator>> (object o, std::deque& v) -{ - if(o.type != type::ARRAY) { throw type_error(); } - v.resize(o.via.array.size); - object* p = o.via.array.ptr; - object* const pend = o.via.array.ptr + o.via.array.size; - typename std::deque::iterator it = v.begin(); - for(; p < pend; ++p, ++it) { - p->convert(&*it); - } - return v; -} - -template -inline packer& operator<< (packer& o, const std::deque& v) -{ - o.pack_array(v.size()); - for(typename std::deque::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(*it); - } - return o; -} - -template -inline void operator<< (object::with_zone& o, const std::deque& v) -{ - o.type = type::ARRAY; - if(v.empty()) { - o.via.array.ptr = NULL; - o.via.array.size = 0; - } else { - object* p = (object*)o.zone->malloc(sizeof(object)*v.size()); - object* const pend = p + v.size(); - o.via.array.ptr = p; - o.via.array.size = v.size(); - typename std::deque::const_iterator it(v.begin()); - do { - *p = object(*it, o.zone); - ++p; - ++it; - } while(p < pend); - } -} - - -} // namespace msgpack - -#endif /* msgpack/type/deque.hpp */ - diff --git a/src/msgpack/type/fixint.hpp b/src/msgpack/type/fixint.hpp deleted file mode 100644 index 38633c66..00000000 --- a/src/msgpack/type/fixint.hpp +++ /dev/null @@ -1,217 +0,0 @@ -// -// 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 "msgpack/object.hpp" -#include "msgpack/type/int.hpp" - -namespace msgpack { - -namespace type { - - -template -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 fix_uint8; -typedef fix_int fix_uint16; -typedef fix_int fix_uint32; -typedef fix_int fix_uint64; - -typedef fix_int fix_int8; -typedef fix_int fix_int16; -typedef fix_int fix_int32; -typedef fix_int fix_int64; - - -} // namespace type - - -inline type::fix_int8& operator>> (object o, type::fix_int8& v) - { v = type::detail::convert_integer(o); return v; } - -inline type::fix_int16& operator>> (object o, type::fix_int16& v) - { v = type::detail::convert_integer(o); return v; } - -inline type::fix_int32& operator>> (object o, type::fix_int32& v) - { v = type::detail::convert_integer(o); return v; } - -inline type::fix_int64& operator>> (object o, type::fix_int64& v) - { v = type::detail::convert_integer(o); return v; } - - -inline type::fix_uint8& operator>> (object o, type::fix_uint8& v) - { v = type::detail::convert_integer(o); return v; } - -inline type::fix_uint16& operator>> (object o, type::fix_uint16& v) - { v = type::detail::convert_integer(o); return v; } - -inline type::fix_uint32& operator>> (object o, type::fix_uint32& v) - { v = type::detail::convert_integer(o); return v; } - -inline type::fix_uint64& operator>> (object o, type::fix_uint64& v) - { v = type::detail::convert_integer(o); return v; } - - -template -inline packer& operator<< (packer& o, const type::fix_int8& v) - { o.pack_fix_int8(v); return o; } - -template -inline packer& operator<< (packer& o, const type::fix_int16& v) - { o.pack_fix_int16(v); return o; } - -template -inline packer& operator<< (packer& o, const type::fix_int32& v) - { o.pack_fix_int32(v); return o; } - -template -inline packer& operator<< (packer& o, const type::fix_int64& v) - { o.pack_fix_int64(v); return o; } - - -template -inline packer& operator<< (packer& o, const type::fix_uint8& v) - { o.pack_fix_uint8(v); return o; } - -template -inline packer& operator<< (packer& o, const type::fix_uint16& v) - { o.pack_fix_uint16(v); return o; } - -template -inline packer& operator<< (packer& o, const type::fix_uint32& v) - { o.pack_fix_uint32(v); return o; } - -template -inline packer& operator<< (packer& o, const type::fix_uint64& v) - { o.pack_fix_uint64(v); return o; } - - -inline void operator<< (object& o, type::fix_int8 v) - { - if ( v.get() < 0 ) - { - o.type = type::NEGATIVE_INTEGER ; - o.via.i64 = v.get() ; - } - else - { - o.type = type::POSITIVE_INTEGER ; - o.via.u64 = v.get() ; - } - } - -inline void operator<< (object& o, type::fix_int16 v) - { - if ( v.get() < 0 ) - { - o.type = type::NEGATIVE_INTEGER ; - o.via.i64 = v.get() ; - } - else - { - o.type = type::POSITIVE_INTEGER ; - o.via.u64 = v.get() ; - } - } - -inline void operator<< (object& o, type::fix_int32 v) - { - if ( v.get() < 0 ) - { - o.type = type::NEGATIVE_INTEGER ; - o.via.i64 = v.get() ; - } - else - { - o.type = type::POSITIVE_INTEGER ; - o.via.u64 = v.get() ; - } - } - -inline void operator<< (object& o, type::fix_int64 v) - { - if( v.get() < 0 ) - { - o.type = type::NEGATIVE_INTEGER ; - o.via.i64 = v.get() ; - } - else - { - o.type = type::POSITIVE_INTEGER ; - o.via.u64 = v.get() ; - } - } - - - -inline void operator<< (object& o, type::fix_uint8 v) - { o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); } - -inline void operator<< (object& o, type::fix_uint16 v) - { o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); } - -inline void operator<< (object& o, type::fix_uint32 v) - { o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); } - -inline void operator<< (object& o, type::fix_uint64 v) - { o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); } - - -inline void operator<< (object::with_zone& o, type::fix_int8 v) - { static_cast(o) << v; } - -inline void operator<< (object::with_zone& o, type::fix_int16 v) - { static_cast(o) << v; } - -inline void operator<< (object::with_zone& o, type::fix_int32 v) - { static_cast(o) << v; } - -inline void operator<< (object::with_zone& o, type::fix_int64 v) - { static_cast(o) << v; } - - -inline void operator<< (object::with_zone& o, type::fix_uint8 v) - { static_cast(o) << v; } - -inline void operator<< (object::with_zone& o, type::fix_uint16 v) - { static_cast(o) << v; } - -inline void operator<< (object::with_zone& o, type::fix_uint32 v) - { static_cast(o) << v; } - -inline void operator<< (object::with_zone& o, type::fix_uint64 v) - { static_cast(o) << v; } - - -} // namespace msgpack - -#endif /* msgpack/type/fixint.hpp */ - diff --git a/src/msgpack/type/float.hpp b/src/msgpack/type/float.hpp deleted file mode 100644 index 6ba06d5c..00000000 --- a/src/msgpack/type/float.hpp +++ /dev/null @@ -1,102 +0,0 @@ -// -// 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 "msgpack/object.hpp" -#include - -namespace msgpack { - - -// FIXME check overflow, underflow - - -inline float& operator>> (object o, float& v) -{ - if(o.type == type::DOUBLE) { - v = (float)o.via.dec; - } - else if (o.type == type::POSITIVE_INTEGER) { - v = (float)o.via.u64; - } - else if (o.type == type::NEGATIVE_INTEGER) { - v = (float)o.via.i64; - } - else { - throw type_error(); - } - return v; -} - -template -inline packer& operator<< (packer& o, const float& v) -{ - o.pack_float(v); - return o; -} - - -inline double& operator>> (object o, double& v) -{ - if(o.type == type::DOUBLE) { - v = o.via.dec; - } - else if (o.type == type::POSITIVE_INTEGER) { - v = (double)o.via.u64; - } - else if (o.type == type::NEGATIVE_INTEGER) { - v = (double)o.via.i64; - } - else { - throw type_error(); - } - return v; -} - -template -inline packer& operator<< (packer& o, const double& v) -{ - o.pack_double(v); - return o; -} - - -inline void operator<< (object& o, float v) -{ - o.type = type::DOUBLE; - o.via.dec = (double)v; -} - -inline void operator<< (object& o, double v) -{ - o.type = type::DOUBLE; - o.via.dec = v; -} - -inline void operator<< (object::with_zone& o, float v) - { static_cast(o) << v; } - -inline void operator<< (object::with_zone& o, double v) - { static_cast(o) << v; } - - -} // namespace msgpack - -#endif /* msgpack/type/float.hpp */ - diff --git a/src/msgpack/type/int.hpp b/src/msgpack/type/int.hpp deleted file mode 100644 index 103fea7d..00000000 --- a/src/msgpack/type/int.hpp +++ /dev/null @@ -1,339 +0,0 @@ -// -// 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 "msgpack/object.hpp" -#include - -namespace msgpack { - - -namespace type { -namespace detail { - template - struct convert_integer_sign; - - template - struct convert_integer_sign { - static inline T convert(object o) { - if(o.type == type::POSITIVE_INTEGER) { - if(o.via.u64 > (uint64_t)std::numeric_limits::max()) - { throw type_error(); } - return (T)o.via.u64; - } else if(o.type == type::NEGATIVE_INTEGER) { - if(o.via.i64 < (int64_t)std::numeric_limits::min()) - { throw type_error(); } - return (T)o.via.i64; - } - throw type_error(); - } - }; - - template - struct convert_integer_sign { - static inline T convert(object o) { - if(o.type == type::POSITIVE_INTEGER) { - if(o.via.u64 > (uint64_t)std::numeric_limits::max()) - { throw type_error(); } - return (T)o.via.u64; - } - throw type_error(); - } - }; - - template - struct is_signed { - static const bool value = std::numeric_limits::is_signed; - }; - - template - static inline T convert_integer(object o) - { - return detail::convert_integer_sign::value>::convert(o); - } - - template - struct pack_char_sign; - - template <> - struct pack_char_sign { - template - static inline packer& pack(packer& o, char v) { - o.pack_int8(v); return o; - } - }; - - template <> - struct pack_char_sign { - template - static inline packer& pack(packer& o, char v) { - o.pack_uint8(v); return o; - } - }; - - template - static inline packer& pack_char(packer& o, char v) { - return pack_char_sign::value>::pack(o, v); - } - - template - struct object_char_sign; - - template <> - struct object_char_sign { - static inline void make(object& o, char v) { - if( v < 0 ) - { - o.type = type::NEGATIVE_INTEGER ; - o.via.i64 = v ; - } - else - { - o.type = type::POSITIVE_INTEGER ; - o.via.u64 = v ; - } - } - }; - - template <> - struct object_char_sign { - static inline void make(object& o, char v) { - o.type = type::POSITIVE_INTEGER, o.via.u64 = v; - } - }; - - static inline void object_char(object& o, char v) { - return object_char_sign::value>::make(o, v); - } - -} // namespace detail -} // namespace type - -inline char& operator>> (object const& o, char& v) - { v = type::detail::convert_integer(o); return v; } - - -inline signed char& operator>> (object o, signed char& v) - { v = type::detail::convert_integer(o); return v; } - -inline signed short& operator>> (object o, signed short& v) - { v = type::detail::convert_integer(o); return v; } - -inline signed int& operator>> (object o, signed int& v) - { v = type::detail::convert_integer(o); return v; } - -inline signed long& operator>> (object o, signed long& v) - { v = type::detail::convert_integer(o); return v; } - -inline signed long long& operator>> (object o, signed long long& v) - { v = type::detail::convert_integer(o); return v; } - - -inline unsigned char& operator>> (object o, unsigned char& v) - { v = type::detail::convert_integer(o); return v; } - -inline unsigned short& operator>> (object o, unsigned short& v) - { v = type::detail::convert_integer(o); return v; } - -inline unsigned int& operator>> (object o, unsigned int& v) - { v = type::detail::convert_integer(o); return v; } - -inline unsigned long& operator>> (object o, unsigned long& v) - { v = type::detail::convert_integer(o); return v; } - -inline unsigned long long& operator>> (object o, unsigned long long& v) - { v = type::detail::convert_integer(o); return v; } - -template -inline packer& operator<< (packer& o, char v) - { return type::detail::pack_char(o, v); } - -template -inline packer& operator<< (packer& o, signed char v) - { o.pack_int8(v); return o; } - -template -inline packer& operator<< (packer& o, signed short v) - { o.pack_short(v); return o; } - -template -inline packer& operator<< (packer& o, signed int v) - { o.pack_int(v); return o; } - -template -inline packer& operator<< (packer& o, signed long v) - { o.pack_long(v); return o; } - -template -inline packer& operator<< (packer& o, signed long long v) - { o.pack_long_long(v); return o; } - - -template -inline packer& operator<< (packer& o, unsigned char v) - { o.pack_uint8(v); return o; } - -template -inline packer& operator<< (packer& o, unsigned short v) - { o.pack_unsigned_short(v); return o; } - -template -inline packer& operator<< (packer& o, unsigned int v) - { o.pack_unsigned_int(v); return o; } - -template -inline packer& operator<< (packer& o, unsigned long v) - { o.pack_unsigned_long(v); return o; } - -template -inline packer& operator<< (packer& o, unsigned long long v) - { o.pack_unsigned_long_long(v); return o; } - - -inline void operator<< (object& o, char v) - { type::detail::object_char(o, v); } - - -inline void operator<< (object& o, signed char v) - { - if( v < 0 ) - { - o.type = type::NEGATIVE_INTEGER ; - o.via.i64 = v; - } - else - { - o.type = type::POSITIVE_INTEGER ; - o.via.u64 = v ; - } - } - -inline void operator<< (object& o, signed short v) - { - if(v < 0 ) - { - o.type = type::NEGATIVE_INTEGER ; - o.via.i64 = v ; - } - else - { - o.type = type::POSITIVE_INTEGER ; - o.via.u64 = v; - } - } - -inline void operator<< (object& o, signed int v) - { - if( v < 0 ) - { - o.type = type::NEGATIVE_INTEGER ; - o.via.i64 = v ; - } - else - { - o.type = type::POSITIVE_INTEGER ; - o.via.u64 = v ; - } - } - -inline void operator<< (object& o, signed long v) - { - if( v < 0 ) - { - o.type = type::NEGATIVE_INTEGER ; - o.via.i64 = v ; - } - else - { - o.type = type::POSITIVE_INTEGER ; - o.via.u64 = v ; - } - } - -inline void operator<< (object& o, signed long long v) - { - if( v < 0 ) - { - o.type = type::NEGATIVE_INTEGER ; - o.via.i64 = v ; - } - else - { - o.type = type::POSITIVE_INTEGER ; - o.via.u64 = v ; - } - } - - -inline void operator<< (object& o, unsigned char v) - { o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } - -inline void operator<< (object& o, unsigned short v) - { o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } - -inline void operator<< (object& o, unsigned int v) - { o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } - -inline void operator<< (object& o, unsigned long v) - { o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } - -inline void operator<< (object& o, unsigned long long v) - { o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } - - -inline void operator<< (object::with_zone& o, char v) - { static_cast(o) << v; } - - -inline void operator<< (object::with_zone& o, signed char v) - { static_cast(o) << v; } - -inline void operator<< (object::with_zone& o, signed short v) - { static_cast(o) << v; } - -inline void operator<< (object::with_zone& o, signed int v) - { static_cast(o) << v; } - -inline void operator<< (object::with_zone& o, signed long v) - { static_cast(o) << v; } - -inline void operator<< (object::with_zone& o, const signed long long& v) - { static_cast(o) << v; } - - -inline void operator<< (object::with_zone& o, unsigned char v) - { static_cast(o) << v; } - -inline void operator<< (object::with_zone& o, unsigned short v) - { static_cast(o) << v; } - -inline void operator<< (object::with_zone& o, unsigned int v) - { static_cast(o) << v; } - -inline void operator<< (object::with_zone& o, unsigned long v) - { static_cast(o) << v; } - -inline void operator<< (object::with_zone& o, const unsigned long long& v) - { static_cast(o) << v; } - - -} // namespace msgpack - -#endif /* msgpack/type/int.hpp */ - diff --git a/src/msgpack/type/list.hpp b/src/msgpack/type/list.hpp deleted file mode 100644 index c0f8ce63..00000000 --- a/src/msgpack/type/list.hpp +++ /dev/null @@ -1,77 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2008-2009 FURUHASHI Sadayuki -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_TYPE_LIST_HPP__ -#define MSGPACK_TYPE_LIST_HPP__ - -#include "msgpack/object.hpp" -#include - -namespace msgpack { - - -template -inline std::list& operator>> (object o, std::list& v) -{ - if(o.type != type::ARRAY) { throw type_error(); } - v.resize(o.via.array.size); - object* p = o.via.array.ptr; - object* const pend = o.via.array.ptr + o.via.array.size; - typename std::list::iterator it = v.begin(); - for(; p < pend; ++p, ++it) { - p->convert(&*it); - } - return v; -} - -template -inline packer& operator<< (packer& o, const std::list& v) -{ - o.pack_array(v.size()); - for(typename std::list::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(*it); - } - return o; -} - -template -inline void operator<< (object::with_zone& o, const std::list& v) -{ - o.type = type::ARRAY; - if(v.empty()) { - o.via.array.ptr = NULL; - o.via.array.size = 0; - } else { - object* p = (object*)o.zone->malloc(sizeof(object)*v.size()); - object* const pend = p + v.size(); - o.via.array.ptr = p; - o.via.array.size = v.size(); - typename std::list::const_iterator it(v.begin()); - do { - *p = object(*it, o.zone); - ++p; - ++it; - } while(p < pend); - } -} - - -} // namespace msgpack - -#endif /* msgpack/type/list.hpp */ - diff --git a/src/msgpack/type/map.hpp b/src/msgpack/type/map.hpp deleted file mode 100644 index 958447d5..00000000 --- a/src/msgpack/type/map.hpp +++ /dev/null @@ -1,205 +0,0 @@ -// -// 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_MAP_HPP__ -#define MSGPACK_TYPE_MAP_HPP__ - -#include "msgpack/object.hpp" -#include -#include -#include - -namespace msgpack { - - -namespace type { - -template -class assoc_vector : public std::vector< std::pair > {}; - -namespace detail { - template - struct pair_first_less { - bool operator() (const std::pair& x, const std::pair& y) const - { return x.first < y.first; } - }; -} - -} //namespace type - - -template -inline type::assoc_vector& operator>> (object o, type::assoc_vector& v) -{ - if(o.type != type::MAP) { throw type_error(); } - v.resize(o.via.map.size); - object_kv* p = o.via.map.ptr; - object_kv* const pend = o.via.map.ptr + o.via.map.size; - std::pair* it(&v.front()); - for(; p < pend; ++p, ++it) { - p->key.convert(&it->first); - p->val.convert(&it->second); - } - std::sort(v.begin(), v.end(), type::detail::pair_first_less()); - return v; -} - -template -inline packer& operator<< (packer& o, const type::assoc_vector& v) -{ - o.pack_map(v.size()); - for(typename type::assoc_vector::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(it->first); - o.pack(it->second); - } - return o; -} - -template -inline void operator<< (object::with_zone& o, const type::assoc_vector& v) -{ - o.type = type::MAP; - if(v.empty()) { - o.via.map.ptr = NULL; - o.via.map.size = 0; - } else { - object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size()); - object_kv* const pend = p + v.size(); - o.via.map.ptr = p; - o.via.map.size = v.size(); - typename type::assoc_vector::const_iterator it(v.begin()); - do { - p->key = object(it->first, o.zone); - p->val = object(it->second, o.zone); - ++p; - ++it; - } while(p < pend); - } -} - - -template -inline std::map operator>> (object o, std::map& v) -{ - if(o.type != type::MAP) { throw type_error(); } - object_kv* p(o.via.map.ptr); - object_kv* const pend(o.via.map.ptr + o.via.map.size); - for(; p != pend; ++p) { - K key; - p->key.convert(&key); - typename std::map::iterator it(v.lower_bound(key)); - if(it != v.end() && !(key < it->first)) { - p->val.convert(&it->second); - } else { - V val; - p->val.convert(&val); - v.insert(it, std::pair(key, val)); - } - } - return v; -} - -template -inline packer& operator<< (packer& o, const std::map& v) -{ - o.pack_map(v.size()); - for(typename std::map::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(it->first); - o.pack(it->second); - } - return o; -} - -template -inline void operator<< (object::with_zone& o, const std::map& v) -{ - o.type = type::MAP; - if(v.empty()) { - o.via.map.ptr = NULL; - o.via.map.size = 0; - } else { - object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size()); - object_kv* const pend = p + v.size(); - o.via.map.ptr = p; - o.via.map.size = v.size(); - typename std::map::const_iterator it(v.begin()); - do { - p->key = object(it->first, o.zone); - p->val = object(it->second, o.zone); - ++p; - ++it; - } while(p < pend); - } -} - - -template -inline std::multimap operator>> (object o, std::multimap& v) -{ - if(o.type != type::MAP) { throw type_error(); } - object_kv* p(o.via.map.ptr); - object_kv* const pend(o.via.map.ptr + o.via.map.size); - for(; p != pend; ++p) { - std::pair value; - p->key.convert(&value.first); - p->val.convert(&value.second); - v.insert(value); - } - return v; -} - -template -inline packer& operator<< (packer& o, const std::multimap& v) -{ - o.pack_map(v.size()); - for(typename std::multimap::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(it->first); - o.pack(it->second); - } - return o; -} - -template -inline void operator<< (object::with_zone& o, const std::multimap& v) -{ - o.type = type::MAP; - if(v.empty()) { - o.via.map.ptr = NULL; - o.via.map.size = 0; - } else { - object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size()); - object_kv* const pend = p + v.size(); - o.via.map.ptr = p; - o.via.map.size = v.size(); - typename std::multimap::const_iterator it(v.begin()); - do { - p->key = object(it->first, o.zone); - p->val = object(it->second, o.zone); - ++p; - ++it; - } while(p < pend); - } -} - - -} // namespace msgpack - -#endif /* msgpack/type/map.hpp */ - diff --git a/src/msgpack/type/raw.hpp b/src/msgpack/type/raw.hpp deleted file mode 100644 index 87d188f6..00000000 --- a/src/msgpack/type/raw.hpp +++ /dev/null @@ -1,94 +0,0 @@ -// -// 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 "msgpack/object.hpp" -#include -#include - -namespace msgpack { - -namespace type { - -struct raw_ref { - raw_ref() : size(0), ptr(NULL) {} - 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 && 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 memcmp(ptr, x.ptr, size) < 0; } - else { return size < x.size; } - } - - bool operator> (const raw_ref& x) const - { - if(size == x.size) { return memcmp(ptr, x.ptr, size) > 0; } - else { return size > x.size; } - } -}; - -} // namespace type - - -inline type::raw_ref& operator>> (object o, type::raw_ref& v) -{ - if(o.type != type::RAW) { throw type_error(); } - v.ptr = o.via.raw.ptr; - v.size = o.via.raw.size; - return v; -} - -template -inline packer& operator<< (packer& o, const type::raw_ref& v) -{ - o.pack_raw(v.size); - o.pack_raw_body(v.ptr, v.size); - return o; -} - -inline void operator<< (object& o, const type::raw_ref& v) -{ - o.type = type::RAW; - o.via.raw.ptr = v.ptr; - o.via.raw.size = v.size; -} - -inline void operator<< (object::with_zone& o, const type::raw_ref& v) - { static_cast(o) << v; } - - -} // namespace msgpack - -#endif /* msgpack/type/raw.hpp */ - diff --git a/src/msgpack/type/set.hpp b/src/msgpack/type/set.hpp deleted file mode 100644 index bcf1030a..00000000 --- a/src/msgpack/type/set.hpp +++ /dev/null @@ -1,122 +0,0 @@ -// -// 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_SET_HPP__ -#define MSGPACK_TYPE_SET_HPP__ - -#include "msgpack/object.hpp" -#include - -namespace msgpack { - - -template -inline std::set& operator>> (object o, std::set& v) -{ - if(o.type != type::ARRAY) { throw type_error(); } - object* p = o.via.array.ptr + o.via.array.size; - object* const pbegin = o.via.array.ptr; - while(p > pbegin) { - --p; - v.insert(p->as()); - } - return v; -} - -template -inline packer& operator<< (packer& o, const std::set& v) -{ - o.pack_array(v.size()); - for(typename std::set::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(*it); - } - return o; -} - -template -inline void operator<< (object::with_zone& o, const std::set& v) -{ - o.type = type::ARRAY; - if(v.empty()) { - o.via.array.ptr = NULL; - o.via.array.size = 0; - } else { - object* p = (object*)o.zone->malloc(sizeof(object)*v.size()); - object* const pend = p + v.size(); - o.via.array.ptr = p; - o.via.array.size = v.size(); - typename std::set::const_iterator it(v.begin()); - do { - *p = object(*it, o.zone); - ++p; - ++it; - } while(p < pend); - } -} - - -template -inline std::multiset& operator>> (object o, std::multiset& v) -{ - if(o.type != type::ARRAY) { throw type_error(); } - object* p = o.via.array.ptr + o.via.array.size; - object* const pbegin = o.via.array.ptr; - while(p > pbegin) { - --p; - v.insert(p->as()); - } - return v; -} - -template -inline packer& operator<< (packer& o, const std::multiset& v) -{ - o.pack_array(v.size()); - for(typename std::multiset::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(*it); - } - return o; -} - -template -inline void operator<< (object::with_zone& o, const std::multiset& v) -{ - o.type = type::ARRAY; - if(v.empty()) { - o.via.array.ptr = NULL; - o.via.array.size = 0; - } else { - object* p = (object*)o.zone->malloc(sizeof(object)*v.size()); - object* const pend = p + v.size(); - o.via.array.ptr = p; - o.via.array.size = v.size(); - typename std::multiset::const_iterator it(v.begin()); - do { - *p = object(*it, o.zone); - ++p; - ++it; - } while(p < pend); - } -} - - -} // namespace msgpack - -#endif /* msgpack/type/set.hpp */ - diff --git a/src/msgpack/type/tr1/unordered_map.hpp b/src/msgpack/type/tr1/unordered_map.hpp deleted file mode 100644 index 62982f0a..00000000 --- a/src/msgpack/type/tr1/unordered_map.hpp +++ /dev/null @@ -1,152 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2008-2009 FURUHASHI Sadayuki -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP__ -#define MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP__ - -#include "msgpack/object.hpp" - -#define LIBSTDCXX_HAS_STD_UNORDERED_MAP defined(__GLIBCXX__) && __GLIBCXX__ >= 20090421 \ - && (__cplusplus >= 201103L || __GXX_EXPERIMENTAL_CXX0X__) - -#if LIBSTDCXX_HAS_STD_UNORDERED_MAP || defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) - -#define MSGPACK_HAS_STD_UNOURDERED_MAP -#include -#define MSGPACK_STD_TR1 std - -#else // LIBSTDCXX_HAS_STD_UNORDERED_MAP || defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) - -#if __GNUC__ >= 4 - -#define MSGPACK_HAS_STD_TR1_UNOURDERED_MAP - -#include -#define MSGPACK_STD_TR1 std::tr1 - -#endif // __GNUC__ >= 4 - -#endif // LIBSTDCXX_HAS_STD_UNORDERED_MAP || defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) - -namespace msgpack { - - -template -inline MSGPACK_STD_TR1::unordered_map operator>> (object o, MSGPACK_STD_TR1::unordered_map& v) -{ - if(o.type != type::MAP) { throw type_error(); } - object_kv* p(o.via.map.ptr); - object_kv* const pend(o.via.map.ptr + o.via.map.size); - for(; p != pend; ++p) { - K key; - p->key.convert(&key); - p->val.convert(&v[key]); - } - return v; -} - -template -inline packer& operator<< (packer& o, const MSGPACK_STD_TR1::unordered_map& v) -{ - o.pack_map(v.size()); - for(typename MSGPACK_STD_TR1::unordered_map::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(it->first); - o.pack(it->second); - } - return o; -} - -template -inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_map& v) -{ - o.type = type::MAP; - if(v.empty()) { - o.via.map.ptr = NULL; - o.via.map.size = 0; - } else { - object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size()); - object_kv* const pend = p + v.size(); - o.via.map.ptr = p; - o.via.map.size = v.size(); - typename MSGPACK_STD_TR1::unordered_map::const_iterator it(v.begin()); - do { - p->key = object(it->first, o.zone); - p->val = object(it->second, o.zone); - ++p; - ++it; - } while(p < pend); - } -} - - -template -inline MSGPACK_STD_TR1::unordered_multimap operator>> (object o, MSGPACK_STD_TR1::unordered_multimap& v) -{ - if(o.type != type::MAP) { throw type_error(); } - object_kv* p(o.via.map.ptr); - object_kv* const pend(o.via.map.ptr + o.via.map.size); - for(; p != pend; ++p) { - std::pair value; - p->key.convert(&value.first); - p->val.convert(&value.second); - v.insert(value); - } - return v; -} - -template -inline packer& operator<< (packer& o, const MSGPACK_STD_TR1::unordered_multimap& v) -{ - o.pack_map(v.size()); - for(typename MSGPACK_STD_TR1::unordered_multimap::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(it->first); - o.pack(it->second); - } - return o; -} - -template -inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_multimap& v) -{ - o.type = type::MAP; - if(v.empty()) { - o.via.map.ptr = NULL; - o.via.map.size = 0; - } else { - object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size()); - object_kv* const pend = p + v.size(); - o.via.map.ptr = p; - o.via.map.size = v.size(); - typename MSGPACK_STD_TR1::unordered_multimap::const_iterator it(v.begin()); - do { - p->key = object(it->first, o.zone); - p->val = object(it->second, o.zone); - ++p; - ++it; - } while(p < pend); - } -} - - -} // namespace msgpack - -#undef MSGPACK_STD_TR1 - -#endif /* msgpack/type/map.hpp */ - diff --git a/src/msgpack/type/tr1/unordered_set.hpp b/src/msgpack/type/tr1/unordered_set.hpp deleted file mode 100644 index cb69f5da..00000000 --- a/src/msgpack/type/tr1/unordered_set.hpp +++ /dev/null @@ -1,145 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2008-2009 FURUHASHI Sadayuki -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_TYPE_TR1_UNORDERED_SET_HPP__ -#define MSGPACK_TYPE_TR1_UNORDERED_SET_HPP__ - -#include "msgpack/object.hpp" - -#define LIBSTDCXX_HAS_STD_UNORDERED_SET defined(__GLIBCXX__) && __GLIBCXX__ >= 20090421 \ - && (__cplusplus >= 201103L || __GXX_EXPERIMENTAL_CXX0X__) - -#if LIBSTDCXX_HAS_STD_UNORDERED_SET || defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) - -#define MSGPACK_HAS_STD_UNOURDERED_SET -#include -#define MSGPACK_STD_TR1 std - -#else // LIBSTDCXX_HAS_STD_UNORDERED_SET || defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) - -#if __GNUC__ >= 4 - -#define MSGPACK_HAS_STD_TR1_UNOURDERED_SET - -#include -#define MSGPACK_STD_TR1 std::tr1 - -#endif // __GNUC__ >= 4 - -#endif // LIBSTDCXX_HAS_STD_UNORDERED_SET || defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) - -namespace msgpack { - - -template -inline MSGPACK_STD_TR1::unordered_set& operator>> (object o, MSGPACK_STD_TR1::unordered_set& v) -{ - if(o.type != type::ARRAY) { throw type_error(); } - object* p = o.via.array.ptr + o.via.array.size; - object* const pbegin = o.via.array.ptr; - while(p > pbegin) { - --p; - v.insert(p->as()); - } - return v; -} - -template -inline packer& operator<< (packer& o, const MSGPACK_STD_TR1::unordered_set& v) -{ - o.pack_array(v.size()); - for(typename MSGPACK_STD_TR1::unordered_set::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(*it); - } - return o; -} - -template -inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_set& v) -{ - o.type = type::ARRAY; - if(v.empty()) { - o.via.array.ptr = NULL; - o.via.array.size = 0; - } else { - object* p = (object*)o.zone->malloc(sizeof(object)*v.size()); - object* const pend = p + v.size(); - o.via.array.ptr = p; - o.via.array.size = v.size(); - typename MSGPACK_STD_TR1::unordered_set::const_iterator it(v.begin()); - do { - *p = object(*it, o.zone); - ++p; - ++it; - } while(p < pend); - } -} - - -template -inline MSGPACK_STD_TR1::unordered_multiset& operator>> (object o, MSGPACK_STD_TR1::unordered_multiset& v) -{ - if(o.type != type::ARRAY) { throw type_error(); } - object* p = o.via.array.ptr + o.via.array.size; - object* const pbegin = o.via.array.ptr; - while(p > pbegin) { - --p; - v.insert(p->as()); - } - return v; -} - -template -inline packer& operator<< (packer& o, const MSGPACK_STD_TR1::unordered_multiset& v) -{ - o.pack_array(v.size()); - for(typename MSGPACK_STD_TR1::unordered_multiset::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(*it); - } - return o; -} - -template -inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_multiset& v) -{ - o.type = type::ARRAY; - if(v.empty()) { - o.via.array.ptr = NULL; - o.via.array.size = 0; - } else { - object* p = (object*)o.zone->malloc(sizeof(object)*v.size()); - object* const pend = p + v.size(); - o.via.array.ptr = p; - o.via.array.size = v.size(); - typename MSGPACK_STD_TR1::unordered_multiset::const_iterator it(v.begin()); - do { - *p = object(*it, o.zone); - ++p; - ++it; - } while(p < pend); - } -} - - -} // namespace msgpack - -#undef MSGPACK_STD_TR1 - -#endif /* msgpack/type/set.hpp */ - diff --git a/src/msgpack/type/tuple.hpp b/src/msgpack/type/tuple.hpp deleted file mode 100644 index 7a893dca..00000000 --- a/src/msgpack/type/tuple.hpp +++ /dev/null @@ -1,13691 +0,0 @@ -// -// 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_TUPLE_HPP__ -#define MSGPACK_TYPE_TUPLE_HPP__ - -#include "msgpack/object.hpp" - -namespace msgpack { - -namespace type { - -// FIXME operator== -// FIXME operator!= - - -template -struct tuple; - -template -struct tuple_element; - -template -struct const_tuple_element; - -template -struct tuple_type { - typedef T type; - typedef T value_type; - typedef T& reference; - typedef const T& const_reference; - typedef const T& transparent_reference; -}; - -template -struct tuple_type { - typedef T type; - typedef T& value_type; - typedef T& reference; - typedef const T& const_reference; - typedef T& transparent_reference; -}; - -template -struct tuple_type { - typedef T type; - typedef T& value_type; - typedef T& reference; - typedef const T& const_reference; - typedef const T& transparent_reference; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : _x(x.a17) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : _x(x.a17) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : _x(x.a18) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : _x(x.a17) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : _x(x.a18) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : _x(x.a19) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : _x(x.a17) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : _x(x.a18) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : _x(x.a19) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : _x(x.a20) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : _x(x.a17) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : _x(x.a18) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : _x(x.a19) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : _x(x.a20) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : _x(x.a21) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : _x(x.a17) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : _x(x.a18) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : _x(x.a19) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : _x(x.a20) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : _x(x.a21) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : _x(x.a22) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : _x(x.a17) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : _x(x.a18) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : _x(x.a19) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : _x(x.a20) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : _x(x.a21) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : _x(x.a22) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : _x(x.a23) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : _x(x.a17) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : _x(x.a18) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : _x(x.a19) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : _x(x.a20) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : _x(x.a21) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : _x(x.a22) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : _x(x.a23) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : _x(x.a24) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : _x(x.a17) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : _x(x.a18) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : _x(x.a19) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : _x(x.a20) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : _x(x.a21) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : _x(x.a22) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : _x(x.a23) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : _x(x.a24) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 25> : tuple_type { - tuple_element(tuple& x) : _x(x.a25) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : _x(x.a17) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : _x(x.a18) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : _x(x.a19) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : _x(x.a20) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : _x(x.a21) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : _x(x.a22) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : _x(x.a23) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : _x(x.a24) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 25> : tuple_type { - tuple_element(tuple& x) : _x(x.a25) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 26> : tuple_type { - tuple_element(tuple& x) : _x(x.a26) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : _x(x.a17) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : _x(x.a18) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : _x(x.a19) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : _x(x.a20) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : _x(x.a21) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : _x(x.a22) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : _x(x.a23) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : _x(x.a24) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 25> : tuple_type { - tuple_element(tuple& x) : _x(x.a25) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 26> : tuple_type { - tuple_element(tuple& x) : _x(x.a26) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 27> : tuple_type { - tuple_element(tuple& x) : _x(x.a27) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : _x(x.a17) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : _x(x.a18) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : _x(x.a19) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : _x(x.a20) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : _x(x.a21) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : _x(x.a22) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : _x(x.a23) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : _x(x.a24) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 25> : tuple_type { - tuple_element(tuple& x) : _x(x.a25) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 26> : tuple_type { - tuple_element(tuple& x) : _x(x.a26) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 27> : tuple_type { - tuple_element(tuple& x) : _x(x.a27) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 28> : tuple_type { - tuple_element(tuple& x) : _x(x.a28) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : _x(x.a17) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : _x(x.a18) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : _x(x.a19) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : _x(x.a20) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : _x(x.a21) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : _x(x.a22) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : _x(x.a23) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : _x(x.a24) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 25> : tuple_type { - tuple_element(tuple& x) : _x(x.a25) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 26> : tuple_type { - tuple_element(tuple& x) : _x(x.a26) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 27> : tuple_type { - tuple_element(tuple& x) : _x(x.a27) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 28> : tuple_type { - tuple_element(tuple& x) : _x(x.a28) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 29> : tuple_type { - tuple_element(tuple& x) : _x(x.a29) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : _x(x.a17) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : _x(x.a18) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : _x(x.a19) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : _x(x.a20) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : _x(x.a21) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : _x(x.a22) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : _x(x.a23) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : _x(x.a24) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 25> : tuple_type { - tuple_element(tuple& x) : _x(x.a25) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 26> : tuple_type { - tuple_element(tuple& x) : _x(x.a26) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 27> : tuple_type { - tuple_element(tuple& x) : _x(x.a27) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 28> : tuple_type { - tuple_element(tuple& x) : _x(x.a28) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 29> : tuple_type { - tuple_element(tuple& x) : _x(x.a29) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 30> : tuple_type { - tuple_element(tuple& x) : _x(x.a30) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : _x(x.a17) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : _x(x.a18) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : _x(x.a19) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : _x(x.a20) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : _x(x.a21) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : _x(x.a22) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : _x(x.a23) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : _x(x.a24) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 25> : tuple_type { - tuple_element(tuple& x) : _x(x.a25) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 26> : tuple_type { - tuple_element(tuple& x) : _x(x.a26) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 27> : tuple_type { - tuple_element(tuple& x) : _x(x.a27) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 28> : tuple_type { - tuple_element(tuple& x) : _x(x.a28) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 29> : tuple_type { - tuple_element(tuple& x) : _x(x.a29) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 30> : tuple_type { - tuple_element(tuple& x) : _x(x.a30) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - -template -struct tuple_element, 31> : tuple_type { - tuple_element(tuple& x) : _x(x.a31) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::reference _x; -}; - - - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a17) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a17) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a18) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a17) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a18) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a19) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a17) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a18) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a19) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a20) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a17) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a18) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a19) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a20) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a21) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a17) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a18) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a19) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a20) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a21) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a22) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a17) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a18) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a19) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a20) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a21) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a22) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a23) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a17) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a18) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a19) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a20) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a21) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a22) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a23) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a24) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a17) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a18) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a19) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a20) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a21) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a22) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a23) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a24) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 25> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a25) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a17) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a18) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a19) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a20) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a21) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a22) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a23) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a24) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 25> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a25) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 26> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a26) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a17) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a18) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a19) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a20) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a21) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a22) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a23) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a24) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 25> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a25) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 26> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a26) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 27> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a27) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a17) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a18) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a19) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a20) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a21) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a22) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a23) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a24) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 25> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a25) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 26> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a26) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 27> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a27) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 28> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a28) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a17) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a18) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a19) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a20) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a21) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a22) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a23) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a24) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 25> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a25) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 26> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a26) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 27> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a27) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 28> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a28) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 29> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a29) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a17) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a18) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a19) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a20) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a21) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a22) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a23) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a24) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 25> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a25) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 26> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a26) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 27> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a27) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 28> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a28) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 29> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a29) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 30> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a30) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a17) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a18) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a19) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a20) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a21) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a22) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a23) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a24) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 25> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a25) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 26> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a26) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 27> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a27) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 28> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a28) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 29> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a29) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 30> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a30) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - -template -struct const_tuple_element, 31> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a31) {} - typename tuple_type::const_reference get() const { return _x; } -private: - typename tuple_type::const_reference _x; -}; - - - -template <> -struct tuple<> { - tuple() {} - tuple(object o) { o.convert(this); } - typedef tuple<> value_type; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0) : - a0(_a0) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1) : - a0(_a0), a1(_a1) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2) : - a0(_a0), a1(_a1), a2(_a2) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; - A17 a17; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; - A17 a17; - A18 a18; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; - A17 a17; - A18 a18; - A19 a19; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; - A17 a17; - A18 a18; - A19 a19; - A20 a20; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; - A17 a17; - A18 a18; - A19 a19; - A20 a20; - A21 a21; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; - A17 a17; - A18 a18; - A19 a19; - A20 a20; - A21 a21; - A22 a22; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; - A17 a17; - A18 a18; - A19 a19; - A20 a20; - A21 a21; - A22 a22; - A23 a23; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; - A17 a17; - A18 a18; - A19 a19; - A20 a20; - A21 a21; - A22 a22; - A23 a23; - A24 a24; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; - A17 a17; - A18 a18; - A19 a19; - A20 a20; - A21 a21; - A22 a22; - A23 a23; - A24 a24; - A25 a25; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; - A17 a17; - A18 a18; - A19 a19; - A20 a20; - A21 a21; - A22 a22; - A23 a23; - A24 a24; - A25 a25; - A26 a26; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; - A17 a17; - A18 a18; - A19 a19; - A20 a20; - A21 a21; - A22 a22; - A23 a23; - A24 a24; - A25 a25; - A26 a26; - A27 a27; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27, typename tuple_type::transparent_reference _a28) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; - A17 a17; - A18 a18; - A19 a19; - A20 a20; - A21 a21; - A22 a22; - A23 a23; - A24 a24; - A25 a25; - A26 a26; - A27 a27; - A28 a28; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27, typename tuple_type::transparent_reference _a28, typename tuple_type::transparent_reference _a29) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28), a29(_a29) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; - A17 a17; - A18 a18; - A19 a19; - A20 a20; - A21 a21; - A22 a22; - A23 a23; - A24 a24; - A25 a25; - A26 a26; - A27 a27; - A28 a28; - A29 a29; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27, typename tuple_type::transparent_reference _a28, typename tuple_type::transparent_reference _a29, typename tuple_type::transparent_reference _a30) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28), a29(_a29), a30(_a30) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; - A17 a17; - A18 a18; - A19 a19; - A20 a20; - A21 a21; - A22 a22; - A23 a23; - A24 a24; - A25 a25; - A26 a26; - A27 a27; - A28 a28; - A29 a29; - A30 a30; -}; - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27, typename tuple_type::transparent_reference _a28, typename tuple_type::transparent_reference _a29, typename tuple_type::transparent_reference _a30, typename tuple_type::transparent_reference _a31) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28), a29(_a29), a30(_a30), a31(_a31) {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; - A17 a17; - A18 a18; - A19 a19; - A20 a20; - A21 a21; - A22 a22; - A23 a23; - A24 a24; - A25 a25; - A26 a26; - A27 a27; - A28 a28; - A29 a29; - A30 a30; - A31 a31; -}; - - -inline tuple<> make_tuple() -{ - return tuple<>(); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0) -{ - return tuple(a0); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1) -{ - return tuple(a0, a1); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2) -{ - return tuple(a0, a1, a2); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3) -{ - return tuple(a0, a1, a2, a3); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4) -{ - return tuple(a0, a1, a2, a3, a4); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5) -{ - return tuple(a0, a1, a2, a3, a4, a5); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28, typename tuple_type::transparent_reference a29) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28, typename tuple_type::transparent_reference a29, typename tuple_type::transparent_reference a30) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30); -} - -template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28, typename tuple_type::transparent_reference a29, typename tuple_type::transparent_reference a30, typename tuple_type::transparent_reference a31) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31); -} - - -} // namespace type - - -inline type::tuple<>& operator>> ( - object o, - type::tuple<>& v) { - if(o.type != type::ARRAY) { throw type_error(); } - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 1) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 2) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 3) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 4) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 5) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 6) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 7) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 8) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 9) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 10) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 11) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 12) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 13) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 14) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 15) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 16) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 17) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 18) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); - o.via.array.ptr[17].convert::type>(&v.template get<17>()); - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 19) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); - o.via.array.ptr[17].convert::type>(&v.template get<17>()); - o.via.array.ptr[18].convert::type>(&v.template get<18>()); - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 20) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); - o.via.array.ptr[17].convert::type>(&v.template get<17>()); - o.via.array.ptr[18].convert::type>(&v.template get<18>()); - o.via.array.ptr[19].convert::type>(&v.template get<19>()); - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 21) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); - o.via.array.ptr[17].convert::type>(&v.template get<17>()); - o.via.array.ptr[18].convert::type>(&v.template get<18>()); - o.via.array.ptr[19].convert::type>(&v.template get<19>()); - o.via.array.ptr[20].convert::type>(&v.template get<20>()); - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 22) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); - o.via.array.ptr[17].convert::type>(&v.template get<17>()); - o.via.array.ptr[18].convert::type>(&v.template get<18>()); - o.via.array.ptr[19].convert::type>(&v.template get<19>()); - o.via.array.ptr[20].convert::type>(&v.template get<20>()); - o.via.array.ptr[21].convert::type>(&v.template get<21>()); - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 23) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); - o.via.array.ptr[17].convert::type>(&v.template get<17>()); - o.via.array.ptr[18].convert::type>(&v.template get<18>()); - o.via.array.ptr[19].convert::type>(&v.template get<19>()); - o.via.array.ptr[20].convert::type>(&v.template get<20>()); - o.via.array.ptr[21].convert::type>(&v.template get<21>()); - o.via.array.ptr[22].convert::type>(&v.template get<22>()); - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 24) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); - o.via.array.ptr[17].convert::type>(&v.template get<17>()); - o.via.array.ptr[18].convert::type>(&v.template get<18>()); - o.via.array.ptr[19].convert::type>(&v.template get<19>()); - o.via.array.ptr[20].convert::type>(&v.template get<20>()); - o.via.array.ptr[21].convert::type>(&v.template get<21>()); - o.via.array.ptr[22].convert::type>(&v.template get<22>()); - o.via.array.ptr[23].convert::type>(&v.template get<23>()); - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 25) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); - o.via.array.ptr[17].convert::type>(&v.template get<17>()); - o.via.array.ptr[18].convert::type>(&v.template get<18>()); - o.via.array.ptr[19].convert::type>(&v.template get<19>()); - o.via.array.ptr[20].convert::type>(&v.template get<20>()); - o.via.array.ptr[21].convert::type>(&v.template get<21>()); - o.via.array.ptr[22].convert::type>(&v.template get<22>()); - o.via.array.ptr[23].convert::type>(&v.template get<23>()); - o.via.array.ptr[24].convert::type>(&v.template get<24>()); - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 26) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); - o.via.array.ptr[17].convert::type>(&v.template get<17>()); - o.via.array.ptr[18].convert::type>(&v.template get<18>()); - o.via.array.ptr[19].convert::type>(&v.template get<19>()); - o.via.array.ptr[20].convert::type>(&v.template get<20>()); - o.via.array.ptr[21].convert::type>(&v.template get<21>()); - o.via.array.ptr[22].convert::type>(&v.template get<22>()); - o.via.array.ptr[23].convert::type>(&v.template get<23>()); - o.via.array.ptr[24].convert::type>(&v.template get<24>()); - o.via.array.ptr[25].convert::type>(&v.template get<25>()); - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 27) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); - o.via.array.ptr[17].convert::type>(&v.template get<17>()); - o.via.array.ptr[18].convert::type>(&v.template get<18>()); - o.via.array.ptr[19].convert::type>(&v.template get<19>()); - o.via.array.ptr[20].convert::type>(&v.template get<20>()); - o.via.array.ptr[21].convert::type>(&v.template get<21>()); - o.via.array.ptr[22].convert::type>(&v.template get<22>()); - o.via.array.ptr[23].convert::type>(&v.template get<23>()); - o.via.array.ptr[24].convert::type>(&v.template get<24>()); - o.via.array.ptr[25].convert::type>(&v.template get<25>()); - o.via.array.ptr[26].convert::type>(&v.template get<26>()); - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 28) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); - o.via.array.ptr[17].convert::type>(&v.template get<17>()); - o.via.array.ptr[18].convert::type>(&v.template get<18>()); - o.via.array.ptr[19].convert::type>(&v.template get<19>()); - o.via.array.ptr[20].convert::type>(&v.template get<20>()); - o.via.array.ptr[21].convert::type>(&v.template get<21>()); - o.via.array.ptr[22].convert::type>(&v.template get<22>()); - o.via.array.ptr[23].convert::type>(&v.template get<23>()); - o.via.array.ptr[24].convert::type>(&v.template get<24>()); - o.via.array.ptr[25].convert::type>(&v.template get<25>()); - o.via.array.ptr[26].convert::type>(&v.template get<26>()); - o.via.array.ptr[27].convert::type>(&v.template get<27>()); - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 29) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); - o.via.array.ptr[17].convert::type>(&v.template get<17>()); - o.via.array.ptr[18].convert::type>(&v.template get<18>()); - o.via.array.ptr[19].convert::type>(&v.template get<19>()); - o.via.array.ptr[20].convert::type>(&v.template get<20>()); - o.via.array.ptr[21].convert::type>(&v.template get<21>()); - o.via.array.ptr[22].convert::type>(&v.template get<22>()); - o.via.array.ptr[23].convert::type>(&v.template get<23>()); - o.via.array.ptr[24].convert::type>(&v.template get<24>()); - o.via.array.ptr[25].convert::type>(&v.template get<25>()); - o.via.array.ptr[26].convert::type>(&v.template get<26>()); - o.via.array.ptr[27].convert::type>(&v.template get<27>()); - o.via.array.ptr[28].convert::type>(&v.template get<28>()); - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 30) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); - o.via.array.ptr[17].convert::type>(&v.template get<17>()); - o.via.array.ptr[18].convert::type>(&v.template get<18>()); - o.via.array.ptr[19].convert::type>(&v.template get<19>()); - o.via.array.ptr[20].convert::type>(&v.template get<20>()); - o.via.array.ptr[21].convert::type>(&v.template get<21>()); - o.via.array.ptr[22].convert::type>(&v.template get<22>()); - o.via.array.ptr[23].convert::type>(&v.template get<23>()); - o.via.array.ptr[24].convert::type>(&v.template get<24>()); - o.via.array.ptr[25].convert::type>(&v.template get<25>()); - o.via.array.ptr[26].convert::type>(&v.template get<26>()); - o.via.array.ptr[27].convert::type>(&v.template get<27>()); - o.via.array.ptr[28].convert::type>(&v.template get<28>()); - o.via.array.ptr[29].convert::type>(&v.template get<29>()); - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 31) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); - o.via.array.ptr[17].convert::type>(&v.template get<17>()); - o.via.array.ptr[18].convert::type>(&v.template get<18>()); - o.via.array.ptr[19].convert::type>(&v.template get<19>()); - o.via.array.ptr[20].convert::type>(&v.template get<20>()); - o.via.array.ptr[21].convert::type>(&v.template get<21>()); - o.via.array.ptr[22].convert::type>(&v.template get<22>()); - o.via.array.ptr[23].convert::type>(&v.template get<23>()); - o.via.array.ptr[24].convert::type>(&v.template get<24>()); - o.via.array.ptr[25].convert::type>(&v.template get<25>()); - o.via.array.ptr[26].convert::type>(&v.template get<26>()); - o.via.array.ptr[27].convert::type>(&v.template get<27>()); - o.via.array.ptr[28].convert::type>(&v.template get<28>()); - o.via.array.ptr[29].convert::type>(&v.template get<29>()); - o.via.array.ptr[30].convert::type>(&v.template get<30>()); - return v; -} - -template -type::tuple& operator>> ( - object o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 32) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); - o.via.array.ptr[17].convert::type>(&v.template get<17>()); - o.via.array.ptr[18].convert::type>(&v.template get<18>()); - o.via.array.ptr[19].convert::type>(&v.template get<19>()); - o.via.array.ptr[20].convert::type>(&v.template get<20>()); - o.via.array.ptr[21].convert::type>(&v.template get<21>()); - o.via.array.ptr[22].convert::type>(&v.template get<22>()); - o.via.array.ptr[23].convert::type>(&v.template get<23>()); - o.via.array.ptr[24].convert::type>(&v.template get<24>()); - o.via.array.ptr[25].convert::type>(&v.template get<25>()); - o.via.array.ptr[26].convert::type>(&v.template get<26>()); - o.via.array.ptr[27].convert::type>(&v.template get<27>()); - o.via.array.ptr[28].convert::type>(&v.template get<28>()); - o.via.array.ptr[29].convert::type>(&v.template get<29>()); - o.via.array.ptr[30].convert::type>(&v.template get<30>()); - o.via.array.ptr[31].convert::type>(&v.template get<31>()); - return v; -} - - -template -const packer& operator<< ( - packer& o, - const type::tuple<>& v) { - o.pack_array(0); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(1); - - o.pack(v.template get<0>()); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(2); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(3); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(4); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(5); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(6); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(7); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(8); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(9); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(10); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(11); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(12); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(13); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(14); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(15); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(16); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(17); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(18); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(19); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(20); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(21); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(22); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(23); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - o.pack(v.template get<22>()); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(24); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - o.pack(v.template get<22>()); - o.pack(v.template get<23>()); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(25); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - o.pack(v.template get<22>()); - o.pack(v.template get<23>()); - o.pack(v.template get<24>()); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(26); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - o.pack(v.template get<22>()); - o.pack(v.template get<23>()); - o.pack(v.template get<24>()); - o.pack(v.template get<25>()); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(27); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - o.pack(v.template get<22>()); - o.pack(v.template get<23>()); - o.pack(v.template get<24>()); - o.pack(v.template get<25>()); - o.pack(v.template get<26>()); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(28); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - o.pack(v.template get<22>()); - o.pack(v.template get<23>()); - o.pack(v.template get<24>()); - o.pack(v.template get<25>()); - o.pack(v.template get<26>()); - o.pack(v.template get<27>()); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(29); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - o.pack(v.template get<22>()); - o.pack(v.template get<23>()); - o.pack(v.template get<24>()); - o.pack(v.template get<25>()); - o.pack(v.template get<26>()); - o.pack(v.template get<27>()); - o.pack(v.template get<28>()); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(30); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - o.pack(v.template get<22>()); - o.pack(v.template get<23>()); - o.pack(v.template get<24>()); - o.pack(v.template get<25>()); - o.pack(v.template get<26>()); - o.pack(v.template get<27>()); - o.pack(v.template get<28>()); - o.pack(v.template get<29>()); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(31); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - o.pack(v.template get<22>()); - o.pack(v.template get<23>()); - o.pack(v.template get<24>()); - o.pack(v.template get<25>()); - o.pack(v.template get<26>()); - o.pack(v.template get<27>()); - o.pack(v.template get<28>()); - o.pack(v.template get<29>()); - o.pack(v.template get<30>()); - return o; -} - -template -const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(32); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - o.pack(v.template get<22>()); - o.pack(v.template get<23>()); - o.pack(v.template get<24>()); - o.pack(v.template get<25>()); - o.pack(v.template get<26>()); - o.pack(v.template get<27>()); - o.pack(v.template get<28>()); - o.pack(v.template get<29>()); - o.pack(v.template get<30>()); - o.pack(v.template get<31>()); - return o; -} - - -inline void operator<< ( - object::with_zone& o, - const type::tuple<>& v) { - o.type = type::ARRAY; - o.via.array.ptr = NULL; - o.via.array.size = 0; -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*1); - o.via.array.size = 1; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*2); - o.via.array.size = 2; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*3); - o.via.array.size = 3; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*4); - o.via.array.size = 4; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*5); - o.via.array.size = 5; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*6); - o.via.array.size = 6; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*7); - o.via.array.size = 7; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*8); - o.via.array.size = 8; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*9); - o.via.array.size = 9; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*10); - o.via.array.size = 10; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*11); - o.via.array.size = 11; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*12); - o.via.array.size = 12; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*13); - o.via.array.size = 13; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*14); - o.via.array.size = 14; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*15); - o.via.array.size = 15; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*16); - o.via.array.size = 16; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*17); - o.via.array.size = 17; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*18); - o.via.array.size = 18; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = object(v.template get<17>(), o.zone); -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*19); - o.via.array.size = 19; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = object(v.template get<18>(), o.zone); -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*20); - o.via.array.size = 20; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = object(v.template get<19>(), o.zone); -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*21); - o.via.array.size = 21; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = object(v.template get<20>(), o.zone); -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*22); - o.via.array.size = 22; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = object(v.template get<21>(), o.zone); -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*23); - o.via.array.size = 23; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = object(v.template get<21>(), o.zone); - o.via.array.ptr[22] = object(v.template get<22>(), o.zone); -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*24); - o.via.array.size = 24; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = object(v.template get<21>(), o.zone); - o.via.array.ptr[22] = object(v.template get<22>(), o.zone); - o.via.array.ptr[23] = object(v.template get<23>(), o.zone); -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*25); - o.via.array.size = 25; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = object(v.template get<21>(), o.zone); - o.via.array.ptr[22] = object(v.template get<22>(), o.zone); - o.via.array.ptr[23] = object(v.template get<23>(), o.zone); - o.via.array.ptr[24] = object(v.template get<24>(), o.zone); -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*26); - o.via.array.size = 26; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = object(v.template get<21>(), o.zone); - o.via.array.ptr[22] = object(v.template get<22>(), o.zone); - o.via.array.ptr[23] = object(v.template get<23>(), o.zone); - o.via.array.ptr[24] = object(v.template get<24>(), o.zone); - o.via.array.ptr[25] = object(v.template get<25>(), o.zone); -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*27); - o.via.array.size = 27; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = object(v.template get<21>(), o.zone); - o.via.array.ptr[22] = object(v.template get<22>(), o.zone); - o.via.array.ptr[23] = object(v.template get<23>(), o.zone); - o.via.array.ptr[24] = object(v.template get<24>(), o.zone); - o.via.array.ptr[25] = object(v.template get<25>(), o.zone); - o.via.array.ptr[26] = object(v.template get<26>(), o.zone); -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*28); - o.via.array.size = 28; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = object(v.template get<21>(), o.zone); - o.via.array.ptr[22] = object(v.template get<22>(), o.zone); - o.via.array.ptr[23] = object(v.template get<23>(), o.zone); - o.via.array.ptr[24] = object(v.template get<24>(), o.zone); - o.via.array.ptr[25] = object(v.template get<25>(), o.zone); - o.via.array.ptr[26] = object(v.template get<26>(), o.zone); - o.via.array.ptr[27] = object(v.template get<27>(), o.zone); -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*29); - o.via.array.size = 29; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = object(v.template get<21>(), o.zone); - o.via.array.ptr[22] = object(v.template get<22>(), o.zone); - o.via.array.ptr[23] = object(v.template get<23>(), o.zone); - o.via.array.ptr[24] = object(v.template get<24>(), o.zone); - o.via.array.ptr[25] = object(v.template get<25>(), o.zone); - o.via.array.ptr[26] = object(v.template get<26>(), o.zone); - o.via.array.ptr[27] = object(v.template get<27>(), o.zone); - o.via.array.ptr[28] = object(v.template get<28>(), o.zone); -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*30); - o.via.array.size = 30; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = object(v.template get<21>(), o.zone); - o.via.array.ptr[22] = object(v.template get<22>(), o.zone); - o.via.array.ptr[23] = object(v.template get<23>(), o.zone); - o.via.array.ptr[24] = object(v.template get<24>(), o.zone); - o.via.array.ptr[25] = object(v.template get<25>(), o.zone); - o.via.array.ptr[26] = object(v.template get<26>(), o.zone); - o.via.array.ptr[27] = object(v.template get<27>(), o.zone); - o.via.array.ptr[28] = object(v.template get<28>(), o.zone); - o.via.array.ptr[29] = object(v.template get<29>(), o.zone); -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*31); - o.via.array.size = 31; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = object(v.template get<21>(), o.zone); - o.via.array.ptr[22] = object(v.template get<22>(), o.zone); - o.via.array.ptr[23] = object(v.template get<23>(), o.zone); - o.via.array.ptr[24] = object(v.template get<24>(), o.zone); - o.via.array.ptr[25] = object(v.template get<25>(), o.zone); - o.via.array.ptr[26] = object(v.template get<26>(), o.zone); - o.via.array.ptr[27] = object(v.template get<27>(), o.zone); - o.via.array.ptr[28] = object(v.template get<28>(), o.zone); - o.via.array.ptr[29] = object(v.template get<29>(), o.zone); - o.via.array.ptr[30] = object(v.template get<30>(), o.zone); -} - -template -inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*32); - o.via.array.size = 32; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = object(v.template get<21>(), o.zone); - o.via.array.ptr[22] = object(v.template get<22>(), o.zone); - o.via.array.ptr[23] = object(v.template get<23>(), o.zone); - o.via.array.ptr[24] = object(v.template get<24>(), o.zone); - o.via.array.ptr[25] = object(v.template get<25>(), o.zone); - o.via.array.ptr[26] = object(v.template get<26>(), o.zone); - o.via.array.ptr[27] = object(v.template get<27>(), o.zone); - o.via.array.ptr[28] = object(v.template get<28>(), o.zone); - o.via.array.ptr[29] = object(v.template get<29>(), o.zone); - o.via.array.ptr[30] = object(v.template get<30>(), o.zone); - o.via.array.ptr[31] = object(v.template get<31>(), o.zone); -} - - -} // namespace msgpack - - -//inline std::ostream& operator<< (std::ostream& o, const msgpack::type::tuple<>& v) { -// return o << "[]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << "]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << "]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << "]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << "]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << "]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << "]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << "]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << "]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << "]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << "]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << "]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << "]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << "]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << "]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << "]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << "]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << "]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << ", " << v.template get<17>() -// << "]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << ", " << v.template get<17>() -// << ", " << v.template get<18>() -// << "]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << ", " << v.template get<17>() -// << ", " << v.template get<18>() -// << ", " << v.template get<19>() -// << "]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << ", " << v.template get<17>() -// << ", " << v.template get<18>() -// << ", " << v.template get<19>() -// << ", " << v.template get<20>() -// << "]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << ", " << v.template get<17>() -// << ", " << v.template get<18>() -// << ", " << v.template get<19>() -// << ", " << v.template get<20>() -// << ", " << v.template get<21>() -// << "]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << ", " << v.template get<17>() -// << ", " << v.template get<18>() -// << ", " << v.template get<19>() -// << ", " << v.template get<20>() -// << ", " << v.template get<21>() -// << ", " << v.template get<22>() -// << "]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << ", " << v.template get<17>() -// << ", " << v.template get<18>() -// << ", " << v.template get<19>() -// << ", " << v.template get<20>() -// << ", " << v.template get<21>() -// << ", " << v.template get<22>() -// << ", " << v.template get<23>() -// << "]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << ", " << v.template get<17>() -// << ", " << v.template get<18>() -// << ", " << v.template get<19>() -// << ", " << v.template get<20>() -// << ", " << v.template get<21>() -// << ", " << v.template get<22>() -// << ", " << v.template get<23>() -// << ", " << v.template get<24>() -// << "]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << ", " << v.template get<17>() -// << ", " << v.template get<18>() -// << ", " << v.template get<19>() -// << ", " << v.template get<20>() -// << ", " << v.template get<21>() -// << ", " << v.template get<22>() -// << ", " << v.template get<23>() -// << ", " << v.template get<24>() -// << ", " << v.template get<25>() -// << "]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << ", " << v.template get<17>() -// << ", " << v.template get<18>() -// << ", " << v.template get<19>() -// << ", " << v.template get<20>() -// << ", " << v.template get<21>() -// << ", " << v.template get<22>() -// << ", " << v.template get<23>() -// << ", " << v.template get<24>() -// << ", " << v.template get<25>() -// << ", " << v.template get<26>() -// << "]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << ", " << v.template get<17>() -// << ", " << v.template get<18>() -// << ", " << v.template get<19>() -// << ", " << v.template get<20>() -// << ", " << v.template get<21>() -// << ", " << v.template get<22>() -// << ", " << v.template get<23>() -// << ", " << v.template get<24>() -// << ", " << v.template get<25>() -// << ", " << v.template get<26>() -// << ", " << v.template get<27>() -// << "]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << ", " << v.template get<17>() -// << ", " << v.template get<18>() -// << ", " << v.template get<19>() -// << ", " << v.template get<20>() -// << ", " << v.template get<21>() -// << ", " << v.template get<22>() -// << ", " << v.template get<23>() -// << ", " << v.template get<24>() -// << ", " << v.template get<25>() -// << ", " << v.template get<26>() -// << ", " << v.template get<27>() -// << ", " << v.template get<28>() -// << "]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << ", " << v.template get<17>() -// << ", " << v.template get<18>() -// << ", " << v.template get<19>() -// << ", " << v.template get<20>() -// << ", " << v.template get<21>() -// << ", " << v.template get<22>() -// << ", " << v.template get<23>() -// << ", " << v.template get<24>() -// << ", " << v.template get<25>() -// << ", " << v.template get<26>() -// << ", " << v.template get<27>() -// << ", " << v.template get<28>() -// << ", " << v.template get<29>() -// << "]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << ", " << v.template get<17>() -// << ", " << v.template get<18>() -// << ", " << v.template get<19>() -// << ", " << v.template get<20>() -// << ", " << v.template get<21>() -// << ", " << v.template get<22>() -// << ", " << v.template get<23>() -// << ", " << v.template get<24>() -// << ", " << v.template get<25>() -// << ", " << v.template get<26>() -// << ", " << v.template get<27>() -// << ", " << v.template get<28>() -// << ", " << v.template get<29>() -// << ", " << v.template get<30>() -// << "]"; -//} -// -//template -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << ", " << v.template get<17>() -// << ", " << v.template get<18>() -// << ", " << v.template get<19>() -// << ", " << v.template get<20>() -// << ", " << v.template get<21>() -// << ", " << v.template get<22>() -// << ", " << v.template get<23>() -// << ", " << v.template get<24>() -// << ", " << v.template get<25>() -// << ", " << v.template get<26>() -// << ", " << v.template get<27>() -// << ", " << v.template get<28>() -// << ", " << v.template get<29>() -// << ", " << v.template get<30>() -// << ", " << v.template get<31>() -// << "]"; -//} -// - -#endif /* msgpack/type/tuple.hpp */ - diff --git a/src/msgpack/type/tuple.hpp.erb b/src/msgpack/type/tuple.hpp.erb deleted file mode 100644 index ebef8163..00000000 --- a/src/msgpack/type/tuple.hpp.erb +++ /dev/null @@ -1,206 +0,0 @@ -// -// 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_TUPLE_HPP__ -#define MSGPACK_TYPE_TUPLE_HPP__ - -#include "msgpack/object.hpp" - -namespace msgpack { - -namespace type { - -// FIXME operator== -// FIXME operator!= -<% GENERATION_LIMIT = 31 %> - -template , typename A<%=i%> = void<%}%>> -struct tuple; - -template -struct tuple_element; - -template -struct const_tuple_element; - -template -struct tuple_type { - typedef T type; - typedef T value_type; - typedef T& reference; - typedef const T& const_reference; - typedef const T& transparent_reference; -}; - -template -struct tuple_type { - typedef T type; - typedef T& value_type; - typedef T& reference; - typedef const T& const_reference; - typedef T& transparent_reference; -}; - -template -struct tuple_type { - typedef T type; - typedef T& value_type; - typedef T& reference; - typedef const T& const_reference; - typedef const T& transparent_reference; -}; - -<%0.upto(GENERATION_LIMIT) {|i|%> -<%0.upto(i) {|j|%> -template , typename A<%=k%><%}%>> -struct tuple_element, A<%=k%><%}%>>, <%=j%>> : tuple_type> { - tuple_element(tuple, A<%=k%> <%}%>>& x) : _x(x.a<%=j%>) {} - typename tuple_type>::reference get() { return _x; } - typename tuple_type>::const_reference get() const { return _x; } -private: - typename tuple_type>::reference _x; -}; -<%}%> -<%}%> - -<%0.upto(GENERATION_LIMIT) {|i|%> -<%0.upto(i) {|j|%> -template , typename A<%=k%><%}%>> -struct const_tuple_element, A<%=k%><%}%>>, <%=j%>> : tuple_type> { - const_tuple_element(const tuple, A<%=k%><%}%>>& x) : _x(x.a<%=j%>) {} - typename tuple_type>::const_reference get() const { return _x; } -private: - typename tuple_type>::const_reference _x; -}; -<%}%> -<%}%> - -template <> -struct tuple<> { - tuple() {} - tuple(object o) { o.convert(this); } - typedef tuple<> value_type; -}; -<%0.upto(GENERATION_LIMIT) {|i|%> -template , typename A<%=j%><%}%>> -struct tuple, A<%=j%><%}%>> { - typedef tuple, A<%=j%><%}%>> value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0<%1.upto(i) {|j|%>, typename tuple_type>::transparent_reference _a<%=j%><%}%>) : - a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {} - tuple(object o) { o.convert(this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - <%0.upto(i) {|j|%> - A<%=j%> a<%=j%>;<%}%> -}; -<%}%> - -inline tuple<> make_tuple() -{ - return tuple<>(); -} -<%0.upto(GENERATION_LIMIT) {|i|%> -template , typename A<%=j%><%}%>> -tuple, A<%=j%><%}%>> make_tuple(typename tuple_type::transparent_reference a0<%1.upto(i) {|j|%>, typename tuple_type>::transparent_reference a<%=j%><%}%>) -{ - return tuple, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>); -} -<%}%> - -} // namespace type - - -inline type::tuple<>& operator>> ( - object o, - type::tuple<>& v) { - if(o.type != type::ARRAY) { throw type_error(); } - return v; -} -<%0.upto(GENERATION_LIMIT) {|i|%> -template , typename A<%=j%><%}%>> -type::tuple, A<%=j%><%}%>>& operator>> ( - object o, - type::tuple, A<%=j%><%}%>>& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < <%=i+1%>) { throw type_error(); } - <%0.upto(i) {|j|%> - o.via.array.ptr[<%=j%>].convert>::type>(&v.template get<<%=j%>>());<%}%> - return v; -} -<%}%> - -template -const packer& operator<< ( - packer& o, - const type::tuple<>& v) { - o.pack_array(0); - return o; -} -<%0.upto(GENERATION_LIMIT) {|i|%> -template , typename A<%=j%><%}%>> -const packer& operator<< ( - packer& o, - const type::tuple, A<%=j%><%}%>>& v) { - o.pack_array(<%=i+1%>); - <%0.upto(i) {|j|%> - o.pack(v.template get<<%=j%>>());<%}%> - return o; -} -<%}%> - -inline void operator<< ( - object::with_zone& o, - const type::tuple<>& v) { - o.type = type::ARRAY; - o.via.array.ptr = NULL; - o.via.array.size = 0; -} -<%0.upto(GENERATION_LIMIT) {|i|%> -template , typename A<%=j%><%}%>> -inline void operator<< ( - object::with_zone& o, - const type::tuple, A<%=j%><%}%>>& v) { - o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*<%=i+1%>); - o.via.array.size = <%=i+1%>; - <%0.upto(i) {|j|%> - o.via.array.ptr[<%=j%>] = object(v.template get<<%=j%>>(), o.zone);<%}%> -} -<%}%> - -} // namespace msgpack - - -//inline std::ostream& operator<< (std::ostream& o, const msgpack::type::tuple<>& v) { -// return o << "[]"; -//} -//<%0.upto(GENERATION_LIMIT) {|i|%> -//template , typename A<%=j%><%}%>> -//inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple, A<%=j%><%}%>>& v) { -// return o << "[" -// <%0.upto(i) {|j|%> -// <<<%if j != 0 then%> ", " <<<%end%> v.template get<<%=j%>>()<%}%> -// << "]"; -//} -//<%}%> - -#endif /* msgpack/type/tuple.hpp */ - diff --git a/src/msgpack/type/vector.hpp b/src/msgpack/type/vector.hpp deleted file mode 100644 index bd073ef8..00000000 --- a/src/msgpack/type/vector.hpp +++ /dev/null @@ -1,81 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2008-2009 FURUHASHI Sadayuki -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_TYPE_VECTOR_HPP__ -#define MSGPACK_TYPE_VECTOR_HPP__ - -#include "msgpack/object.hpp" -#include - -namespace msgpack { - - -template -inline std::vector& operator>> (object o, std::vector& v) -{ - if(o.type != type::ARRAY) { throw type_error(); } - v.resize(o.via.array.size); - if(o.via.array.size > 0) { - object* p = o.via.array.ptr; - object* const pend = o.via.array.ptr + o.via.array.size; - T* it = &v[0]; - do { - p->convert(it); - ++p; - ++it; - } while(p < pend); - } - return v; -} - -template -inline packer& operator<< (packer& o, const std::vector& v) -{ - o.pack_array(v.size()); - for(typename std::vector::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(*it); - } - return o; -} - -template -inline void operator<< (object::with_zone& o, const std::vector& v) -{ - o.type = type::ARRAY; - if(v.empty()) { - o.via.array.ptr = NULL; - o.via.array.size = 0; - } else { - object* p = (object*)o.zone->malloc(sizeof(object)*v.size()); - object* const pend = p + v.size(); - o.via.array.ptr = p; - o.via.array.size = v.size(); - typename std::vector::const_iterator it(v.begin()); - do { - *p = object(*it, o.zone); - ++p; - ++it; - } while(p < pend); - } -} - - -} // namespace msgpack - -#endif /* msgpack/type/vector.hpp */ - diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp deleted file mode 100644 index baca1176..00000000 --- a/src/msgpack/unpack.hpp +++ /dev/null @@ -1,374 +0,0 @@ -// -// MessagePack for C++ deserializing 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_UNPACK_HPP__ -#define MSGPACK_UNPACK_HPP__ - -#include "unpack.h" -#include "object.hpp" -#include "zone.hpp" -#include -#include - -// backward compatibility -#ifndef MSGPACK_UNPACKER_DEFAULT_INITIAL_BUFFER_SIZE -#define MSGPACK_UNPACKER_DEFAULT_INITIAL_BUFFER_SIZE MSGPACK_UNPACKER_INIT_BUFFER_SIZE -#endif - -namespace msgpack { - - -struct unpack_error : public std::runtime_error { - unpack_error(const std::string& msg) : - std::runtime_error(msg) { } -}; - - -class unpacked { -public: - unpacked() { } - - unpacked(object obj, std::auto_ptr z) : - m_obj(obj), m_zone(z) { } - - object& get() - { return m_obj; } - - const object& get() const - { return m_obj; } - - std::auto_ptr& zone() - { return m_zone; } - - const std::auto_ptr& zone() const - { return m_zone; } - -private: - object m_obj; - std::auto_ptr m_zone; -}; - - -class unpacker : public msgpack_unpacker { -public: - unpacker(size_t init_buffer_size = MSGPACK_UNPACKER_INIT_BUFFER_SIZE); - ~unpacker(); - -public: - /*! 1. reserve buffer. at least `size' bytes of capacity will be ready */ - void reserve_buffer(size_t size = MSGPACK_UNPACKER_RESERVE_SIZE); - - /*! 2. read data to the buffer() up to buffer_capacity() bytes */ - char* buffer(); - size_t buffer_capacity() const; - - /*! 3. specify the number of bytes actually copied */ - void buffer_consumed(size_t size); - - /*! 4. repeat next() until it retunrs false */ - bool next(unpacked* result); - - /*! 5. check if the size of message doesn't exceed assumption. */ - size_t message_size() const; - - // Basic usage of the unpacker is as following: - // - // msgpack::unpacker pac; - // while( /* input is readable */ ) { - // - // // 1. - // pac.reserve_buffer(32*1024); - // - // // 2. - // size_t bytes = input.readsome(pac.buffer(), pac.buffer_capacity()); - // - // // error handling ... - // - // // 3. - // pac.buffer_consumed(bytes); - // - // // 4. - // msgpack::unpacked result; - // while(pac.next(&result)) { - // // do some with the object with the zone. - // msgpack::object obj = result.get(); - // std::auto_ptr z = result.zone(); - // on_message(obj, z); - // - // //// boost::shared_ptr is also usable: - // // boost::shared_ptr life(z.release()); - // // on_message(result.get(), life); - // } - // - // // 5. - // if(pac.message_size() > 10*1024*1024) { - // throw std::runtime_error("message is too large"); - // } - // } - // - - /*! for backward compatibility */ - bool execute(); - - /*! for backward compatibility */ - object data(); - - /*! for backward compatibility */ - zone* release_zone(); - - /*! for backward compatibility */ - void reset_zone(); - - /*! for backward compatibility */ - void reset(); - -public: - // These functions are usable when non-MessagePack message follows after - // MessagePack message. - size_t parsed_size() const; - - /*! get address of the buffer that is not parsed */ - char* nonparsed_buffer(); - size_t nonparsed_size() const; - - /*! skip specified size of non-parsed buffer, leaving the buffer */ - // Note that the `size' argument must be smaller than nonparsed_size() - void skip_nonparsed_buffer(size_t size); - - /*! remove unparsed buffer from unpacker */ - // Note that reset() leaves non-parsed buffer. - void remove_nonparsed_buffer(); - -private: - typedef msgpack_unpacker base; - -private: - unpacker(const unpacker&); -}; - - -static void unpack(unpacked* result, - const char* data, size_t len, size_t* offset = NULL); - - -// obsolete -typedef enum { - UNPACK_SUCCESS = 2, - UNPACK_EXTRA_BYTES = 1, - UNPACK_CONTINUE = 0, - UNPACK_PARSE_ERROR = -1, -} unpack_return; - -// obsolete -static unpack_return unpack(const char* data, size_t len, size_t* off, - zone* z, object* result); - - -// obsolete -static object unpack(const char* data, size_t len, zone& z, size_t* off = NULL); - - -inline unpacker::unpacker(size_t initial_buffer_size) -{ - if(!msgpack_unpacker_init(this, initial_buffer_size)) { - throw std::bad_alloc(); - } -} - -inline unpacker::~unpacker() -{ - msgpack_unpacker_destroy(this); -} - - -inline void unpacker::reserve_buffer(size_t size) -{ - if(!msgpack_unpacker_reserve_buffer(this, size)) { - throw std::bad_alloc(); - } -} - -inline char* unpacker::buffer() -{ - return msgpack_unpacker_buffer(this); -} - -inline size_t unpacker::buffer_capacity() const -{ - return msgpack_unpacker_buffer_capacity(this); -} - -inline void unpacker::buffer_consumed(size_t size) -{ - return msgpack_unpacker_buffer_consumed(this, size); -} - -inline bool unpacker::next(unpacked* result) -{ - int ret = msgpack_unpacker_execute(this); - - if(ret < 0) { - throw unpack_error("parse error"); - } - - if(ret == 0) { - result->zone().reset(); - result->get() = object(); - return false; - - } else { - result->zone().reset( release_zone() ); - result->get() = data(); - reset(); - return true; - } -} - - -inline bool unpacker::execute() -{ - int ret = msgpack_unpacker_execute(this); - if(ret < 0) { - throw unpack_error("parse error"); - } else if(ret == 0) { - return false; - } else { - return true; - } -} - -inline object unpacker::data() -{ - return msgpack_unpacker_data(this); -} - -inline zone* unpacker::release_zone() -{ - return static_cast(msgpack_unpacker_release_zone(static_cast(this))); -} - -inline void unpacker::reset_zone() -{ - msgpack_unpacker_reset_zone(this); -} - -inline void unpacker::reset() -{ - msgpack_unpacker_reset(this); -} - - -inline size_t unpacker::message_size() const -{ - return msgpack_unpacker_message_size(this); -} - -inline size_t unpacker::parsed_size() const -{ - return msgpack_unpacker_parsed_size(this); -} - -inline char* unpacker::nonparsed_buffer() -{ - return base::buffer + base::off; -} - -inline size_t unpacker::nonparsed_size() const -{ - return base::used - base::off; -} - -inline void unpacker::skip_nonparsed_buffer(size_t size) -{ - base::off += size; -} - -inline void unpacker::remove_nonparsed_buffer() -{ - base::used = base::off; -} - - -inline void unpack(unpacked* result, - const char* data, size_t len, size_t* offset) -{ - msgpack::object obj; - std::auto_ptr z(new zone()); - - unpack_return ret = (unpack_return)msgpack_unpack( - data, len, offset, z.get(), - reinterpret_cast(&obj)); - - switch(ret) { - case UNPACK_SUCCESS: - result->get() = obj; - result->zone() = z; - return; - - case UNPACK_EXTRA_BYTES: - result->get() = obj; - result->zone() = z; - return; - - case UNPACK_CONTINUE: - throw unpack_error("insufficient bytes"); - - case UNPACK_PARSE_ERROR: - default: - throw unpack_error("parse error"); - } -} - - -// obsolete -inline unpack_return unpack(const char* data, size_t len, size_t* off, - zone* z, object* result) -{ - return (unpack_return)msgpack_unpack(data, len, off, - z, reinterpret_cast(result)); -} - -// obsolete -inline object unpack(const char* data, size_t len, zone& z, size_t* off) -{ - object result; - - switch( msgpack::unpack(data, len, off, &z, &result) ) { - case UNPACK_SUCCESS: - return result; - - case UNPACK_EXTRA_BYTES: - if(off) { - return result; - } else { - throw unpack_error("extra bytes"); - } - - case UNPACK_CONTINUE: - throw unpack_error("insufficient bytes"); - - case UNPACK_PARSE_ERROR: - default: - throw unpack_error("parse error"); - } -} - - -} // namespace msgpack - -#endif /* msgpack/unpack.hpp */ - diff --git a/src/msgpack/unpack_define.h b/src/msgpack/unpack_define.h deleted file mode 100644 index c6ecb90d..00000000 --- a/src/msgpack/unpack_define.h +++ /dev/null @@ -1,95 +0,0 @@ -/* - * MessagePack unpacking routine template - * - * Copyright (C) 2008-2010 FURUHASHI Sadayuki - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * 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_UNPACK_DEFINE_H__ -#define MSGPACK_UNPACK_DEFINE_H__ - -#include "msgpack/sysdep.h" -#include -#include -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - - -#ifndef MSGPACK_EMBED_STACK_SIZE -#define MSGPACK_EMBED_STACK_SIZE 32 -#endif - - -typedef enum { - CS_HEADER = 0x00, // nil - - //CS_ = 0x01, - //CS_ = 0x02, // false - //CS_ = 0x03, // true - - CS_BIN_8 = 0x04, - CS_BIN_16 = 0x05, - CS_BIN_32 = 0x06, - - //CS_EXT_8 = 0x07, - //CS_EXT_16 = 0x08, - //CS_EXT_32 = 0x09, - - CS_FLOAT = 0x0a, - CS_DOUBLE = 0x0b, - CS_UINT_8 = 0x0c, - CS_UINT_16 = 0x0d, - CS_UINT_32 = 0x0e, - CS_UINT_64 = 0x0f, - CS_INT_8 = 0x10, - CS_INT_16 = 0x11, - CS_INT_32 = 0x12, - CS_INT_64 = 0x13, - - //CS_FIXEXT_1 = 0x14, - //CS_FIXEXT_2 = 0x15, - //CS_FIXEXT_4 = 0x16, - //CS_FIXEXT_8 = 0x17, - //CS_FIXEXT_16 = 0x18, - - CS_RAW_8 = 0x19, // str8 - CS_RAW_16 = 0x1a, // str16 - CS_RAW_32 = 0x1b, // str32 - CS_ARRAY_16 = 0x1c, - CS_ARRAY_32 = 0x1d, - CS_MAP_16 = 0x1e, - CS_MAP_32 = 0x1f, - - //ACS_BIG_INT_VALUE, - //ACS_BIG_FLOAT_VALUE, - ACS_RAW_VALUE, -} msgpack_unpack_state; - - -typedef enum { - CT_ARRAY_ITEM, - CT_MAP_KEY, - CT_MAP_VALUE, -} msgpack_container_type; - - -#ifdef __cplusplus -} -#endif - -#endif /* msgpack/unpack_define.h */ - diff --git a/src/msgpack/unpack_template.h b/src/msgpack/unpack_template.h deleted file mode 100644 index 60611c6c..00000000 --- a/src/msgpack/unpack_template.h +++ /dev/null @@ -1,420 +0,0 @@ -/* - * MessagePack unpacking routine template - * - * Copyright (C) 2008-2010 FURUHASHI Sadayuki - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * 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_unpack_func -#error msgpack_unpack_func template is not defined -#endif - -#ifndef msgpack_unpack_callback -#error msgpack_unpack_callback template is not defined -#endif - -#ifndef msgpack_unpack_struct -#error msgpack_unpack_struct template is not defined -#endif - -#ifndef msgpack_unpack_struct_decl -#define msgpack_unpack_struct_decl(name) msgpack_unpack_struct(name) -#endif - -#ifndef msgpack_unpack_object -#error msgpack_unpack_object type is not defined -#endif - -#ifndef msgpack_unpack_user -#error msgpack_unpack_user type is not defined -#endif - -#ifndef USE_CASE_RANGE -#if !defined(_MSC_VER) -#define USE_CASE_RANGE -#endif -#endif - -msgpack_unpack_struct_decl(_stack) { - msgpack_unpack_object obj; - size_t count; - unsigned int ct; - msgpack_unpack_object map_key; -}; - -msgpack_unpack_struct_decl(_context) { - msgpack_unpack_user user; - unsigned int cs; - unsigned int trail; - unsigned int top; - /* - msgpack_unpack_struct(_stack)* stack; - unsigned int stack_size; - msgpack_unpack_struct(_stack) embed_stack[MSGPACK_EMBED_STACK_SIZE]; - */ - msgpack_unpack_struct(_stack) stack[MSGPACK_EMBED_STACK_SIZE]; -}; - - -msgpack_unpack_func(void, _init)(msgpack_unpack_struct(_context)* ctx) -{ - ctx->cs = CS_HEADER; - ctx->trail = 0; - ctx->top = 0; - /* - ctx->stack = ctx->embed_stack; - ctx->stack_size = MSGPACK_EMBED_STACK_SIZE; - */ - ctx->stack[0].obj = msgpack_unpack_callback(_root)(&ctx->user); -} - -/* -msgpack_unpack_func(void, _destroy)(msgpack_unpack_struct(_context)* ctx) -{ - if(ctx->stack_size != MSGPACK_EMBED_STACK_SIZE) { - free(ctx->stack); - } -} -*/ - -msgpack_unpack_func(msgpack_unpack_object, _data)(msgpack_unpack_struct(_context)* ctx) -{ - return (ctx)->stack[0].obj; -} - - -msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const char* data, size_t len, size_t* off) -{ - assert(len >= *off); - - const unsigned char* p = (unsigned char*)data + *off; - const unsigned char* const pe = (unsigned char*)data + len; - const void* n = NULL; - - unsigned int trail = ctx->trail; - unsigned int cs = ctx->cs; - unsigned int top = ctx->top; - msgpack_unpack_struct(_stack)* stack = ctx->stack; - /* - unsigned int stack_size = ctx->stack_size; - */ - msgpack_unpack_user* user = &ctx->user; - - msgpack_unpack_object obj; - msgpack_unpack_struct(_stack)* c = NULL; - - int ret; - -#define push_simple_value(func) \ - if(msgpack_unpack_callback(func)(user, &obj) < 0) { goto _failed; } \ - goto _push -#define push_fixed_value(func, arg) \ - if(msgpack_unpack_callback(func)(user, arg, &obj) < 0) { goto _failed; } \ - goto _push -#define push_variable_value(func, base, pos, len) \ - if(msgpack_unpack_callback(func)(user, \ - (const char*)base, (const char*)pos, len, &obj) < 0) { goto _failed; } \ - goto _push - -#define again_fixed_trail(_cs, trail_len) \ - trail = trail_len; \ - cs = _cs; \ - goto _fixed_trail_again -#define again_fixed_trail_if_zero(_cs, trail_len, ifzero) \ - trail = trail_len; \ - if(trail == 0) { goto ifzero; } \ - cs = _cs; \ - goto _fixed_trail_again - -#define start_container(func, count_, ct_) \ - if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ \ - if(msgpack_unpack_callback(func)(user, count_, &stack[top].obj) < 0) { goto _failed; } \ - if((count_) == 0) { obj = stack[top].obj; goto _push; } \ - stack[top].ct = ct_; \ - stack[top].count = count_; \ - ++top; \ - /*printf("container %d count %d stack %d\n",stack[top].obj,count_,top);*/ \ - /*printf("stack push %d\n", top);*/ \ - /* FIXME \ - if(top >= stack_size) { \ - if(stack_size == MSGPACK_EMBED_STACK_SIZE) { \ - size_t csize = sizeof(msgpack_unpack_struct(_stack)) * MSGPACK_EMBED_STACK_SIZE; \ - size_t nsize = csize * 2; \ - msgpack_unpack_struct(_stack)* tmp = (msgpack_unpack_struct(_stack)*)malloc(nsize); \ - if(tmp == NULL) { goto _failed; } \ - memcpy(tmp, ctx->stack, csize); \ - ctx->stack = stack = tmp; \ - ctx->stack_size = stack_size = MSGPACK_EMBED_STACK_SIZE * 2; \ - } else { \ - size_t nsize = sizeof(msgpack_unpack_struct(_stack)) * ctx->stack_size * 2; \ - msgpack_unpack_struct(_stack)* tmp = (msgpack_unpack_struct(_stack)*)realloc(ctx->stack, nsize); \ - if(tmp == NULL) { goto _failed; } \ - ctx->stack = stack = tmp; \ - ctx->stack_size = stack_size = stack_size * 2; \ - } \ - } \ - */ \ - goto _header_again - -#define NEXT_CS(p) \ - ((unsigned int)*p & 0x1f) - -#ifdef USE_CASE_RANGE -#define SWITCH_RANGE_BEGIN switch(*p) { -#define SWITCH_RANGE(FROM, TO) case FROM ... TO: -#define SWITCH_RANGE_DEFAULT default: -#define SWITCH_RANGE_END } -#else -#define SWITCH_RANGE_BEGIN { if(0) { -#define SWITCH_RANGE(FROM, TO) } else if(FROM <= *p && *p <= TO) { -#define SWITCH_RANGE_DEFAULT } else { -#define SWITCH_RANGE_END } } -#endif - - if(p == pe) { goto _out; } - do { - switch(cs) { - case CS_HEADER: - SWITCH_RANGE_BEGIN - SWITCH_RANGE(0x00, 0x7f) // Positive Fixnum - push_fixed_value(_uint8, *(uint8_t*)p); - SWITCH_RANGE(0xe0, 0xff) // Negative Fixnum - push_fixed_value(_int8, *(int8_t*)p); - SWITCH_RANGE(0xc0, 0xdf) // Variable - switch(*p) { - case 0xc0: // nil - push_simple_value(_nil); - //case 0xc1: // string - // again_terminal_trail(NEXT_CS(p), p+1); - case 0xc2: // false - push_simple_value(_false); - case 0xc3: // true - push_simple_value(_true); - case 0xc4: // bin 8 - case 0xc5: // bin 16 - case 0xc6: // bin 32 - again_fixed_trail(NEXT_CS(p), 1 << (((unsigned int)*p) & 0x03)); - //case 0xc7: - //case 0xc8: - //case 0xc9: - case 0xca: // float - case 0xcb: // double - case 0xcc: // unsigned int 8 - case 0xcd: // unsigned int 16 - case 0xce: // unsigned int 32 - case 0xcf: // unsigned int 64 - case 0xd0: // signed int 8 - case 0xd1: // signed int 16 - case 0xd2: // signed int 32 - case 0xd3: // signed int 64 - again_fixed_trail(NEXT_CS(p), 1 << (((unsigned int)*p) & 0x03)); - //case 0xd4: - //case 0xd5: - //case 0xd6: // big integer 16 - //case 0xd7: // big integer 32 - //case 0xd8: // big float 16 - case 0xd9: // raw 8 (str 8) - case 0xda: // raw 16 (str 16) - case 0xdb: // raw 32 (str 32) - again_fixed_trail(NEXT_CS(p), 1 << ((((unsigned int)*p) & 0x03) - 1)); - case 0xdc: // array 16 - case 0xdd: // array 32 - case 0xde: // map 16 - case 0xdf: // map 32 - again_fixed_trail(NEXT_CS(p), 2u << (((unsigned int)*p) & 0x01)); - default: - goto _failed; - } - SWITCH_RANGE(0xa0, 0xbf) // FixRaw - again_fixed_trail_if_zero(ACS_RAW_VALUE, ((unsigned int)*p & 0x1f), _raw_zero); - SWITCH_RANGE(0x90, 0x9f) // FixArray - start_container(_array, ((unsigned int)*p) & 0x0f, CT_ARRAY_ITEM); - SWITCH_RANGE(0x80, 0x8f) // FixMap - start_container(_map, ((unsigned int)*p) & 0x0f, CT_MAP_KEY); - - SWITCH_RANGE_DEFAULT - goto _failed; - SWITCH_RANGE_END - // end CS_HEADER - - - _fixed_trail_again: - ++p; - - default: - if((size_t)(pe - p) < trail) { goto _out; } - n = p; p += trail - 1; - switch(cs) { - //case CS_ - //case CS_ - case CS_FLOAT: { - union { uint32_t i; float f; } mem; - mem.i = _msgpack_load32(uint32_t,n); - push_fixed_value(_float, mem.f); } - case CS_DOUBLE: { - union { uint64_t i; double f; } mem; - mem.i = _msgpack_load64(uint64_t,n); -#if defined(__arm__) && !(__ARM_EABI__) // arm-oabi - // https://github.com/msgpack/msgpack-perl/pull/1 - mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); -#endif - push_fixed_value(_double, mem.f); } - case CS_UINT_8: - push_fixed_value(_uint8, *(uint8_t*)n); - case CS_UINT_16: - push_fixed_value(_uint16, _msgpack_load16(uint16_t,n)); - case CS_UINT_32: - push_fixed_value(_uint32, _msgpack_load32(uint32_t,n)); - case CS_UINT_64: - push_fixed_value(_uint64, _msgpack_load64(uint64_t,n)); - - case CS_INT_8: - push_fixed_value(_int8, *(int8_t*)n); - case CS_INT_16: - push_fixed_value(_int16, _msgpack_load16(int16_t,n)); - case CS_INT_32: - push_fixed_value(_int32, _msgpack_load32(int32_t,n)); - case CS_INT_64: - push_fixed_value(_int64, _msgpack_load64(int64_t,n)); - - //case CS_ - //case CS_ - //case CS_BIG_INT_16: - // again_fixed_trail_if_zero(ACS_BIG_INT_VALUE, _msgpack_load16(uint16_t,n), _big_int_zero); - //case CS_BIG_INT_32: - // again_fixed_trail_if_zero(ACS_BIG_INT_VALUE, _msgpack_load32(uint32_t,n), _big_int_zero); - //case ACS_BIG_INT_VALUE: - //_big_int_zero: - // // FIXME - // push_variable_value(_big_int, data, n, trail); - - //case CS_BIG_FLOAT_16: - // again_fixed_trail_if_zero(ACS_BIG_FLOAT_VALUE, _msgpack_load16(uint16_t,n), _big_float_zero); - //case CS_BIG_FLOAT_32: - // again_fixed_trail_if_zero(ACS_BIG_FLOAT_VALUE, _msgpack_load32(uint32_t,n), _big_float_zero); - //case ACS_BIG_FLOAT_VALUE: - //_big_float_zero: - // // FIXME - // push_variable_value(_big_float, data, n, trail); - - case CS_BIN_8: - case CS_RAW_8: - again_fixed_trail_if_zero(ACS_RAW_VALUE, *(uint8_t*)n, _raw_zero); - case CS_BIN_16: - case CS_RAW_16: - again_fixed_trail_if_zero(ACS_RAW_VALUE, _msgpack_load16(uint16_t,n), _raw_zero); - case CS_BIN_32: - case CS_RAW_32: - again_fixed_trail_if_zero(ACS_RAW_VALUE, _msgpack_load32(uint32_t,n), _raw_zero); - case ACS_RAW_VALUE: - _raw_zero: - push_variable_value(_raw, data, n, trail); - - case CS_ARRAY_16: - start_container(_array, _msgpack_load16(uint16_t,n), CT_ARRAY_ITEM); - case CS_ARRAY_32: - /* FIXME security guard */ - start_container(_array, _msgpack_load32(uint32_t,n), CT_ARRAY_ITEM); - - case CS_MAP_16: - start_container(_map, _msgpack_load16(uint16_t,n), CT_MAP_KEY); - case CS_MAP_32: - /* FIXME security guard */ - start_container(_map, _msgpack_load32(uint32_t,n), CT_MAP_KEY); - - default: - goto _failed; - } - } - -_push: - if(top == 0) { goto _finish; } - c = &stack[top-1]; - switch(c->ct) { - case CT_ARRAY_ITEM: - if(msgpack_unpack_callback(_array_item)(user, &c->obj, obj) < 0) { goto _failed; } - if(--c->count == 0) { - obj = c->obj; - --top; - /*printf("stack pop %d\n", top);*/ - goto _push; - } - goto _header_again; - case CT_MAP_KEY: - c->map_key = obj; - c->ct = CT_MAP_VALUE; - goto _header_again; - case CT_MAP_VALUE: - if(msgpack_unpack_callback(_map_item)(user, &c->obj, c->map_key, obj) < 0) { goto _failed; } - if(--c->count == 0) { - obj = c->obj; - --top; - /*printf("stack pop %d\n", top);*/ - goto _push; - } - c->ct = CT_MAP_KEY; - goto _header_again; - - default: - goto _failed; - } - -_header_again: - cs = CS_HEADER; - ++p; - } while(p != pe); - goto _out; - - -_finish: - stack[0].obj = obj; - ++p; - ret = 1; - /*printf("-- finish --\n"); */ - goto _end; - -_failed: - /*printf("** FAILED **\n"); */ - ret = -1; - goto _end; - -_out: - ret = 0; - goto _end; - -_end: - ctx->cs = cs; - ctx->trail = trail; - ctx->top = top; - *off = (size_t)(p - (const unsigned char*)data); - - return ret; -} - - -#undef msgpack_unpack_func -#undef msgpack_unpack_callback -#undef msgpack_unpack_struct -#undef msgpack_unpack_object -#undef msgpack_unpack_user - -#undef push_simple_value -#undef push_fixed_value -#undef push_variable_value -#undef again_fixed_trail -#undef again_fixed_trail_if_zero -#undef start_container - -#undef NEXT_CS - diff --git a/src/msgpack/vrefbuffer.hpp b/src/msgpack/vrefbuffer.hpp deleted file mode 100644 index 2cf7f89c..00000000 --- a/src/msgpack/vrefbuffer.hpp +++ /dev/null @@ -1,99 +0,0 @@ -// -// MessagePack for C++ zero-copy buffer implementation -// -// 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_VREFBUFFER_HPP__ -#define MSGPACK_VREFBUFFER_HPP__ - -#include "vrefbuffer.h" -#include - -namespace msgpack { - - -class vrefbuffer : public msgpack_vrefbuffer { -public: - vrefbuffer(size_t ref_size = MSGPACK_VREFBUFFER_REF_SIZE, - size_t chunk_size = MSGPACK_VREFBUFFER_CHUNK_SIZE) - { - if (!msgpack_vrefbuffer_init(this, ref_size, chunk_size)) { - throw std::bad_alloc(); - } - } - - ~vrefbuffer() - { - msgpack_vrefbuffer_destroy(this); - } - -public: - void write(const char* buf, size_t len) - { - if(len < base::ref_size) { - append_copy(buf, len); - } else { - append_ref(buf, len); - } - } - - void append_ref(const char* buf, size_t len) - { - if(msgpack_vrefbuffer_append_ref(this, buf, len) < 0) { - throw std::bad_alloc(); - } - } - - void append_copy(const char* buf, size_t len) - { - if(msgpack_vrefbuffer_append_copy(this, buf, len) < 0) { - throw std::bad_alloc(); - } - } - - const struct iovec* vector() const - { - return msgpack_vrefbuffer_vec(this); - } - - size_t vector_size() const - { - return msgpack_vrefbuffer_veclen(this); - } - - void migrate(vrefbuffer* to) - { - if(msgpack_vrefbuffer_migrate(this, to) < 0) { - throw std::bad_alloc(); - } - } - - void clear() - { - msgpack_vrefbuffer_clear(this); - } - -private: - typedef msgpack_vrefbuffer base; - -private: - vrefbuffer(const vrefbuffer&); -}; - - -} // namespace msgpack - -#endif /* msgpack/vrefbuffer.hpp */ - diff --git a/src/msgpack/zbuffer.hpp b/src/msgpack/zbuffer.hpp deleted file mode 100644 index 69e2eb79..00000000 --- a/src/msgpack/zbuffer.hpp +++ /dev/null @@ -1,102 +0,0 @@ -// -// MessagePack for C++ deflate buffer implementation -// -// Copyright (C) 2010 FURUHASHI Sadayuki -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// 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_ZBUFFER_HPP__ -#define MSGPACK_ZBUFFER_HPP__ - -#include "zbuffer.h" -#include - -namespace msgpack { - - -class zbuffer : public msgpack_zbuffer { -public: - zbuffer(int level = Z_DEFAULT_COMPRESSION, - size_t init_size = MSGPACK_ZBUFFER_INIT_SIZE) - { - if (!msgpack_zbuffer_init(this, level, init_size)) { - throw std::bad_alloc(); - } - } - - ~zbuffer() - { - msgpack_zbuffer_destroy(this); - } - -public: - void write(const char* buf, size_t len) - { - if(msgpack_zbuffer_write(this, buf, len) < 0) { - throw std::bad_alloc(); - } - } - - char* flush() - { - char* buf = msgpack_zbuffer_flush(this); - if(!buf) { - throw std::bad_alloc(); - } - return buf; - } - - char* data() - { - return base::data; - } - - const char* data() const - { - return base::data; - } - - size_t size() const - { - return msgpack_zbuffer_size(this); - } - - void reset() - { - if(!msgpack_zbuffer_reset(this)) { - throw std::bad_alloc(); - } - } - - void reset_buffer() - { - msgpack_zbuffer_reset_buffer(this); - } - - char* release_buffer() - { - return msgpack_zbuffer_release_buffer(this); - } - -private: - typedef msgpack_zbuffer base; - -private: - zbuffer(const zbuffer&); -}; - - -} // namespace msgpack - -#endif /* msgpack/zbuffer.hpp */ - diff --git a/src/msgpack/zone.hpp b/src/msgpack/zone.hpp deleted file mode 100644 index 692fbf8c..00000000 --- a/src/msgpack/zone.hpp +++ /dev/null @@ -1,464 +0,0 @@ -// -// MessagePack for C++ memory pool -// -// Copyright (C) 2008-2010 FURUHASHI Sadayuki -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_ZONE_HPP__ -#define MSGPACK_ZONE_HPP__ - -#include "zone.h" -#include -#include -#include - - -namespace msgpack { - - -class zone : public msgpack_zone { -public: - zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE); - ~zone(); - -public: - void* malloc(size_t size); - void* malloc_no_align(size_t size); - - void push_finalizer(void (*func)(void*), void* data); - - template - void push_finalizer(std::auto_ptr obj); - - void clear(); - - void swap(zone& o); - static void* operator new(std::size_t size) throw(std::bad_alloc) - { - void* p = ::malloc(size); - if (!p) throw std::bad_alloc(); - return p; - } - static void operator delete(void *p) throw() - { - ::free(p); - } - - template - T* allocate(); - - template - T* allocate(A1 a1); - - template - T* allocate(A1 a1, A2 a2); - - template - T* allocate(A1 a1, A2 a2, A3 a3); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15); - - -private: - void undo_malloc(size_t size); - - template - static void object_destructor(void* obj); - - typedef msgpack_zone base; - -private: - zone(const zone&); -}; - - - -inline zone::zone(size_t chunk_size) -{ - msgpack_zone_init(this, chunk_size); -} - -inline zone::~zone() -{ - msgpack_zone_destroy(this); -} - -inline void* zone::malloc(size_t size) -{ - void* ptr = msgpack_zone_malloc(this, size); - if(!ptr) { - throw std::bad_alloc(); - } - return ptr; -} - -inline void* zone::malloc_no_align(size_t size) -{ - void* ptr = msgpack_zone_malloc_no_align(this, size); - if(!ptr) { - throw std::bad_alloc(); - } - return ptr; -} - -inline void zone::push_finalizer(void (*func)(void*), void* data) -{ - if(!msgpack_zone_push_finalizer(this, func, data)) { - throw std::bad_alloc(); - } -} - -template -inline void zone::push_finalizer(std::auto_ptr obj) -{ - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, obj.get())) { - throw std::bad_alloc(); - } - obj.release(); -} - -inline void zone::clear() -{ - msgpack_zone_clear(this); -} - -inline void zone::swap(zone& o) -{ - msgpack_zone_swap(this, &o); -} - -template -void zone::object_destructor(void* obj) -{ - reinterpret_cast(obj)->~T(); -} - -inline void zone::undo_malloc(size_t size) -{ - base::chunk_list.ptr -= size; - base::chunk_list.free += size; -} - - -template -T* zone::allocate() -{ - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); - } - try { - return new (x) T(); - } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); - throw; - } -} - -template -T* zone::allocate(A1 a1) -{ - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); - } - try { - return new (x) T(a1); - } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); - throw; - } -} - -template -T* zone::allocate(A1 a1, A2 a2) -{ - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); - } - try { - return new (x) T(a1, a2); - } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); - throw; - } -} - -template -T* zone::allocate(A1 a1, A2 a2, A3 a3) -{ - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); - } - try { - return new (x) T(a1, a2, a3); - } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); - throw; - } -} - -template -T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4) -{ - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); - } - try { - return new (x) T(a1, a2, a3, a4); - } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); - throw; - } -} - -template -T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) -{ - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); - } - try { - return new (x) T(a1, a2, a3, a4, a5); - } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); - throw; - } -} - -template -T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) -{ - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); - } - try { - return new (x) T(a1, a2, a3, a4, a5, a6); - } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); - throw; - } -} - -template -T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) -{ - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); - } - try { - return new (x) T(a1, a2, a3, a4, a5, a6, a7); - } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); - throw; - } -} - -template -T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) -{ - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); - } - try { - return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8); - } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); - throw; - } -} - -template -T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) -{ - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); - } - try { - return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9); - } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); - throw; - } -} - -template -T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) -{ - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); - } - try { - return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); - } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); - throw; - } -} - -template -T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) -{ - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); - } - try { - return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); - } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); - throw; - } -} - -template -T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) -{ - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); - } - try { - return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); - } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); - throw; - } -} - -template -T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) -{ - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); - } - try { - return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); - } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); - throw; - } -} - -template -T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) -{ - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); - } - try { - return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); - } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); - throw; - } -} - -template -T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) -{ - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); - } - try { - return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); - } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); - throw; - } -} - - -} // namespace msgpack - -#endif /* msgpack/zone.hpp */ - diff --git a/src/msgpack/zone.hpp.erb b/src/msgpack/zone.hpp.erb deleted file mode 100644 index b2c19db0..00000000 --- a/src/msgpack/zone.hpp.erb +++ /dev/null @@ -1,164 +0,0 @@ -// -// MessagePack for C++ memory pool -// -// Copyright (C) 2008-2010 FURUHASHI Sadayuki -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_ZONE_HPP__ -#define MSGPACK_ZONE_HPP__ - -#include "zone.h" -#include -#include -#include - -<% GENERATION_LIMIT = 15 %> -namespace msgpack { - - -class zone : public msgpack_zone { -public: - zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE); - ~zone(); - -public: - void* malloc(size_t size); - void* malloc_no_align(size_t size); - - void push_finalizer(void (*func)(void*), void* data); - - template - void push_finalizer(std::auto_ptr obj); - - void clear(); - - void swap(zone& o); - static void* operator new(std::size_t size) throw(std::bad_alloc) - { - void* p = ::malloc(size); - if (!p) throw std::bad_alloc(); - return p; - } - static void operator delete(void *p) throw() - { - ::free(p); - } - <%0.upto(GENERATION_LIMIT) {|i|%> - template , typename A<%=j%><%}%>> - T* allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>); - <%}%> - -private: - void undo_malloc(size_t size); - - template - static void object_destructor(void* obj); - - typedef msgpack_zone base; - -private: - zone(const zone&); -}; - - - -inline zone::zone(size_t chunk_size) -{ - msgpack_zone_init(this, chunk_size); -} - -inline zone::~zone() -{ - msgpack_zone_destroy(this); -} - -inline void* zone::malloc(size_t size) -{ - void* ptr = msgpack_zone_malloc(this, size); - if(!ptr) { - throw std::bad_alloc(); - } - return ptr; -} - -inline void* zone::malloc_no_align(size_t size) -{ - void* ptr = msgpack_zone_malloc_no_align(this, size); - if(!ptr) { - throw std::bad_alloc(); - } - return ptr; -} - -inline void zone::push_finalizer(void (*func)(void*), void* data) -{ - if(!msgpack_zone_push_finalizer(this, func, data)) { - throw std::bad_alloc(); - } -} - -template -inline void zone::push_finalizer(std::auto_ptr obj) -{ - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, obj.get())) { - throw std::bad_alloc(); - } - obj.release(); -} - -inline void zone::clear() -{ - msgpack_zone_clear(this); -} - -inline void zone::swap(zone& o) -{ - msgpack_zone_swap(this, &o); -} - -template -void zone::object_destructor(void* obj) -{ - reinterpret_cast(obj)->~T(); -} - -inline void zone::undo_malloc(size_t size) -{ - base::chunk_list.ptr -= size; - base::chunk_list.free += size; -} - -<%0.upto(GENERATION_LIMIT) {|i|%> -template , typename A<%=j%><%}%>> -T* zone::allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>) -{ - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); - } - try { - return new (x) T(<%=(1..i).map{|j|"a#{j}"}.join(', ')%>); - } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); - throw; - } -} -<%}%> - -} // namespace msgpack - -#endif /* msgpack/zone.hpp */ - diff --git a/src/object.cpp b/src/object.cpp deleted file mode 100644 index dfe32bbc..00000000 --- a/src/object.cpp +++ /dev/null @@ -1,87 +0,0 @@ -// -// MessagePack for C++ dynamic typed objects -// -// Copyright (C) 2008-2009 FURUHASHI Sadayuki -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#include "msgpack/object.hpp" - -namespace msgpack { - - -std::ostream& operator<< (std::ostream& s, const object o) -{ - switch(o.type) { - case type::NIL: - s << "nil"; - break; - - case type::BOOLEAN: - s << (o.via.boolean ? "true" : "false"); - break; - - case type::POSITIVE_INTEGER: - s << o.via.u64; - break; - - case type::NEGATIVE_INTEGER: - s << o.via.i64; - break; - - case type::DOUBLE: - s << o.via.dec; - break; - - case type::RAW: - (s << '"').write(o.via.raw.ptr, o.via.raw.size) << '"'; - break; - - case type::ARRAY: - s << "["; - if(o.via.array.size != 0) { - object* p(o.via.array.ptr); - s << *p; - ++p; - for(object* const pend(o.via.array.ptr + o.via.array.size); - p < pend; ++p) { - s << ", " << *p; - } - } - s << "]"; - break; - - case type::MAP: - s << "{"; - if(o.via.map.size != 0) { - object_kv* p(o.via.map.ptr); - s << p->key << "=>" << p->val; - ++p; - for(object_kv* const pend(o.via.map.ptr + o.via.map.size); - p < pend; ++p) { - s << ", " << p->key << "=>" << p->val; - } - } - s << "}"; - break; - - default: - // FIXME - s << "#"; - } - return s; -} - - -} // namespace msgpack - diff --git a/src/objectc.c b/src/objectc.c index 8634bcdf..840d4332 100644 --- a/src/objectc.c +++ b/src/objectc.c @@ -34,204 +34,240 @@ int msgpack_pack_object(msgpack_packer* pk, msgpack_object d) { - switch(d.type) { - case MSGPACK_OBJECT_NIL: - return msgpack_pack_nil(pk); + switch(d.type) { + case MSGPACK_OBJECT_NIL: + return msgpack_pack_nil(pk); - case MSGPACK_OBJECT_BOOLEAN: - if(d.via.boolean) { - return msgpack_pack_true(pk); - } else { - return msgpack_pack_false(pk); - } + case MSGPACK_OBJECT_BOOLEAN: + if(d.via.boolean) { + return msgpack_pack_true(pk); + } else { + return msgpack_pack_false(pk); + } - case MSGPACK_OBJECT_POSITIVE_INTEGER: - return msgpack_pack_uint64(pk, d.via.u64); + case MSGPACK_OBJECT_POSITIVE_INTEGER: + return msgpack_pack_uint64(pk, d.via.u64); - case MSGPACK_OBJECT_NEGATIVE_INTEGER: - return msgpack_pack_int64(pk, d.via.i64); + case MSGPACK_OBJECT_NEGATIVE_INTEGER: + return msgpack_pack_int64(pk, d.via.i64); - case MSGPACK_OBJECT_DOUBLE: - return msgpack_pack_double(pk, d.via.dec); + case MSGPACK_OBJECT_DOUBLE: + return msgpack_pack_double(pk, d.via.dec); - case MSGPACK_OBJECT_RAW: - { - int ret = msgpack_pack_raw(pk, d.via.raw.size); - if(ret < 0) { return ret; } - return msgpack_pack_raw_body(pk, d.via.raw.ptr, d.via.raw.size); - } + case MSGPACK_OBJECT_STR: + { + int ret = msgpack_pack_str(pk, d.via.str.size); + if(ret < 0) { return ret; } + return msgpack_pack_str_body(pk, d.via.str.ptr, d.via.str.size); + } - case MSGPACK_OBJECT_ARRAY: - { - int ret = msgpack_pack_array(pk, d.via.array.size); - if(ret < 0) { return ret; } + case MSGPACK_OBJECT_BIN: + { + int ret = msgpack_pack_bin(pk, d.via.bin.size); + if(ret < 0) { return ret; } + return msgpack_pack_bin_body(pk, d.via.bin.ptr, d.via.bin.size); + } - msgpack_object* o = d.via.array.ptr; - msgpack_object* const oend = d.via.array.ptr + d.via.array.size; - for(; o != oend; ++o) { - ret = msgpack_pack_object(pk, *o); - if(ret < 0) { return ret; } - } + case MSGPACK_OBJECT_EXT: + { + int ret = msgpack_pack_ext(pk, d.via.ext.size, d.via.ext.type); + if(ret < 0) { return ret; } + return msgpack_pack_ext_body(pk, d.via.ext.ptr, d.via.ext.size); + } - return 0; - } + case MSGPACK_OBJECT_ARRAY: + { + int ret = msgpack_pack_array(pk, d.via.array.size); + if(ret < 0) { return ret; } - case MSGPACK_OBJECT_MAP: - { - int ret = msgpack_pack_map(pk, d.via.map.size); - if(ret < 0) { return ret; } + msgpack_object* o = d.via.array.ptr; + msgpack_object* const oend = d.via.array.ptr + d.via.array.size; + for(; o != oend; ++o) { + ret = msgpack_pack_object(pk, *o); + if(ret < 0) { return ret; } + } - msgpack_object_kv* kv = d.via.map.ptr; - msgpack_object_kv* const kvend = d.via.map.ptr + d.via.map.size; - for(; kv != kvend; ++kv) { - ret = msgpack_pack_object(pk, kv->key); - if(ret < 0) { return ret; } - ret = msgpack_pack_object(pk, kv->val); - if(ret < 0) { return ret; } - } + return 0; + } - return 0; - } + case MSGPACK_OBJECT_MAP: + { + int ret = msgpack_pack_map(pk, d.via.map.size); + if(ret < 0) { return ret; } - default: - return -1; - } + msgpack_object_kv* kv = d.via.map.ptr; + msgpack_object_kv* const kvend = d.via.map.ptr + d.via.map.size; + for(; kv != kvend; ++kv) { + ret = msgpack_pack_object(pk, kv->key); + if(ret < 0) { return ret; } + ret = msgpack_pack_object(pk, kv->val); + if(ret < 0) { return ret; } + } + + return 0; + } + + default: + return -1; + } } void msgpack_object_print(FILE* out, msgpack_object o) { - switch(o.type) { - case MSGPACK_OBJECT_NIL: - fprintf(out, "nil"); - break; + switch(o.type) { + case MSGPACK_OBJECT_NIL: + fprintf(out, "nil"); + break; - case MSGPACK_OBJECT_BOOLEAN: - fprintf(out, (o.via.boolean ? "true" : "false")); - break; + case MSGPACK_OBJECT_BOOLEAN: + fprintf(out, (o.via.boolean ? "true" : "false")); + break; - case MSGPACK_OBJECT_POSITIVE_INTEGER: - fprintf(out, "%" PRIu64, o.via.u64); - break; + case MSGPACK_OBJECT_POSITIVE_INTEGER: + fprintf(out, "%" PRIu64, o.via.u64); + break; - case MSGPACK_OBJECT_NEGATIVE_INTEGER: - fprintf(out, "%" PRIi64, o.via.i64); - break; + case MSGPACK_OBJECT_NEGATIVE_INTEGER: + fprintf(out, "%" PRIi64, o.via.i64); + break; - case MSGPACK_OBJECT_DOUBLE: - fprintf(out, "%f", o.via.dec); - break; + case MSGPACK_OBJECT_DOUBLE: + fprintf(out, "%f", o.via.dec); + break; - case MSGPACK_OBJECT_RAW: - fprintf(out, "\""); - fwrite(o.via.raw.ptr, o.via.raw.size, 1, out); - fprintf(out, "\""); - break; + case MSGPACK_OBJECT_STR: + fprintf(out, "\""); + fwrite(o.via.str.ptr, o.via.str.size, 1, out); + fprintf(out, "\""); + break; - case MSGPACK_OBJECT_ARRAY: - fprintf(out, "["); - if(o.via.array.size != 0) { - msgpack_object* p = o.via.array.ptr; - msgpack_object_print(out, *p); - ++p; - msgpack_object* const pend = o.via.array.ptr + o.via.array.size; - for(; p < pend; ++p) { - fprintf(out, ", "); - msgpack_object_print(out, *p); - } - } - fprintf(out, "]"); - break; + case MSGPACK_OBJECT_BIN: + fprintf(out, "\""); + fwrite(o.via.bin.ptr, o.via.bin.size, 1, out); + fprintf(out, "\""); + break; - case MSGPACK_OBJECT_MAP: - fprintf(out, "{"); - if(o.via.map.size != 0) { - msgpack_object_kv* p = o.via.map.ptr; - msgpack_object_print(out, p->key); - fprintf(out, "=>"); - msgpack_object_print(out, p->val); - ++p; - msgpack_object_kv* const pend = o.via.map.ptr + o.via.map.size; - for(; p < pend; ++p) { - fprintf(out, ", "); - msgpack_object_print(out, p->key); - fprintf(out, "=>"); - msgpack_object_print(out, p->val); - } - } - fprintf(out, "}"); - break; + case MSGPACK_OBJECT_EXT: + fprintf(out, "(ext: %" PRIi8 ")", o.via.ext.type); + fprintf(out, "\""); + fwrite(o.via.ext.ptr, o.via.ext.size, 1, out); + fprintf(out, "\""); + break; - default: - // FIXME - fprintf(out, "#", o.type, o.via.u64); - } + case MSGPACK_OBJECT_ARRAY: + fprintf(out, "["); + if(o.via.array.size != 0) { + msgpack_object* p = o.via.array.ptr; + msgpack_object_print(out, *p); + ++p; + msgpack_object* const pend = o.via.array.ptr + o.via.array.size; + for(; p < pend; ++p) { + fprintf(out, ", "); + msgpack_object_print(out, *p); + } + } + fprintf(out, "]"); + break; + + case MSGPACK_OBJECT_MAP: + fprintf(out, "{"); + if(o.via.map.size != 0) { + msgpack_object_kv* p = o.via.map.ptr; + msgpack_object_print(out, p->key); + fprintf(out, "=>"); + msgpack_object_print(out, p->val); + ++p; + msgpack_object_kv* const pend = o.via.map.ptr + o.via.map.size; + for(; p < pend; ++p) { + fprintf(out, ", "); + msgpack_object_print(out, p->key); + fprintf(out, "=>"); + msgpack_object_print(out, p->val); + } + } + fprintf(out, "}"); + break; + + default: + // FIXME + fprintf(out, "#", o.type, o.via.u64); + } } bool msgpack_object_equal(const msgpack_object x, const msgpack_object y) { - if(x.type != y.type) { return false; } + if(x.type != y.type) { return false; } - switch(x.type) { - case MSGPACK_OBJECT_NIL: - return true; + switch(x.type) { + case MSGPACK_OBJECT_NIL: + return true; - case MSGPACK_OBJECT_BOOLEAN: - return x.via.boolean == y.via.boolean; + case MSGPACK_OBJECT_BOOLEAN: + return x.via.boolean == y.via.boolean; - case MSGPACK_OBJECT_POSITIVE_INTEGER: - return x.via.u64 == y.via.u64; + case MSGPACK_OBJECT_POSITIVE_INTEGER: + return x.via.u64 == y.via.u64; - case MSGPACK_OBJECT_NEGATIVE_INTEGER: - return x.via.i64 == y.via.i64; + case MSGPACK_OBJECT_NEGATIVE_INTEGER: + return x.via.i64 == y.via.i64; - case MSGPACK_OBJECT_DOUBLE: - return x.via.dec == y.via.dec; + case MSGPACK_OBJECT_DOUBLE: + return x.via.dec == y.via.dec; - case MSGPACK_OBJECT_RAW: - return x.via.raw.size == y.via.raw.size && - memcmp(x.via.raw.ptr, y.via.raw.ptr, x.via.raw.size) == 0; + case MSGPACK_OBJECT_STR: + return x.via.str.size == y.via.str.size && + memcmp(x.via.str.ptr, y.via.str.ptr, x.via.str.size) == 0; - case MSGPACK_OBJECT_ARRAY: - if(x.via.array.size != y.via.array.size) { - return false; - } else if(x.via.array.size == 0) { - return true; - } else { - msgpack_object* px = x.via.array.ptr; - msgpack_object* const pxend = x.via.array.ptr + x.via.array.size; - msgpack_object* py = y.via.array.ptr; - do { - if(!msgpack_object_equal(*px, *py)) { - return false; - } - ++px; - ++py; - } while(px < pxend); - return true; - } + case MSGPACK_OBJECT_BIN: + return x.via.bin.size == y.via.bin.size && + memcmp(x.via.bin.ptr, y.via.bin.ptr, x.via.bin.size) == 0; - case MSGPACK_OBJECT_MAP: - if(x.via.map.size != y.via.map.size) { - return false; - } else if(x.via.map.size == 0) { - return true; - } else { - msgpack_object_kv* px = x.via.map.ptr; - msgpack_object_kv* const pxend = x.via.map.ptr + x.via.map.size; - msgpack_object_kv* py = y.via.map.ptr; - do { - if(!msgpack_object_equal(px->key, py->key) || !msgpack_object_equal(px->val, py->val)) { - return false; - } - ++px; - ++py; - } while(px < pxend); - return true; - } + case MSGPACK_OBJECT_EXT: + return x.via.ext.size == y.via.ext.size && + x.via.ext.type == y.via.ext.type && + memcmp(x.via.ext.ptr, y.via.ext.ptr, x.via.ext.size) == 0; - default: - return false; - } + case MSGPACK_OBJECT_ARRAY: + if(x.via.array.size != y.via.array.size) { + return false; + } else if(x.via.array.size == 0) { + return true; + } else { + msgpack_object* px = x.via.array.ptr; + msgpack_object* const pxend = x.via.array.ptr + x.via.array.size; + msgpack_object* py = y.via.array.ptr; + do { + if(!msgpack_object_equal(*px, *py)) { + return false; + } + ++px; + ++py; + } while(px < pxend); + return true; + } + + case MSGPACK_OBJECT_MAP: + if(x.via.map.size != y.via.map.size) { + return false; + } else if(x.via.map.size == 0) { + return true; + } else { + msgpack_object_kv* px = x.via.map.ptr; + msgpack_object_kv* const pxend = x.via.map.ptr + x.via.map.size; + msgpack_object_kv* py = y.via.map.ptr; + do { + if(!msgpack_object_equal(px->key, py->key) || !msgpack_object_equal(px->val, py->val)) { + return false; + } + ++px; + ++py; + } while(px < pxend); + return true; + } + + default: + return false; + } } diff --git a/src/unpack.c b/src/unpack.c index 8f154cac..33b1bec0 100644 --- a/src/unpack.c +++ b/src/unpack.c @@ -17,6 +17,7 @@ */ #include "msgpack/unpack.h" #include "msgpack/unpack_define.h" +#include "msgpack/util.h" #include #ifdef _msgpack_atomic_counter_header @@ -25,19 +26,19 @@ typedef struct { - msgpack_zone* z; - bool referenced; + msgpack_zone* z; + bool referenced; } unpack_user; #define msgpack_unpack_struct(name) \ - struct template ## name + struct template ## name #define msgpack_unpack_func(ret, name) \ - ret template ## name + ret template ## name #define msgpack_unpack_callback(name) \ - template_callback ## name + template_callback ## name #define msgpack_unpack_object msgpack_object @@ -51,105 +52,225 @@ static void template_init(template_context* ctx); static msgpack_object template_data(template_context* ctx); -static int template_execute(template_context* ctx, - const char* data, size_t len, size_t* off); +static int template_execute( + template_context* ctx, const char* data, size_t len, size_t* off); static inline msgpack_object template_callback_root(unpack_user* u) -{ msgpack_object o = { MSGPACK_OBJECT_NIL }; return o; } +{ + MSGPACK_UNUSED(u); + msgpack_object o; + o.type = MSGPACK_OBJECT_NIL; + return o; +} static inline int template_callback_uint8(unpack_user* u, uint8_t d, msgpack_object* o) -{ o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; o->via.u64 = d; return 0; } +{ + MSGPACK_UNUSED(u); + o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; + o->via.u64 = d; + return 0; +} static inline int template_callback_uint16(unpack_user* u, uint16_t d, msgpack_object* o) -{ o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; o->via.u64 = d; return 0; } +{ + MSGPACK_UNUSED(u); + o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; + o->via.u64 = d; + return 0; +} static inline int template_callback_uint32(unpack_user* u, uint32_t d, msgpack_object* o) -{ o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; o->via.u64 = d; return 0; } +{ + MSGPACK_UNUSED(u); + o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; + o->via.u64 = d; + return 0; +} static inline int template_callback_uint64(unpack_user* u, uint64_t d, msgpack_object* o) -{ o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; o->via.u64 = d; return 0; } +{ + MSGPACK_UNUSED(u); + o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; + o->via.u64 = d; + return 0; +} static inline int template_callback_int8(unpack_user* u, int8_t d, msgpack_object* o) -{ if(d >= 0) { o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; o->via.u64 = (uint64_t)d; return 0; } - else { o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } +{ + MSGPACK_UNUSED(u); + if(d >= 0) { + o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; + o->via.u64 = (uint64_t)d; + return 0; + } + else { + o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; + o->via.i64 = d; + return 0; + } +} static inline int template_callback_int16(unpack_user* u, int16_t d, msgpack_object* o) -{ if(d >= 0) { o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; o->via.u64 = (uint64_t)d; return 0; } - else { o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } +{ + MSGPACK_UNUSED(u); + if(d >= 0) { + o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; + o->via.u64 = (uint64_t)d; + return 0; + } + else { + o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; + o->via.i64 = d; + return 0; + } +} static inline int template_callback_int32(unpack_user* u, int32_t d, msgpack_object* o) -{ if(d >= 0) { o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; o->via.u64 = (uint64_t)d; return 0; } - else { o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } +{ + MSGPACK_UNUSED(u); + if(d >= 0) { + o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; + o->via.u64 = (uint64_t)d; + return 0; + } + else { + o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; + o->via.i64 = d; + return 0; + } +} static inline int template_callback_int64(unpack_user* u, int64_t d, msgpack_object* o) -{ if(d >= 0) { o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; o->via.u64 = (uint64_t)d; return 0; } - else { o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } +{ + MSGPACK_UNUSED(u); + if(d >= 0) { + o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; + o->via.u64 = (uint64_t)d; + return 0; + } + else { + o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; + o->via.i64 = d; + return 0; + } +} static inline int template_callback_float(unpack_user* u, float d, msgpack_object* o) -{ o->type = MSGPACK_OBJECT_DOUBLE; o->via.dec = d; return 0; } +{ + MSGPACK_UNUSED(u); + o->type = MSGPACK_OBJECT_DOUBLE; + o->via.dec = d; + return 0; +} static inline int template_callback_double(unpack_user* u, double d, msgpack_object* o) -{ o->type = MSGPACK_OBJECT_DOUBLE; o->via.dec = d; return 0; } +{ + MSGPACK_UNUSED(u); + o->type = MSGPACK_OBJECT_DOUBLE; + o->via.dec = d; + return 0; +} static inline int template_callback_nil(unpack_user* u, msgpack_object* o) -{ o->type = MSGPACK_OBJECT_NIL; return 0; } +{ + MSGPACK_UNUSED(u); + o->type = MSGPACK_OBJECT_NIL; + return 0; +} static inline int template_callback_true(unpack_user* u, msgpack_object* o) -{ o->type = MSGPACK_OBJECT_BOOLEAN; o->via.boolean = true; return 0; } +{ + MSGPACK_UNUSED(u); + o->type = MSGPACK_OBJECT_BOOLEAN; + o->via.boolean = true; + return 0; +} static inline int template_callback_false(unpack_user* u, msgpack_object* o) -{ o->type = MSGPACK_OBJECT_BOOLEAN; o->via.boolean = false; return 0; } +{ + MSGPACK_UNUSED(u); + o->type = MSGPACK_OBJECT_BOOLEAN; + o->via.boolean = false; + return 0; +} static inline int template_callback_array(unpack_user* u, unsigned int n, msgpack_object* o) { - o->type = MSGPACK_OBJECT_ARRAY; - o->via.array.size = 0; - o->via.array.ptr = (msgpack_object*)msgpack_zone_malloc(u->z, n*sizeof(msgpack_object)); - if(o->via.array.ptr == NULL) { return -1; } - return 0; + o->type = MSGPACK_OBJECT_ARRAY; + o->via.array.size = 0; + o->via.array.ptr = (msgpack_object*)msgpack_zone_malloc(u->z, n*sizeof(msgpack_object)); + if(o->via.array.ptr == NULL) { return -1; } + return 0; } static inline int template_callback_array_item(unpack_user* u, msgpack_object* c, msgpack_object o) { + MSGPACK_UNUSED(u); #if defined(__GNUC__) && !defined(__clang__) - memcpy(&c->via.array.ptr[c->via.array.size], &o, sizeof(msgpack_object)); + memcpy(&c->via.array.ptr[c->via.array.size], &o, sizeof(msgpack_object)); #else /* __GNUC__ && !__clang__ */ - c->via.array.ptr[c->via.array.size] = o; + c->via.array.ptr[c->via.array.size] = o; #endif /* __GNUC__ && !__clang__ */ - ++c->via.array.size; - return 0; + ++c->via.array.size; + return 0; } static inline int template_callback_map(unpack_user* u, unsigned int n, msgpack_object* o) { - o->type = MSGPACK_OBJECT_MAP; - o->via.map.size = 0; - o->via.map.ptr = (msgpack_object_kv*)msgpack_zone_malloc(u->z, n*sizeof(msgpack_object_kv)); - if(o->via.map.ptr == NULL) { return -1; } - return 0; + o->type = MSGPACK_OBJECT_MAP; + o->via.map.size = 0; + o->via.map.ptr = (msgpack_object_kv*)msgpack_zone_malloc(u->z, n*sizeof(msgpack_object_kv)); + if(o->via.map.ptr == NULL) { return -1; } + return 0; } static inline int template_callback_map_item(unpack_user* u, msgpack_object* c, msgpack_object k, msgpack_object v) { + MSGPACK_UNUSED(u); #if defined(__GNUC__) && !defined(__clang__) - memcpy(&c->via.map.ptr[c->via.map.size].key, &k, sizeof(msgpack_object)); - memcpy(&c->via.map.ptr[c->via.map.size].val, &v, sizeof(msgpack_object)); + memcpy(&c->via.map.ptr[c->via.map.size].key, &k, sizeof(msgpack_object)); + memcpy(&c->via.map.ptr[c->via.map.size].val, &v, sizeof(msgpack_object)); #else /* __GNUC__ && !__clang__ */ - c->via.map.ptr[c->via.map.size].key = k; - c->via.map.ptr[c->via.map.size].val = v; + c->via.map.ptr[c->via.map.size].key = k; + c->via.map.ptr[c->via.map.size].val = v; #endif /* __GNUC__ && !__clang__ */ - ++c->via.map.size; - return 0; + ++c->via.map.size; + return 0; } -static inline int template_callback_raw(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o) +static inline int template_callback_str(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o) { - o->type = MSGPACK_OBJECT_RAW; - o->via.raw.ptr = p; - o->via.raw.size = l; - u->referenced = true; - return 0; + MSGPACK_UNUSED(u); + MSGPACK_UNUSED(b); + o->type = MSGPACK_OBJECT_STR; + o->via.str.ptr = p; + o->via.str.size = l; + u->referenced = true; + return 0; +} + +static inline int template_callback_bin(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o) +{ + MSGPACK_UNUSED(u); + MSGPACK_UNUSED(b); + o->type = MSGPACK_OBJECT_BIN; + o->via.bin.ptr = p; + o->via.bin.size = l; + u->referenced = true; + return 0; +} + +static inline int template_callback_ext(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o) +{ + MSGPACK_UNUSED(u); + MSGPACK_UNUSED(b); + o->type = MSGPACK_OBJECT_EXT; + o->via.ext.type = *p; + o->via.ext.ptr = p + 1; + o->via.ext.size = l - 1; + u->referenced = true; + return 0; } #include "msgpack/unpack_template.h" @@ -163,316 +284,328 @@ static inline int template_callback_raw(unpack_user* u, const char* b, const cha static inline void init_count(void* buffer) { - *(volatile _msgpack_atomic_counter_t*)buffer = 1; + *(volatile _msgpack_atomic_counter_t*)buffer = 1; } static inline void decl_count(void* buffer) { - // atomic if(--*(_msgpack_atomic_counter_t*)buffer == 0) { free(buffer); } - if(_msgpack_sync_decr_and_fetch((volatile _msgpack_atomic_counter_t*)buffer) == 0) { - free(buffer); - } + // atomic if(--*(_msgpack_atomic_counter_t*)buffer == 0) { free(buffer); } + if(_msgpack_sync_decr_and_fetch((volatile _msgpack_atomic_counter_t*)buffer) == 0) { + free(buffer); + } } static inline void incr_count(void* buffer) { - // atomic ++*(_msgpack_atomic_counter_t*)buffer; - _msgpack_sync_incr_and_fetch((volatile _msgpack_atomic_counter_t*)buffer); + // atomic ++*(_msgpack_atomic_counter_t*)buffer; + _msgpack_sync_incr_and_fetch((volatile _msgpack_atomic_counter_t*)buffer); } static inline _msgpack_atomic_counter_t get_count(void* buffer) { - return *(volatile _msgpack_atomic_counter_t*)buffer; + return *(volatile _msgpack_atomic_counter_t*)buffer; } bool msgpack_unpacker_init(msgpack_unpacker* mpac, size_t initial_buffer_size) { - if(initial_buffer_size < COUNTER_SIZE) { - initial_buffer_size = COUNTER_SIZE; - } + if(initial_buffer_size < COUNTER_SIZE) { + initial_buffer_size = COUNTER_SIZE; + } - char* buffer = (char*)malloc(initial_buffer_size); - if(buffer == NULL) { - return false; - } + char* buffer = (char*)malloc(initial_buffer_size); + if(buffer == NULL) { + return false; + } - void* ctx = malloc(sizeof(template_context)); - if(ctx == NULL) { - free(buffer); - return false; - } + void* ctx = malloc(sizeof(template_context)); + if(ctx == NULL) { + free(buffer); + return false; + } - msgpack_zone* z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); - if(z == NULL) { - free(ctx); - free(buffer); - return false; - } + msgpack_zone* z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); + if(z == NULL) { + free(ctx); + free(buffer); + return false; + } - mpac->buffer = buffer; - mpac->used = COUNTER_SIZE; - mpac->free = initial_buffer_size - mpac->used; - mpac->off = COUNTER_SIZE; - mpac->parsed = 0; - mpac->initial_buffer_size = initial_buffer_size; - mpac->z = z; - mpac->ctx = ctx; + mpac->buffer = buffer; + mpac->used = COUNTER_SIZE; + mpac->free = initial_buffer_size - mpac->used; + mpac->off = COUNTER_SIZE; + mpac->parsed = 0; + mpac->initial_buffer_size = initial_buffer_size; + mpac->z = z; + mpac->ctx = ctx; - init_count(mpac->buffer); + init_count(mpac->buffer); - template_init(CTX_CAST(mpac->ctx)); - CTX_CAST(mpac->ctx)->user.z = mpac->z; - CTX_CAST(mpac->ctx)->user.referenced = false; + template_init(CTX_CAST(mpac->ctx)); + CTX_CAST(mpac->ctx)->user.z = mpac->z; + CTX_CAST(mpac->ctx)->user.referenced = false; - return true; + return true; } void msgpack_unpacker_destroy(msgpack_unpacker* mpac) { - msgpack_zone_free(mpac->z); - free(mpac->ctx); - decl_count(mpac->buffer); + msgpack_zone_free(mpac->z); + free(mpac->ctx); + decl_count(mpac->buffer); } msgpack_unpacker* msgpack_unpacker_new(size_t initial_buffer_size) { - msgpack_unpacker* mpac = (msgpack_unpacker*)malloc(sizeof(msgpack_unpacker)); - if(mpac == NULL) { - return NULL; - } + msgpack_unpacker* mpac = (msgpack_unpacker*)malloc(sizeof(msgpack_unpacker)); + if(mpac == NULL) { + return NULL; + } - if(!msgpack_unpacker_init(mpac, initial_buffer_size)) { - free(mpac); - return NULL; - } + if(!msgpack_unpacker_init(mpac, initial_buffer_size)) { + free(mpac); + return NULL; + } - return mpac; + return mpac; } void msgpack_unpacker_free(msgpack_unpacker* mpac) { - msgpack_unpacker_destroy(mpac); - free(mpac); + msgpack_unpacker_destroy(mpac); + free(mpac); } bool msgpack_unpacker_expand_buffer(msgpack_unpacker* mpac, size_t size) { - if(mpac->used == mpac->off && get_count(mpac->buffer) == 1 - && !CTX_REFERENCED(mpac)) { - // rewind buffer - mpac->free += mpac->used - COUNTER_SIZE; - mpac->used = COUNTER_SIZE; - mpac->off = COUNTER_SIZE; + if(mpac->used == mpac->off && get_count(mpac->buffer) == 1 + && !CTX_REFERENCED(mpac)) { + // rewind buffer + mpac->free += mpac->used - COUNTER_SIZE; + mpac->used = COUNTER_SIZE; + mpac->off = COUNTER_SIZE; - if(mpac->free >= size) { - return true; - } - } + if(mpac->free >= size) { + return true; + } + } - if(mpac->off == COUNTER_SIZE) { - size_t next_size = (mpac->used + mpac->free) * 2; // include COUNTER_SIZE - while(next_size < size + mpac->used) { - next_size *= 2; - } + if(mpac->off == COUNTER_SIZE) { + size_t next_size = (mpac->used + mpac->free) * 2; // include COUNTER_SIZE + while(next_size < size + mpac->used) { + next_size *= 2; + } - char* tmp = (char*)realloc(mpac->buffer, next_size); - if(tmp == NULL) { - return false; - } + char* tmp = (char*)realloc(mpac->buffer, next_size); + if(tmp == NULL) { + return false; + } - mpac->buffer = tmp; - mpac->free = next_size - mpac->used; + mpac->buffer = tmp; + mpac->free = next_size - mpac->used; - } else { - size_t next_size = mpac->initial_buffer_size; // include COUNTER_SIZE - size_t not_parsed = mpac->used - mpac->off; - while(next_size < size + not_parsed + COUNTER_SIZE) { - next_size *= 2; - } + } else { + size_t next_size = mpac->initial_buffer_size; // include COUNTER_SIZE + size_t not_parsed = mpac->used - mpac->off; + while(next_size < size + not_parsed + COUNTER_SIZE) { + next_size *= 2; + } - char* tmp = (char*)malloc(next_size); - if(tmp == NULL) { - return false; - } + char* tmp = (char*)malloc(next_size); + if(tmp == NULL) { + return false; + } - init_count(tmp); + init_count(tmp); - memcpy(tmp+COUNTER_SIZE, mpac->buffer+mpac->off, not_parsed); + memcpy(tmp+COUNTER_SIZE, mpac->buffer+mpac->off, not_parsed); - if(CTX_REFERENCED(mpac)) { - if(!msgpack_zone_push_finalizer(mpac->z, decl_count, mpac->buffer)) { - free(tmp); - return false; - } - CTX_REFERENCED(mpac) = false; - } else { - decl_count(mpac->buffer); - } + if(CTX_REFERENCED(mpac)) { + if(!msgpack_zone_push_finalizer(mpac->z, decl_count, mpac->buffer)) { + free(tmp); + return false; + } + CTX_REFERENCED(mpac) = false; + } else { + decl_count(mpac->buffer); + } - mpac->buffer = tmp; - mpac->used = not_parsed + COUNTER_SIZE; - mpac->free = next_size - mpac->used; - mpac->off = COUNTER_SIZE; - } + mpac->buffer = tmp; + mpac->used = not_parsed + COUNTER_SIZE; + mpac->free = next_size - mpac->used; + mpac->off = COUNTER_SIZE; + } - return true; + return true; } int msgpack_unpacker_execute(msgpack_unpacker* mpac) { - size_t off = mpac->off; - int ret = template_execute(CTX_CAST(mpac->ctx), - mpac->buffer, mpac->used, &mpac->off); - if(mpac->off > off) { - mpac->parsed += mpac->off - off; - } - return ret; + size_t off = mpac->off; + int ret = template_execute(CTX_CAST(mpac->ctx), + mpac->buffer, mpac->used, &mpac->off); + if(mpac->off > off) { + mpac->parsed += mpac->off - off; + } + return ret; } msgpack_object msgpack_unpacker_data(msgpack_unpacker* mpac) { - return template_data(CTX_CAST(mpac->ctx)); + return template_data(CTX_CAST(mpac->ctx)); } msgpack_zone* msgpack_unpacker_release_zone(msgpack_unpacker* mpac) { - if(!msgpack_unpacker_flush_zone(mpac)) { - return NULL; - } + if(!msgpack_unpacker_flush_zone(mpac)) { + return NULL; + } - msgpack_zone* r = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); - if(r == NULL) { - return NULL; - } + msgpack_zone* r = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); + if(r == NULL) { + return NULL; + } - msgpack_zone* old = mpac->z; - mpac->z = r; - CTX_CAST(mpac->ctx)->user.z = mpac->z; + msgpack_zone* old = mpac->z; + mpac->z = r; + CTX_CAST(mpac->ctx)->user.z = mpac->z; - return old; + return old; } void msgpack_unpacker_reset_zone(msgpack_unpacker* mpac) { - msgpack_zone_clear(mpac->z); + msgpack_zone_clear(mpac->z); } bool msgpack_unpacker_flush_zone(msgpack_unpacker* mpac) { - if(CTX_REFERENCED(mpac)) { - if(!msgpack_zone_push_finalizer(mpac->z, decl_count, mpac->buffer)) { - return false; - } - CTX_REFERENCED(mpac) = false; + if(CTX_REFERENCED(mpac)) { + if(!msgpack_zone_push_finalizer(mpac->z, decl_count, mpac->buffer)) { + return false; + } + CTX_REFERENCED(mpac) = false; - incr_count(mpac->buffer); - } + incr_count(mpac->buffer); + } - return true; + return true; } void msgpack_unpacker_reset(msgpack_unpacker* mpac) { - template_init(CTX_CAST(mpac->ctx)); - // don't reset referenced flag - mpac->parsed = 0; + template_init(CTX_CAST(mpac->ctx)); + // don't reset referenced flag + mpac->parsed = 0; } -bool msgpack_unpacker_next(msgpack_unpacker* mpac, msgpack_unpacked* result) +msgpack_unpack_return msgpack_unpacker_next(msgpack_unpacker* mpac, msgpack_unpacked* result) { - if(result->zone != NULL) { - msgpack_zone_free(result->zone); - } + msgpack_unpacked_destroy(result); - int ret = msgpack_unpacker_execute(mpac); + int ret = msgpack_unpacker_execute(mpac); - if(ret <= 0) { - result->zone = NULL; - memset(&result->data, 0, sizeof(msgpack_object)); - return false; - } + if(ret < 0) { + result->zone = NULL; + memset(&result->data, 0, sizeof(msgpack_object)); + return MSGPACK_UNPACK_PARSE_ERROR; + } - result->zone = msgpack_unpacker_release_zone(mpac); - result->data = msgpack_unpacker_data(mpac); - msgpack_unpacker_reset(mpac); + if(ret == 0) { + return MSGPACK_UNPACK_CONTINUE; + } + result->zone = msgpack_unpacker_release_zone(mpac); + result->data = msgpack_unpacker_data(mpac); + msgpack_unpacker_reset(mpac); - return true; + return MSGPACK_UNPACK_SUCCESS; } msgpack_unpack_return msgpack_unpack(const char* data, size_t len, size_t* off, - msgpack_zone* result_zone, msgpack_object* result) + msgpack_zone* result_zone, msgpack_object* result) { - size_t noff = 0; - if(off != NULL) { noff = *off; } + size_t noff = 0; + if(off != NULL) { noff = *off; } - if(len <= noff) { - // FIXME - return MSGPACK_UNPACK_CONTINUE; - } + if(len <= noff) { + // FIXME + return MSGPACK_UNPACK_CONTINUE; + } - template_context ctx; - template_init(&ctx); + template_context ctx; + template_init(&ctx); - ctx.user.z = result_zone; - ctx.user.referenced = false; + ctx.user.z = result_zone; + ctx.user.referenced = false; - int e = template_execute(&ctx, data, len, &noff); - if(e < 0) { - return MSGPACK_UNPACK_PARSE_ERROR; - } + int e = template_execute(&ctx, data, len, &noff); + if(e < 0) { + return MSGPACK_UNPACK_PARSE_ERROR; + } - if(off != NULL) { *off = noff; } + if(off != NULL) { *off = noff; } - if(e == 0) { - return MSGPACK_UNPACK_CONTINUE; - } + if(e == 0) { + return MSGPACK_UNPACK_CONTINUE; + } - *result = template_data(&ctx); + *result = template_data(&ctx); - if(noff < len) { - return MSGPACK_UNPACK_EXTRA_BYTES; - } + if(noff < len) { + return MSGPACK_UNPACK_EXTRA_BYTES; + } - return MSGPACK_UNPACK_SUCCESS; + return MSGPACK_UNPACK_SUCCESS; } -bool msgpack_unpack_next(msgpack_unpacked* result, - const char* data, size_t len, size_t* off) +msgpack_unpack_return +msgpack_unpack_next(msgpack_unpacked* result, + const char* data, size_t len, size_t* off) { - msgpack_unpacked_destroy(result); + msgpack_unpacked_destroy(result); - size_t noff = 0; - if(off != NULL) { noff = *off; } + size_t noff = 0; + if(off != NULL) { noff = *off; } - if(len <= noff) { - return false; - } + if(len <= noff) { + return MSGPACK_UNPACK_CONTINUE; + } - msgpack_zone* z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); + if (!result->zone) { + result->zone = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); + } - template_context ctx; - template_init(&ctx); + if (!result->zone) { + return MSGPACK_UNPACK_NOMEM_ERROR; + } - ctx.user.z = z; - ctx.user.referenced = false; + template_context ctx; + template_init(&ctx); - int e = template_execute(&ctx, data, len, &noff); - if(e <= 0) { - msgpack_zone_free(z); - return false; - } + ctx.user.z = result->zone; + ctx.user.referenced = false; - if(off != NULL) { *off = noff; } + int e = template_execute(&ctx, data, len, &noff); + if(e < 0) { + msgpack_zone_free(result->zone); + result->zone = NULL; + return MSGPACK_UNPACK_PARSE_ERROR; + } - result->zone = z; - result->data = template_data(&ctx); + if(off != NULL) { *off = noff; } - return true; + if(e == 0) { + return MSGPACK_UNPACK_CONTINUE; + } + + result->data = template_data(&ctx); + + return MSGPACK_UNPACK_SUCCESS; } #if defined(MSGPACK_OLD_COMPILER_BUS_ERROR_WORKAROUND) diff --git a/src/version.c b/src/version.c index 3d956f18..83f75108 100644 --- a/src/version.c +++ b/src/version.c @@ -2,16 +2,21 @@ const char* msgpack_version(void) { - return MSGPACK_VERSION; + return MSGPACK_VERSION; } int msgpack_version_major(void) { - return MSGPACK_VERSION_MAJOR; + return MSGPACK_VERSION_MAJOR; } int msgpack_version_minor(void) { - return MSGPACK_VERSION_MINOR; + return MSGPACK_VERSION_MINOR; +} + +int msgpack_version_revision(void) +{ + return MSGPACK_VERSION_REVISION; } diff --git a/src/vrefbuffer.c b/src/vrefbuffer.c index d43fb6d2..1070ba2c 100644 --- a/src/vrefbuffer.c +++ b/src/vrefbuffer.c @@ -19,202 +19,205 @@ #include #include +#define MSGPACK_PACKER_MAX_BUFFER_SIZE 9 + struct msgpack_vrefbuffer_chunk { - struct msgpack_vrefbuffer_chunk* next; - /* data ... */ + struct msgpack_vrefbuffer_chunk* next; + /* data ... */ }; bool msgpack_vrefbuffer_init(msgpack_vrefbuffer* vbuf, - size_t ref_size, size_t chunk_size) + size_t ref_size, size_t chunk_size) { - vbuf->chunk_size = chunk_size; - vbuf->ref_size = ref_size; + vbuf->chunk_size = chunk_size; + vbuf->ref_size = + ref_size > MSGPACK_PACKER_MAX_BUFFER_SIZE + 1 ? + ref_size : MSGPACK_PACKER_MAX_BUFFER_SIZE + 1 ; - size_t nfirst = (sizeof(struct iovec) < 72/2) ? - 72 / sizeof(struct iovec) : 8; + size_t nfirst = (sizeof(struct iovec) < 72/2) ? + 72 / sizeof(struct iovec) : 8; - struct iovec* array = (struct iovec*)malloc( - sizeof(struct iovec) * nfirst); - if(array == NULL) { - return false; - } + struct iovec* array = (struct iovec*)malloc( + sizeof(struct iovec) * nfirst); + if(array == NULL) { + return false; + } - vbuf->tail = array; - vbuf->end = array + nfirst; - vbuf->array = array; + vbuf->tail = array; + vbuf->end = array + nfirst; + vbuf->array = array; - msgpack_vrefbuffer_chunk* chunk = (msgpack_vrefbuffer_chunk*)malloc( - sizeof(msgpack_vrefbuffer_chunk) + chunk_size); - if(chunk == NULL) { - free(array); - return false; - } + msgpack_vrefbuffer_chunk* chunk = (msgpack_vrefbuffer_chunk*)malloc( + sizeof(msgpack_vrefbuffer_chunk) + chunk_size); + if(chunk == NULL) { + free(array); + return false; + } - msgpack_vrefbuffer_inner_buffer* const ib = &vbuf->inner_buffer; + msgpack_vrefbuffer_inner_buffer* const ib = &vbuf->inner_buffer; - ib->free = chunk_size; - ib->ptr = ((char*)chunk) + sizeof(msgpack_vrefbuffer_chunk); - ib->head = chunk; - chunk->next = NULL; + ib->free = chunk_size; + ib->ptr = ((char*)chunk) + sizeof(msgpack_vrefbuffer_chunk); + ib->head = chunk; + chunk->next = NULL; - return true; + return true; } void msgpack_vrefbuffer_destroy(msgpack_vrefbuffer* vbuf) { - msgpack_vrefbuffer_chunk* c = vbuf->inner_buffer.head; - while(true) { - msgpack_vrefbuffer_chunk* n = c->next; - free(c); - if(n != NULL) { - c = n; - } else { - break; - } - } - free(vbuf->array); + msgpack_vrefbuffer_chunk* c = vbuf->inner_buffer.head; + while(true) { + msgpack_vrefbuffer_chunk* n = c->next; + free(c); + if(n != NULL) { + c = n; + } else { + break; + } + } + free(vbuf->array); } void msgpack_vrefbuffer_clear(msgpack_vrefbuffer* vbuf) { - msgpack_vrefbuffer_chunk* c = vbuf->inner_buffer.head->next; - msgpack_vrefbuffer_chunk* n; - while(c != NULL) { - n = c->next; - free(c); - c = n; - } + msgpack_vrefbuffer_chunk* c = vbuf->inner_buffer.head->next; + msgpack_vrefbuffer_chunk* n; + while(c != NULL) { + n = c->next; + free(c); + c = n; + } - msgpack_vrefbuffer_inner_buffer* const ib = &vbuf->inner_buffer; - msgpack_vrefbuffer_chunk* chunk = ib->head; - chunk->next = NULL; - ib->free = vbuf->chunk_size; - ib->ptr = ((char*)chunk) + sizeof(msgpack_vrefbuffer_chunk); + msgpack_vrefbuffer_inner_buffer* const ib = &vbuf->inner_buffer; + msgpack_vrefbuffer_chunk* chunk = ib->head; + chunk->next = NULL; + ib->free = vbuf->chunk_size; + ib->ptr = ((char*)chunk) + sizeof(msgpack_vrefbuffer_chunk); - vbuf->tail = vbuf->array; + vbuf->tail = vbuf->array; } int msgpack_vrefbuffer_append_ref(msgpack_vrefbuffer* vbuf, - const char* buf, size_t len) + const char* buf, size_t len) { - if(vbuf->tail == vbuf->end) { - const size_t nused = (size_t)(vbuf->tail - vbuf->array); - const size_t nnext = nused * 2; + if(vbuf->tail == vbuf->end) { + const size_t nused = (size_t)(vbuf->tail - vbuf->array); + const size_t nnext = nused * 2; - struct iovec* nvec = (struct iovec*)realloc( - vbuf->array, sizeof(struct iovec)*nnext); - if(nvec == NULL) { - return -1; - } + struct iovec* nvec = (struct iovec*)realloc( + vbuf->array, sizeof(struct iovec)*nnext); + if(nvec == NULL) { + return -1; + } - vbuf->array = nvec; - vbuf->end = nvec + nnext; - vbuf->tail = nvec + nused; - } + vbuf->array = nvec; + vbuf->end = nvec + nnext; + vbuf->tail = nvec + nused; + } - vbuf->tail->iov_base = (char*)buf; - vbuf->tail->iov_len = len; - ++vbuf->tail; + vbuf->tail->iov_base = (char*)buf; + vbuf->tail->iov_len = len; + ++vbuf->tail; - return 0; + return 0; } int msgpack_vrefbuffer_append_copy(msgpack_vrefbuffer* vbuf, - const char* buf, size_t len) + const char* buf, size_t len) { - msgpack_vrefbuffer_inner_buffer* const ib = &vbuf->inner_buffer; + msgpack_vrefbuffer_inner_buffer* const ib = &vbuf->inner_buffer; - if(ib->free < len) { - size_t sz = vbuf->chunk_size; - if(sz < len) { - sz = len; - } + if(ib->free < len) { + size_t sz = vbuf->chunk_size; + if(sz < len) { + sz = len; + } - msgpack_vrefbuffer_chunk* chunk = (msgpack_vrefbuffer_chunk*)malloc( - sizeof(msgpack_vrefbuffer_chunk) + sz); - if(chunk == NULL) { - return -1; - } + msgpack_vrefbuffer_chunk* chunk = (msgpack_vrefbuffer_chunk*)malloc( + sizeof(msgpack_vrefbuffer_chunk) + sz); + if(chunk == NULL) { + return -1; + } - chunk->next = ib->head; - ib->head = chunk; - ib->free = sz; - ib->ptr = ((char*)chunk) + sizeof(msgpack_vrefbuffer_chunk); - } + chunk->next = ib->head; + ib->head = chunk; + ib->free = sz; + ib->ptr = ((char*)chunk) + sizeof(msgpack_vrefbuffer_chunk); + } - char* m = ib->ptr; - memcpy(m, buf, len); - ib->free -= len; - ib->ptr += len; + char* m = ib->ptr; + memcpy(m, buf, len); + ib->free -= len; + ib->ptr += len; - if(vbuf->tail != vbuf->array && m == - (const char*)((vbuf->tail-1)->iov_base) + (vbuf->tail-1)->iov_len) { - (vbuf->tail-1)->iov_len += len; - return 0; - } else { - return msgpack_vrefbuffer_append_ref(vbuf, m, len); - } + if(vbuf->tail != vbuf->array && m == + (const char*)((vbuf->tail-1)->iov_base) + (vbuf->tail-1)->iov_len) { + (vbuf->tail-1)->iov_len += len; + return 0; + } else { + return msgpack_vrefbuffer_append_ref(vbuf, m, len); + } } int msgpack_vrefbuffer_migrate(msgpack_vrefbuffer* vbuf, msgpack_vrefbuffer* to) { - size_t sz = vbuf->chunk_size; + size_t sz = vbuf->chunk_size; - msgpack_vrefbuffer_chunk* empty = (msgpack_vrefbuffer_chunk*)malloc( - sizeof(msgpack_vrefbuffer_chunk) + sz); - if(empty == NULL) { - return -1; - } + msgpack_vrefbuffer_chunk* empty = (msgpack_vrefbuffer_chunk*)malloc( + sizeof(msgpack_vrefbuffer_chunk) + sz); + if(empty == NULL) { + return -1; + } - empty->next = NULL; + empty->next = NULL; - const size_t nused = (size_t)(vbuf->tail - vbuf->array); - if(to->tail + nused < vbuf->end) { - const size_t tosize = (size_t)(to->tail - to->array); - const size_t reqsize = nused + tosize; - size_t nnext = (size_t)(to->end - to->array) * 2; - while(nnext < reqsize) { - nnext *= 2; - } + const size_t nused = (size_t)(vbuf->tail - vbuf->array); + if(to->tail + nused < vbuf->end) { + const size_t tosize = (size_t)(to->tail - to->array); + const size_t reqsize = nused + tosize; + size_t nnext = (size_t)(to->end - to->array) * 2; + while(nnext < reqsize) { + nnext *= 2; + } - struct iovec* nvec = (struct iovec*)realloc( - to->array, sizeof(struct iovec)*nnext); - if(nvec == NULL) { - free(empty); - return -1; - } + struct iovec* nvec = (struct iovec*)realloc( + to->array, sizeof(struct iovec)*nnext); + if(nvec == NULL) { + free(empty); + return -1; + } - to->array = nvec; - to->end = nvec + nnext; - to->tail = nvec + tosize; - } + to->array = nvec; + to->end = nvec + nnext; + to->tail = nvec + tosize; + } - memcpy(to->tail, vbuf->array, sizeof(struct iovec)*nused); + memcpy(to->tail, vbuf->array, sizeof(struct iovec)*nused); - to->tail += nused; - vbuf->tail = vbuf->array; + to->tail += nused; + vbuf->tail = vbuf->array; - msgpack_vrefbuffer_inner_buffer* const ib = &vbuf->inner_buffer; - msgpack_vrefbuffer_inner_buffer* const toib = &to->inner_buffer; + msgpack_vrefbuffer_inner_buffer* const ib = &vbuf->inner_buffer; + msgpack_vrefbuffer_inner_buffer* const toib = &to->inner_buffer; - msgpack_vrefbuffer_chunk* last = ib->head; - while(last->next != NULL) { - last = last->next; - } - last->next = toib->head; - toib->head = ib->head; + msgpack_vrefbuffer_chunk* last = ib->head; + while(last->next != NULL) { + last = last->next; + } + last->next = toib->head; + toib->head = ib->head; - if(toib->free < ib->free) { - toib->free = ib->free; - toib->ptr = ib->ptr; - } + if(toib->free < ib->free) { + toib->free = ib->free; + toib->ptr = ib->ptr; + } - ib->head = empty; - ib->free = sz; - ib->ptr = ((char*)empty) + sizeof(msgpack_vrefbuffer_chunk); + ib->head = empty; + ib->free = sz; + ib->ptr = ((char*)empty) + sizeof(msgpack_vrefbuffer_chunk); - return 0; + return 0; } - diff --git a/src/zone.c b/src/zone.c index f982cf7c..33e25169 100644 --- a/src/zone.c +++ b/src/zone.c @@ -20,202 +20,202 @@ #include struct msgpack_zone_chunk { - struct msgpack_zone_chunk* next; - /* data ... */ + struct msgpack_zone_chunk* next; + /* data ... */ }; static inline bool init_chunk_list(msgpack_zone_chunk_list* cl, size_t chunk_size) { - msgpack_zone_chunk* chunk = (msgpack_zone_chunk*)malloc( - sizeof(msgpack_zone_chunk) + chunk_size); - if(chunk == NULL) { - return false; - } + msgpack_zone_chunk* chunk = (msgpack_zone_chunk*)malloc( + sizeof(msgpack_zone_chunk) + chunk_size); + if(chunk == NULL) { + return false; + } - cl->head = chunk; - cl->free = chunk_size; - cl->ptr = ((char*)chunk) + sizeof(msgpack_zone_chunk); - chunk->next = NULL; + cl->head = chunk; + cl->free = chunk_size; + cl->ptr = ((char*)chunk) + sizeof(msgpack_zone_chunk); + chunk->next = NULL; - return true; + return true; } static inline void destroy_chunk_list(msgpack_zone_chunk_list* cl) { - msgpack_zone_chunk* c = cl->head; - while(true) { - msgpack_zone_chunk* n = c->next; - free(c); - if(n != NULL) { - c = n; - } else { - break; - } - } + msgpack_zone_chunk* c = cl->head; + while(true) { + msgpack_zone_chunk* n = c->next; + free(c); + if(n != NULL) { + c = n; + } else { + break; + } + } } static inline void clear_chunk_list(msgpack_zone_chunk_list* cl, size_t chunk_size) { - msgpack_zone_chunk* c = cl->head; - while(true) { - msgpack_zone_chunk* n = c->next; - if(n != NULL) { - free(c); - c = n; - } else { - cl->head = c; - break; - } - } - cl->head->next = NULL; - cl->free = chunk_size; - cl->ptr = ((char*)cl->head) + sizeof(msgpack_zone_chunk); + msgpack_zone_chunk* c = cl->head; + while(true) { + msgpack_zone_chunk* n = c->next; + if(n != NULL) { + free(c); + c = n; + } else { + cl->head = c; + break; + } + } + cl->head->next = NULL; + cl->free = chunk_size; + cl->ptr = ((char*)cl->head) + sizeof(msgpack_zone_chunk); } void* msgpack_zone_malloc_expand(msgpack_zone* zone, size_t size) { - msgpack_zone_chunk_list* const cl = &zone->chunk_list; + msgpack_zone_chunk_list* const cl = &zone->chunk_list; - size_t sz = zone->chunk_size; + size_t sz = zone->chunk_size; - while(sz < size) { - sz *= 2; - } + while(sz < size) { + sz *= 2; + } - msgpack_zone_chunk* chunk = (msgpack_zone_chunk*)malloc( - sizeof(msgpack_zone_chunk) + sz); - if (chunk == NULL) return NULL; - char* ptr = ((char*)chunk) + sizeof(msgpack_zone_chunk); - chunk->next = cl->head; - cl->head = chunk; - cl->free = sz - size; - cl->ptr = ptr + size; + msgpack_zone_chunk* chunk = (msgpack_zone_chunk*)malloc( + sizeof(msgpack_zone_chunk) + sz); + if (chunk == NULL) return NULL; + char* ptr = ((char*)chunk) + sizeof(msgpack_zone_chunk); + chunk->next = cl->head; + cl->head = chunk; + cl->free = sz - size; + cl->ptr = ptr + size; - return ptr; + return ptr; } static inline void init_finalizer_array(msgpack_zone_finalizer_array* fa) { - fa->tail = NULL; - fa->end = NULL; - fa->array = NULL; + fa->tail = NULL; + fa->end = NULL; + fa->array = NULL; } static inline void call_finalizer_array(msgpack_zone_finalizer_array* fa) { - msgpack_zone_finalizer* fin = fa->tail; - for(; fin != fa->array; --fin) { - (*(fin-1)->func)((fin-1)->data); - } + msgpack_zone_finalizer* fin = fa->tail; + for(; fin != fa->array; --fin) { + (*(fin-1)->func)((fin-1)->data); + } } static inline void destroy_finalizer_array(msgpack_zone_finalizer_array* fa) { - call_finalizer_array(fa); - free(fa->array); + call_finalizer_array(fa); + free(fa->array); } static inline void clear_finalizer_array(msgpack_zone_finalizer_array* fa) { - call_finalizer_array(fa); - fa->tail = fa->array; + call_finalizer_array(fa); + fa->tail = fa->array; } bool msgpack_zone_push_finalizer_expand(msgpack_zone* zone, - void (*func)(void* data), void* data) + void (*func)(void* data), void* data) { - msgpack_zone_finalizer_array* const fa = &zone->finalizer_array; + msgpack_zone_finalizer_array* const fa = &zone->finalizer_array; - const size_t nused = (size_t)(fa->end - fa->array); + const size_t nused = (size_t)(fa->end - fa->array); - size_t nnext; - if(nused == 0) { - nnext = (sizeof(msgpack_zone_finalizer) < 72/2) ? - 72 / sizeof(msgpack_zone_finalizer) : 8; + size_t nnext; + if(nused == 0) { + nnext = (sizeof(msgpack_zone_finalizer) < 72/2) ? + 72 / sizeof(msgpack_zone_finalizer) : 8; - } else { - nnext = nused * 2; - } + } else { + nnext = nused * 2; + } - msgpack_zone_finalizer* tmp = - (msgpack_zone_finalizer*)realloc(fa->array, - sizeof(msgpack_zone_finalizer) * nnext); - if(tmp == NULL) { - return false; - } + msgpack_zone_finalizer* tmp = + (msgpack_zone_finalizer*)realloc(fa->array, + sizeof(msgpack_zone_finalizer) * nnext); + if(tmp == NULL) { + return false; + } - fa->array = tmp; - fa->end = tmp + nnext; - fa->tail = tmp + nused; + fa->array = tmp; + fa->end = tmp + nnext; + fa->tail = tmp + nused; - fa->tail->func = func; - fa->tail->data = data; + fa->tail->func = func; + fa->tail->data = data; - ++fa->tail; + ++fa->tail; - return true; + return true; } bool msgpack_zone_is_empty(msgpack_zone* zone) { - msgpack_zone_chunk_list* const cl = &zone->chunk_list; - msgpack_zone_finalizer_array* const fa = &zone->finalizer_array; - return cl->free == zone->chunk_size && cl->head->next == NULL && - fa->tail == fa->array; + msgpack_zone_chunk_list* const cl = &zone->chunk_list; + msgpack_zone_finalizer_array* const fa = &zone->finalizer_array; + return cl->free == zone->chunk_size && cl->head->next == NULL && + fa->tail == fa->array; } void msgpack_zone_destroy(msgpack_zone* zone) { - destroy_finalizer_array(&zone->finalizer_array); - destroy_chunk_list(&zone->chunk_list); + destroy_finalizer_array(&zone->finalizer_array); + destroy_chunk_list(&zone->chunk_list); } void msgpack_zone_clear(msgpack_zone* zone) { - clear_finalizer_array(&zone->finalizer_array); - clear_chunk_list(&zone->chunk_list, zone->chunk_size); + clear_finalizer_array(&zone->finalizer_array); + clear_chunk_list(&zone->chunk_list, zone->chunk_size); } bool msgpack_zone_init(msgpack_zone* zone, size_t chunk_size) { - zone->chunk_size = chunk_size; + zone->chunk_size = chunk_size; - if(!init_chunk_list(&zone->chunk_list, chunk_size)) { - return false; - } + if(!init_chunk_list(&zone->chunk_list, chunk_size)) { + return false; + } - init_finalizer_array(&zone->finalizer_array); + init_finalizer_array(&zone->finalizer_array); - return true; + return true; } msgpack_zone* msgpack_zone_new(size_t chunk_size) { - msgpack_zone* zone = (msgpack_zone*)malloc( - sizeof(msgpack_zone) + chunk_size); - if(zone == NULL) { - return NULL; - } + msgpack_zone* zone = (msgpack_zone*)malloc( + sizeof(msgpack_zone)); + if(zone == NULL) { + return NULL; + } - zone->chunk_size = chunk_size; + zone->chunk_size = chunk_size; - if(!init_chunk_list(&zone->chunk_list, chunk_size)) { - free(zone); - return NULL; - } + if(!init_chunk_list(&zone->chunk_list, chunk_size)) { + free(zone); + return NULL; + } - init_finalizer_array(&zone->finalizer_array); + init_finalizer_array(&zone->finalizer_array); - return zone; + return zone; } void msgpack_zone_free(msgpack_zone* zone) { - if(zone == NULL) { return; } - msgpack_zone_destroy(zone); - free(zone); + if(zone == NULL) { return; } + msgpack_zone_destroy(zone); + free(zone); } diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 252fd164..59bf41d8 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -3,53 +3,61 @@ FIND_PACKAGE (ZLIB REQUIRED) FIND_PACKAGE (Threads REQUIRED) INCLUDE_DIRECTORIES ( - ${GTEST_INCLUDE_DIRS} - ${ZLIB_INCLUDE_DIRS} + ${GTEST_INCLUDE_DIRS} + ${ZLIB_INCLUDE_DIRS} ) -SET (check_PROGRAMS - pack_unpack.cc - version.cc - streaming_c.cc - pack_unpack_c.cc - zone.cc - msgpack_test.cpp - buffer.cc - msgpackc_test.cpp - streaming.cc - convert.cc - fixint_c.cc +LIST (APPEND check_PROGRAMS + zone.cpp + pack_unpack.cpp + pack_unpack_c.cpp + streaming.cpp + streaming_c.cpp + object.cpp + object_with_zone.cpp + version.cpp + convert.cpp + buffer.cpp + cases.cpp + fixint.cpp + fixint_c.cpp + msgpack_tuple.cpp + msgpack_basic.cpp + msgpack_container.cpp + msgpack_stream.cpp + msgpack_vref.cpp + msgpack_c.cpp + reference.cpp ) -IF (MSGPACK_ENABLE_CXX) - LIST (APPEND check_PROGRAMS - cases.cc - fixint.cc - object.cc - ) +IF (MSGPACK_CXX11) + LIST (APPEND check_PROGRAMS + msgpack_cpp11.cpp + reference_cpp11.cpp + ) ENDIF () FOREACH (source_file ${check_PROGRAMS}) - GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE) - ADD_EXECUTABLE ( - ${source_file_we} - ${source_file} - ) - TARGET_LINK_LIBRARIES (${source_file_we} - msgpack - ${GTEST_BOTH_LIBRARIES} - ${ZLIB_LIBRARIES} - ${CMAKE_THREAD_LIBS_INIT} - ) - ADD_TEST (${source_file_we} ${source_file_we}) - IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") - SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -g -O3") - ENDIF () - IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") - IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]") - STRING(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") - ELSE () - SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4") - ENDIF () - ENDIF () + GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE) + ADD_EXECUTABLE ( + ${source_file_we} + ${source_file} + ) + TARGET_LINK_LIBRARIES (${source_file_we} + msgpack + ${GTEST_BOTH_LIBRARIES} + ${ZLIB_LIBRARIES} + ${CMAKE_THREAD_LIBS_INIT} + ) + ADD_TEST (${source_file_we} ${source_file_we}) + IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") + SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -g -O3") + ENDIF () + IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") + IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]") + STRING(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") + ELSE () + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4") + ENDIF () + ENDIF () ENDFOREACH () diff --git a/test/Makefile.am b/test/Makefile.am index 1939f25c..c12c56d2 100644 --- a/test/Makefile.am +++ b/test/Makefile.am @@ -1,6 +1,5 @@ - -AM_CPPFLAGS = -I$(top_srcdir)/src -I$(top_builddir)/src -AM_C_CPPFLAGS = -I$(top_srcdir)/src -I$(top_builddir)/src +AM_CPPFLAGS = -I$(top_srcdir)/include +AM_C_CPPFLAGS = -I$(top_srcdir)/include AM_LDFLAGS = $(top_builddir)/src/libmsgpack.la -lgtest_main -lgtest -pthread check_PROGRAMS = \ @@ -10,45 +9,68 @@ check_PROGRAMS = \ streaming \ streaming_c \ object \ + object_with_zone \ convert \ buffer \ cases \ fixint \ fixint_c \ version \ - msgpackc_test \ - msgpack_test + msgpack_tuple \ + msgpack_c \ + msgpack_basic \ + msgpack_container \ + msgpack_stream \ + msgpack_vref \ + msgpack_cpp11 \ + reference_cpp11 \ + reference TESTS = $(check_PROGRAMS) -zone_SOURCES = zone.cc +zone_SOURCES = zone.cpp -pack_unpack_SOURCES = pack_unpack.cc +pack_unpack_SOURCES = pack_unpack.cpp -pack_unpack_c_SOURCES = pack_unpack_c.cc +pack_unpack_c_SOURCES = pack_unpack_c.cpp -streaming_SOURCES = streaming.cc +streaming_SOURCES = streaming.cpp -streaming_c_SOURCES = streaming_c.cc +streaming_c_SOURCES = streaming_c.cpp -object_SOURCES = object.cc +object_SOURCES = object.cpp -convert_SOURCES = convert.cc +object_with_zone_SOURCES = object_with_zone.cpp -buffer_SOURCES = buffer.cc +convert_SOURCES = convert.cpp + +buffer_SOURCES = buffer.cpp buffer_LDADD = -lz -cases_SOURCES = cases.cc +cases_SOURCES = cases.cpp -fixint_SOURCES = fixint.cc +fixint_SOURCES = fixint.cpp -fixint_c_SOURCES = fixint_c.cc +fixint_c_SOURCES = fixint_c.cpp -version_SOURCES = version.cc +version_SOURCES = version.cpp -msgpackc_test_SOURCES = msgpackc_test.cpp +msgpack_tuple_SOURCES = msgpack_tuple.cpp -msgpack_test_SOURCES = msgpack_test.cpp +msgpack_c_SOURCES = msgpack_c.cpp + +msgpack_basic_SOURCES = msgpack_basic.cpp + +msgpack_container_SOURCES = msgpack_container.cpp + +msgpack_stream_SOURCES = msgpack_stream.cpp + +msgpack_vref_SOURCES = msgpack_vref.cpp + +msgpack_cpp11_SOURCES = msgpack_cpp11.cpp + +reference_SOURCES = reference.cpp + +reference_cpp11_SOURCES = reference_cpp11.cpp EXTRA_DIST = cases.mpac cases_compact.mpac - diff --git a/test/buffer.cc b/test/buffer.cc deleted file mode 100644 index 35d731a5..00000000 --- a/test/buffer.cc +++ /dev/null @@ -1,120 +0,0 @@ -#include -#include -#include -#include -#include -#include - -TEST(buffer, sbuffer) -{ - msgpack::sbuffer sbuf; - sbuf.write("a", 1); - sbuf.write("a", 1); - sbuf.write("a", 1); - - EXPECT_EQ(3, sbuf.size()); - EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 ); - - sbuf.clear(); - sbuf.write("a", 1); - sbuf.write("a", 1); - sbuf.write("a", 1); - - EXPECT_EQ(3, sbuf.size()); - EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 ); -} - - -TEST(buffer, vrefbuffer) -{ - msgpack::vrefbuffer vbuf; - vbuf.write("a", 1); - vbuf.write("a", 1); - vbuf.write("a", 1); - - const struct iovec* vec = vbuf.vector(); - size_t veclen = vbuf.vector_size(); - - msgpack::sbuffer sbuf; - for(size_t i=0; i < veclen; ++i) { - sbuf.write((const char*)vec[i].iov_base, vec[i].iov_len); - } - - EXPECT_EQ(3, sbuf.size()); - EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 ); - - - vbuf.clear(); - vbuf.write("a", 1); - vbuf.write("a", 1); - vbuf.write("a", 1); - - vec = vbuf.vector(); - veclen = vbuf.vector_size(); - - sbuf.clear(); - for(size_t i=0; i < veclen; ++i) { - sbuf.write((const char*)vec[i].iov_base, vec[i].iov_len); - } - - EXPECT_EQ(3, sbuf.size()); - EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 ); -} - - -TEST(buffer, zbuffer) -{ - msgpack::zbuffer zbuf; - zbuf.write("a", 1); - zbuf.write("a", 1); - zbuf.write("a", 1); - - zbuf.flush(); -} - - -TEST(buffer, fbuffer) -{ - FILE* file = tmpfile(); - EXPECT_TRUE( file != NULL ); - - msgpack::fbuffer fbuf(file); - EXPECT_EQ(file, fbuf.file()); - - fbuf.write("a", 1); - fbuf.write("a", 1); - fbuf.write("a", 1); - - fflush(file); - rewind(file); - for (size_t i=0; i < 3; ++i) { - int ch = fgetc(file); - EXPECT_TRUE(ch != EOF); - EXPECT_EQ('a', static_cast(ch)); - } - EXPECT_EQ(EOF, fgetc(file)); - fclose(file); -} - - -TEST(buffer, fbuffer_c) -{ - FILE* file = tmpfile(); - void* fbuf = (void*)file; - - EXPECT_TRUE( file != NULL ); - EXPECT_EQ(0, msgpack_fbuffer_write(fbuf, "a", 1)); - EXPECT_EQ(0, msgpack_fbuffer_write(fbuf, "a", 1)); - EXPECT_EQ(0, msgpack_fbuffer_write(fbuf, "a", 1)); - - fflush(file); - rewind(file); - for (size_t i=0; i < 3; ++i) { - int ch = fgetc(file); - EXPECT_TRUE(ch != EOF); - EXPECT_EQ('a', (char) ch); - } - EXPECT_EQ(EOF, fgetc(file)); - fclose(file); -} - diff --git a/test/buffer.cpp b/test/buffer.cpp new file mode 100644 index 00000000..512b0bc4 --- /dev/null +++ b/test/buffer.cpp @@ -0,0 +1,119 @@ +#include +#include +#include +#include +#include +#include + +TEST(buffer, sbuffer) +{ + msgpack::sbuffer sbuf; + sbuf.write("a", 1); + sbuf.write("a", 1); + sbuf.write("a", 1); + + EXPECT_EQ(3, sbuf.size()); + EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 ); + + sbuf.clear(); + sbuf.write("a", 1); + sbuf.write("a", 1); + sbuf.write("a", 1); + + EXPECT_EQ(3, sbuf.size()); + EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 ); +} + + +TEST(buffer, vrefbuffer) +{ + msgpack::vrefbuffer vbuf; + vbuf.write("a", 1); + vbuf.write("a", 1); + vbuf.write("a", 1); + + const struct iovec* vec = vbuf.vector(); + size_t veclen = vbuf.vector_size(); + + msgpack::sbuffer sbuf; + for(size_t i=0; i < veclen; ++i) { + sbuf.write((const char*)vec[i].iov_base, vec[i].iov_len); + } + + EXPECT_EQ(3, sbuf.size()); + EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 ); + + + vbuf.clear(); + vbuf.write("a", 1); + vbuf.write("a", 1); + vbuf.write("a", 1); + + vec = vbuf.vector(); + veclen = vbuf.vector_size(); + + sbuf.clear(); + for(size_t i=0; i < veclen; ++i) { + sbuf.write((const char*)vec[i].iov_base, vec[i].iov_len); + } + + EXPECT_EQ(3, sbuf.size()); + EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 ); +} + + +TEST(buffer, zbuffer) +{ + msgpack::zbuffer zbuf; + zbuf.write("a", 1); + zbuf.write("a", 1); + zbuf.write("a", 1); + + zbuf.flush(); +} + + +TEST(buffer, fbuffer) +{ + FILE* file = tmpfile(); + EXPECT_TRUE( file != NULL ); + + msgpack::fbuffer fbuf(file); + EXPECT_EQ(file, fbuf.file()); + + fbuf.write("a", 1); + fbuf.write("a", 1); + fbuf.write("a", 1); + + fflush(file); + rewind(file); + for (size_t i=0; i < 3; ++i) { + int ch = fgetc(file); + EXPECT_TRUE(ch != EOF); + EXPECT_EQ('a', static_cast(ch)); + } + EXPECT_EQ(EOF, fgetc(file)); + fclose(file); +} + + +TEST(buffer, fbuffer_c) +{ + FILE* file = tmpfile(); + void* fbuf = (void*)file; + + EXPECT_TRUE( file != NULL ); + EXPECT_EQ(0, msgpack_fbuffer_write(fbuf, "a", 1)); + EXPECT_EQ(0, msgpack_fbuffer_write(fbuf, "a", 1)); + EXPECT_EQ(0, msgpack_fbuffer_write(fbuf, "a", 1)); + + fflush(file); + rewind(file); + for (size_t i=0; i < 3; ++i) { + int ch = fgetc(file); + EXPECT_TRUE(ch != EOF); + EXPECT_EQ('a', (char) ch); + } + EXPECT_EQ(EOF, fgetc(file)); + fclose(file); +} diff --git a/test/cases.cc b/test/cases.cc deleted file mode 100644 index eb1286c7..00000000 --- a/test/cases.cc +++ /dev/null @@ -1,38 +0,0 @@ -#include -#include -#include - -static void feed_file(msgpack::unpacker& pac, const char* path) -{ - std::ifstream fin(path); - while(true) { - pac.reserve_buffer(32*1024); - fin.read(pac.buffer(), pac.buffer_capacity()); - if(fin.bad()) { - throw std::runtime_error("read failed"); - } - pac.buffer_consumed(fin.gcount()); - if(fin.fail()) { - break; - } - } -} - -TEST(cases, format) -{ - msgpack::unpacker pac; - msgpack::unpacker pac_compact; - - feed_file(pac, "cases.mpac"); - feed_file(pac_compact, "cases_compact.mpac"); - - msgpack::unpacked result; - while(pac.next(&result)) { - msgpack::unpacked result_compact; - EXPECT_TRUE( pac_compact.next(&result_compact) ); - EXPECT_EQ(result_compact.get(), result.get()); - } - - EXPECT_FALSE( pac_compact.next(&result) ); -} - diff --git a/test/cases.cpp b/test/cases.cpp new file mode 100644 index 00000000..45aace0b --- /dev/null +++ b/test/cases.cpp @@ -0,0 +1,38 @@ +#include +#include +#include + +static void feed_file(msgpack::unpacker& pac, const char* path) +{ + std::ifstream fin(path); + while(true) { + pac.reserve_buffer(32*1024); + fin.read(pac.buffer(), pac.buffer_capacity()); + if(fin.bad()) { + throw std::runtime_error("read failed"); + } + pac.buffer_consumed(fin.gcount()); + if(fin.fail()) { + break; + } + } +} + +TEST(cases, format) +{ + msgpack::unpacker pac; + msgpack::unpacker pac_compact; + + feed_file(pac, "cases.mpac"); + feed_file(pac_compact, "cases_compact.mpac"); + + msgpack::unpacked result; + while(pac.next(&result)) { + msgpack::unpacked result_compact; + EXPECT_TRUE( pac_compact.next(&result_compact) ); + EXPECT_EQ(result_compact.get(), result.get()); + } + + EXPECT_FALSE( pac_compact.next(&result) ); +} + diff --git a/test/convert.cc b/test/convert.cc deleted file mode 100644 index f579f33a..00000000 --- a/test/convert.cc +++ /dev/null @@ -1,76 +0,0 @@ -#include -#include - -class compatibility { -public: - compatibility() : str1("default"), str2("default") { } - - std::string str1; - std::string str2; - - MSGPACK_DEFINE(str1, str2); -}; - -TEST(convert, compatibility_less) -{ - std::vector src(1); - src[0] = "kumofs"; - - msgpack::zone z; - msgpack::object obj(src, &z); - - compatibility c; - EXPECT_NO_THROW( obj.convert(&c) ); - - EXPECT_EQ("kumofs", c.str1); - EXPECT_EQ("default", c.str2); -} - -TEST(convert, compatibility_more) -{ - std::vector src(3); - src[0] = "kumofs"; - src[1] = "mpio"; - src[2] = "cloudy"; - - msgpack::zone z; - msgpack::object obj(src, &z); - - compatibility to; - EXPECT_NO_THROW( obj.convert(&to) ); - - EXPECT_EQ("kumofs", to.str1); - EXPECT_EQ("mpio", to.str2); -} - - -class enum_member { -public: - enum_member() : flag(A) { } - - enum flags_t { - A = 0, - B = 1, - }; - - flags_t flag; - - MSGPACK_DEFINE(flag); -}; - -MSGPACK_ADD_ENUM(enum_member::flags_t); - -TEST(convert, enum_member) -{ - enum_member src; - src.flag = enum_member::B; - - msgpack::zone z; - msgpack::object obj(src, &z); - - enum_member to; - EXPECT_NO_THROW( obj.convert(&to) ); - - EXPECT_EQ(enum_member::B, to.flag); -} - diff --git a/test/convert.cpp b/test/convert.cpp new file mode 100644 index 00000000..dcda77c6 --- /dev/null +++ b/test/convert.cpp @@ -0,0 +1,76 @@ +#include +#include + +class compatibility { +public: + compatibility() : str1("default"), str2("default") { } + + std::string str1; + std::string str2; + + MSGPACK_DEFINE(str1, str2); +}; + +TEST(convert, compatibility_less) +{ + std::vector src(1); + src[0] = "kumofs"; + + msgpack::zone z; + msgpack::object obj(src, &z); + + compatibility c; + EXPECT_NO_THROW( obj.convert(&c) ); + + EXPECT_EQ("kumofs", c.str1); + EXPECT_EQ("default", c.str2); +} + +TEST(convert, compatibility_more) +{ + std::vector src(3); + src[0] = "kumofs"; + src[1] = "mpio"; + src[2] = "cloudy"; + + msgpack::zone z; + msgpack::object obj(src, &z); + + compatibility to; + EXPECT_NO_THROW( obj.convert(&to) ); + + EXPECT_EQ("kumofs", to.str1); + EXPECT_EQ("mpio", to.str2); +} + + +class enum_member { +public: + enum_member() : flag(A) { } + + enum flags_t { + A = 0, + B = 1 + }; + + flags_t flag; + + MSGPACK_DEFINE(flag); +}; + +MSGPACK_ADD_ENUM(enum_member::flags_t); + +TEST(convert, enum_member) +{ + enum_member src; + src.flag = enum_member::B; + + msgpack::zone z; + msgpack::object obj(src, &z); + + enum_member to; + EXPECT_NO_THROW( obj.convert(&to) ); + + EXPECT_EQ(enum_member::B, to.flag); +} + diff --git a/test/fixint.cc b/test/fixint.cc deleted file mode 100644 index 63288a1b..00000000 --- a/test/fixint.cc +++ /dev/null @@ -1,55 +0,0 @@ -#include -#include - -template -void check_size(size_t size) { - T v(0); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, v); - EXPECT_EQ(size, sbuf.size()); -} - -TEST(fixint, size) -{ - check_size(2); - check_size(3); - check_size(5); - check_size(9); - - check_size(2); - check_size(3); - check_size(5); - check_size(9); -} - - -template -void check_convert() { - T v1(-11); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, v1); - - msgpack::unpacked msg; - msgpack::unpack(&msg, sbuf.data(), sbuf.size()); - - T v2; - msg.get().convert(&v2); - - EXPECT_EQ(v1.get(), v2.get()); - - EXPECT_EQ(msg.get(), msgpack::object(T(v1.get()))); -} - -TEST(fixint, convert) -{ - check_convert(); - check_convert(); - check_convert(); - check_convert(); - - check_convert(); - check_convert(); - check_convert(); - check_convert(); -} - diff --git a/test/fixint.cpp b/test/fixint.cpp new file mode 100644 index 00000000..cf109ae5 --- /dev/null +++ b/test/fixint.cpp @@ -0,0 +1,55 @@ +#include +#include + +template +void check_size(size_t size) { + T v(0); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, v); + EXPECT_EQ(size, sbuf.size()); +} + +TEST(fixint, size) +{ + check_size(2); + check_size(3); + check_size(5); + check_size(9); + + check_size(2); + check_size(3); + check_size(5); + check_size(9); +} + + +template +void check_convert() { + T v1(-11); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, v1); + + msgpack::unpacked msg; + msgpack::unpack(&msg, sbuf.data(), sbuf.size()); + + T v2; + msg.get().convert(&v2); + + EXPECT_EQ(v1.get(), v2.get()); + + EXPECT_EQ(msg.get(), msgpack::object(T(v1.get()))); +} + +TEST(fixint, convert) +{ + check_convert(); + check_convert(); + check_convert(); + check_convert(); + + check_convert(); + check_convert(); + check_convert(); + check_convert(); +} + diff --git a/test/fixint_c.cc b/test/fixint_c.cc deleted file mode 100644 index caa4d262..00000000 --- a/test/fixint_c.cc +++ /dev/null @@ -1,32 +0,0 @@ -#include -#include - -TEST(fixint, size) -{ - msgpack_sbuffer* sbuf = msgpack_sbuffer_new(); - msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write); - - size_t sum = 0; - - EXPECT_EQ(0, msgpack_pack_fix_int8(pk, 0)); - EXPECT_EQ(sum+=2, sbuf->size); - EXPECT_EQ(0, msgpack_pack_fix_int16(pk, 0)); - EXPECT_EQ(sum+=3, sbuf->size); - EXPECT_EQ(0, msgpack_pack_fix_int32(pk, 0)); - EXPECT_EQ(sum+=5, sbuf->size); - EXPECT_EQ(0, msgpack_pack_fix_int64(pk, 0)); - EXPECT_EQ(sum+=9, sbuf->size); - - EXPECT_EQ(0, msgpack_pack_fix_uint8(pk, 0)); - EXPECT_EQ(sum+=2, sbuf->size); - EXPECT_EQ(0, msgpack_pack_fix_uint16(pk, 0)); - EXPECT_EQ(sum+=3, sbuf->size); - EXPECT_EQ(0, msgpack_pack_fix_uint32(pk, 0)); - EXPECT_EQ(sum+=5, sbuf->size); - EXPECT_EQ(0, msgpack_pack_fix_uint64(pk, 0)); - EXPECT_EQ(sum+=9, sbuf->size); - - msgpack_sbuffer_free(sbuf); - msgpack_packer_free(pk); -} - diff --git a/test/fixint_c.cpp b/test/fixint_c.cpp new file mode 100644 index 00000000..d9dc5180 --- /dev/null +++ b/test/fixint_c.cpp @@ -0,0 +1,32 @@ +#include +#include + +TEST(fixint, size) +{ + msgpack_sbuffer* sbuf = msgpack_sbuffer_new(); + msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write); + + size_t sum = 0; + + EXPECT_EQ(0, msgpack_pack_fix_int8(pk, 0)); + EXPECT_EQ(sum+=2, sbuf->size); + EXPECT_EQ(0, msgpack_pack_fix_int16(pk, 0)); + EXPECT_EQ(sum+=3, sbuf->size); + EXPECT_EQ(0, msgpack_pack_fix_int32(pk, 0)); + EXPECT_EQ(sum+=5, sbuf->size); + EXPECT_EQ(0, msgpack_pack_fix_int64(pk, 0)); + EXPECT_EQ(sum+=9, sbuf->size); + + EXPECT_EQ(0, msgpack_pack_fix_uint8(pk, 0)); + EXPECT_EQ(sum+=2, sbuf->size); + EXPECT_EQ(0, msgpack_pack_fix_uint16(pk, 0)); + EXPECT_EQ(sum+=3, sbuf->size); + EXPECT_EQ(0, msgpack_pack_fix_uint32(pk, 0)); + EXPECT_EQ(sum+=5, sbuf->size); + EXPECT_EQ(0, msgpack_pack_fix_uint64(pk, 0)); + EXPECT_EQ(sum+=9, sbuf->size); + + msgpack_sbuffer_free(sbuf); + msgpack_packer_free(pk); +} + diff --git a/test/msgpack_basic.cpp b/test/msgpack_basic.cpp new file mode 100644 index 00000000..210a6c5a --- /dev/null +++ b/test/msgpack_basic.cpp @@ -0,0 +1,471 @@ +#include "msgpack.hpp" + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +using namespace std; + +const unsigned int kLoop = 10000; +const unsigned int kElements = 100; +const double kEPS = 1e-10; + +#define GEN_TEST(test_type) \ + do { \ + vector v; \ + v.push_back(0); \ + v.push_back(1); \ + v.push_back(2); \ + v.push_back(numeric_limits::min()); \ + v.push_back(numeric_limits::max()); \ + for (unsigned int i = 0; i < kLoop; i++) \ + v.push_back(rand()); \ + for (unsigned int i = 0; i < v.size() ; i++) { \ + msgpack::sbuffer sbuf; \ + test_type val1 = v[i]; \ + msgpack::pack(sbuf, val1); \ + msgpack::unpacked ret; \ + msgpack::unpack(ret, sbuf.data(), sbuf.size()); \ + EXPECT_EQ(val1, ret.get().as()); \ + } \ +} while(0) + +TEST(MSGPACK, simple_buffer_char) +{ + GEN_TEST(char); +} + +TEST(MSGPACK, simple_buffer_signed_char) +{ + GEN_TEST(signed char); +} + +TEST(MSGPACK, simple_buffer_unsigned_char) +{ + GEN_TEST(unsigned char); +} + + +TEST(MSGPACK, simple_buffer_short) +{ + GEN_TEST(short); +} + +TEST(MSGPACK, simple_buffer_int) +{ + GEN_TEST(int); +} + +TEST(MSGPACK, simple_buffer_long) +{ + GEN_TEST(long); +} + +TEST(MSGPACK, simple_buffer_long_long) +{ + GEN_TEST(long long); +} + +TEST(MSGPACK, simple_buffer_unsigned_short) +{ + GEN_TEST(unsigned short); +} + +TEST(MSGPACK, simple_buffer_unsigned_int) +{ + GEN_TEST(unsigned int); +} + +TEST(MSGPACK, simple_buffer_unsigned_long) +{ + GEN_TEST(unsigned long); +} + +TEST(MSGPACK, simple_buffer_unsigned_long_long) +{ + GEN_TEST(unsigned long long); +} + +TEST(MSGPACK, simple_buffer_uint8) +{ + GEN_TEST(uint8_t); +} + +TEST(MSGPACK, simple_buffer_uint16) +{ + GEN_TEST(uint16_t); +} + +TEST(MSGPACK, simple_buffer_uint32) +{ + GEN_TEST(uint32_t); +} + +TEST(MSGPACK, simple_buffer_uint64) +{ + GEN_TEST(uint64_t); +} + +TEST(MSGPACK, simple_buffer_int8) +{ + GEN_TEST(int8_t); +} + +TEST(MSGPACK, simple_buffer_int16) +{ + GEN_TEST(int16_t); +} + +TEST(MSGPACK, simple_buffer_int32) +{ + GEN_TEST(int32_t); +} + +TEST(MSGPACK, simple_buffer_int64) +{ + GEN_TEST(int64_t); +} + +TEST(MSGPACK, simple_buffer_float) +{ + vector v; + v.push_back(0.0); + v.push_back(-0.0); + v.push_back(1.0); + v.push_back(-1.0); + v.push_back(numeric_limits::min()); + v.push_back(numeric_limits::max()); + v.push_back(nanf("tag")); + v.push_back(1.0/0.0); // inf + v.push_back(-(1.0/0.0)); // -inf + for (unsigned int i = 0; i < kLoop; i++) { + v.push_back(drand48()); + v.push_back(-drand48()); + } + for (unsigned int i = 0; i < v.size() ; i++) { + msgpack::sbuffer sbuf; + float val1 = v[i]; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + float val2 = ret.get().as(); + + if (std::isnan(val1)) + EXPECT_TRUE(std::isnan(val2)); + else if (std::isinf(val1)) + EXPECT_TRUE(std::isinf(val2)); + else + EXPECT_TRUE(fabs(val2 - val1) <= kEPS); + } +} + +namespace { +template +struct TypePair { + typedef F float_type; + typedef I integer_type; +}; +} // namespace + +template +class IntegerToFloatingPointTest : public testing::Test { +}; +TYPED_TEST_CASE_P(IntegerToFloatingPointTest); + +TYPED_TEST_P(IntegerToFloatingPointTest, simple_buffer) +{ + typedef typename TypeParam::float_type float_type; + typedef typename TypeParam::integer_type integer_type; + vector v; + v.push_back(0); + v.push_back(1); + if (numeric_limits::is_signed) v.push_back(-1); + else v.push_back(2); + for (unsigned int i = 0; i < kLoop; i++) { + v.push_back(rand() % 0x7FFFFF); + } + for (unsigned int i = 0; i < v.size() ; i++) { + msgpack::sbuffer sbuf; + integer_type val1 = v[i]; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + float_type val2 = ret.get().as(); + EXPECT_TRUE(fabs(val2 - val1) <= kEPS); + } +} + +REGISTER_TYPED_TEST_CASE_P(IntegerToFloatingPointTest, + simple_buffer); + +typedef testing::Types, + TypePair, + TypePair, + TypePair > IntegerToFloatingPointTestTypes; +INSTANTIATE_TYPED_TEST_CASE_P(IntegerToFloatingPointTestInstance, + IntegerToFloatingPointTest, + IntegerToFloatingPointTestTypes); + +TEST(MSGPACK, simple_buffer_double) +{ + vector v; + v.push_back(0.0); + v.push_back(-0.0); + v.push_back(1.0); + v.push_back(-1.0); + v.push_back(numeric_limits::min()); + v.push_back(numeric_limits::max()); + v.push_back(nanf("tag")); + v.push_back(1.0/0.0); // inf + v.push_back(-(1.0/0.0)); // -inf + for (unsigned int i = 0; i < kLoop; i++) { + v.push_back(drand48()); + v.push_back(-drand48()); + } + for (unsigned int i = 0; i < v.size() ; i++) { + msgpack::sbuffer sbuf; + double val1 = v[i]; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + double val2 = ret.get().as(); + + if (std::isnan(val1)) + EXPECT_TRUE(std::isnan(val2)); + else if (std::isinf(val1)) + EXPECT_TRUE(std::isinf(val2)); + else + EXPECT_TRUE(fabs(val2 - val1) <= kEPS); + } +} + +TEST(MSGPACK, simple_buffer_true) +{ + msgpack::sbuffer sbuf; + bool val1 = true; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + bool val2 = ret.get().as(); + EXPECT_EQ(val1, val2); +} + +TEST(MSGPACK, simple_buffer_false) +{ + msgpack::sbuffer sbuf; + bool val1 = false; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + bool val2 = ret.get().as(); + EXPECT_EQ(val1, val2); +} + +TEST(MSGPACK, simple_buffer_fixext1) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2 }; + + packer.pack_ext(sizeof(buf), 1); + packer.pack_ext_body(buf, sizeof(buf)); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(1, ret.get().via.ext.size); + EXPECT_EQ(1, ret.get().via.ext.type()); + EXPECT_EQ(2, ret.get().via.ext.data()[0]); +} + +TEST(MSGPACK, simple_buffer_fixext2) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2, 3 }; + + packer.pack_ext(sizeof(buf), 0); + packer.pack_ext_body(buf, sizeof(buf)); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(2, ret.get().via.ext.size); + EXPECT_EQ(0, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + +TEST(MSGPACK, simple_buffer_fixext4) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2, 3, 4, 5 }; + + packer.pack_ext(sizeof(buf), 1); + packer.pack_ext_body(buf, sizeof(buf)); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(4, ret.get().via.ext.size); + EXPECT_EQ(1, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + +TEST(MSGPACK, simple_buffer_fixext8) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9 }; + + packer.pack_ext(sizeof(buf), 1); + packer.pack_ext_body(buf, sizeof(buf)); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(8, ret.get().via.ext.size); + EXPECT_EQ(1, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + +TEST(MSGPACK, simple_buffer_fixext16) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 }; + + packer.pack_ext(sizeof(buf), 1); + packer.pack_ext_body(buf, sizeof(buf)); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(16, ret.get().via.ext.size); + EXPECT_EQ(1, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + +TEST(MSGPACK, simple_buffer_fixext_1byte_0) +{ + std::size_t const size = 0; + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + + packer.pack_ext(size, 77); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(size, ret.get().via.ext.size); + EXPECT_EQ(77, ret.get().via.ext.type()); +} + +TEST(MSGPACK, simple_buffer_fixext_1byte_255) +{ + std::size_t const size = 255; + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char buf[size]; + for (int i = 0; i != size; ++i) buf[i] = static_cast(i); + packer.pack_ext(sizeof(buf), 77); + packer.pack_ext_body(buf, sizeof(buf)); + + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(size, ret.get().via.ext.size); + EXPECT_EQ(77, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + +TEST(MSGPACK, simple_buffer_fixext_2byte_256) +{ + std::size_t const size = 256; + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char buf[size]; + for (int i = 0; i != size; ++i) buf[i] = static_cast(i); + packer.pack_ext(sizeof(buf), 77); + packer.pack_ext_body(buf, sizeof(buf)); + + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(size, ret.get().via.ext.size); + EXPECT_EQ(77, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + +TEST(MSGPACK, simple_buffer_fixext_2byte_65535) +{ + std::size_t const size = 65535; + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char buf[size]; + for (int i = 0; i != size; ++i) buf[i] = static_cast(i); + packer.pack_ext(sizeof(buf), 77); + packer.pack_ext_body(buf, sizeof(buf)); + + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(size, ret.get().via.ext.size); + EXPECT_EQ(77, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + +TEST(MSGPACK, simple_buffer_fixext_4byte_65536) +{ + std::size_t const size = 65536; + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char buf[size]; + for (int i = 0; i != size; ++i) buf[i] = static_cast(i); + packer.pack_ext(sizeof(buf), 77); + packer.pack_ext_body(buf, sizeof(buf)); + + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(size, ret.get().via.ext.size); + EXPECT_EQ(77, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + +TEST(MSGPACK_STL, simple_buffer_string) +{ + for (unsigned int k = 0; k < kLoop; k++) { + string val1; + for (unsigned int i = 0; i < kElements; i++) + val1 += 'a' + rand() % 26; + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(ret.get().type, msgpack::type::STR); + string val2 = ret.get().as(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_EQ(val1, val2); + } +} + +TEST(MSGPACK_STL, simple_buffer_cstring) +{ + for (unsigned int k = 0; k < kLoop; k++) { + string val1; + for (unsigned int i = 0; i < kElements; i++) + val1 += 'a' + rand() % 26; + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1.c_str()); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(ret.get().type, msgpack::type::STR); + string val2 = ret.get().as(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_EQ(val1, val2); + } +} diff --git a/test/msgpackc_test.cpp b/test/msgpack_c.cpp similarity index 58% rename from test/msgpackc_test.cpp rename to test/msgpack_c.cpp index 589ac4eb..7d832002 100644 --- a/test/msgpackc_test.cpp +++ b/test/msgpack_c.cpp @@ -80,9 +80,9 @@ TEST(MSGPACKC, simple_buffer_char) { #if defined(CHAR_MIN) #if CHAR_MIN < 0 - GEN_TEST_SIGNED(char, char); + GEN_TEST_SIGNED(char, char); #else - GEN_TEST_UNSIGNED(char, char); + GEN_TEST_UNSIGNED(char, char); #endif #else #error CHAR_MIN is not defined @@ -318,6 +318,260 @@ TEST(MSGPACKC, simple_buffer_false) msgpack_sbuffer_destroy(&sbuf); } +TEST(MSGPACKC, simple_buffer_fixext1) +{ + msgpack_sbuffer sbuf; + msgpack_sbuffer_init(&sbuf); + msgpack_packer pk; + msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); + char const buf[] = { 2 }; + + msgpack_pack_ext(&pk, sizeof(buf), 1); + msgpack_pack_ext_body(&pk, buf, sizeof(buf)); + msgpack_zone z; + msgpack_zone_init(&z, 2048); + msgpack_object obj; + msgpack_unpack_return ret = + msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); + EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); + EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); + EXPECT_EQ(1, obj.via.ext.size); + EXPECT_EQ(1, obj.via.ext.type); + EXPECT_EQ(2, obj.via.ext.ptr[0]); + msgpack_zone_destroy(&z); + msgpack_sbuffer_destroy(&sbuf); +} + +TEST(MSGPACKC, simple_buffer_fixext2) +{ + msgpack_sbuffer sbuf; + msgpack_sbuffer_init(&sbuf); + msgpack_packer pk; + msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); + char const buf[] = { 2, 3 }; + + msgpack_pack_ext(&pk, sizeof(buf), 0); + msgpack_pack_ext_body(&pk, buf, sizeof(buf)); + msgpack_zone z; + msgpack_zone_init(&z, 2048); + msgpack_object obj; + msgpack_unpack_return ret = + msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); + EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); + EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); + EXPECT_EQ(2, obj.via.ext.size); + EXPECT_EQ(0, obj.via.ext.type); + EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); + msgpack_zone_destroy(&z); + msgpack_sbuffer_destroy(&sbuf); +} + +TEST(MSGPACKC, simple_buffer_fixext4) +{ + msgpack_sbuffer sbuf; + msgpack_sbuffer_init(&sbuf); + msgpack_packer pk; + msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); + char const buf[] = { 2, 3, 4, 5 }; + + msgpack_pack_ext(&pk, sizeof(buf), 1); + msgpack_pack_ext_body(&pk, buf, sizeof(buf)); + msgpack_zone z; + msgpack_zone_init(&z, 2048); + msgpack_object obj; + msgpack_unpack_return ret = + msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); + EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); + EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); + EXPECT_EQ(4, obj.via.ext.size); + EXPECT_EQ(1, obj.via.ext.type); + EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); + msgpack_zone_destroy(&z); + msgpack_sbuffer_destroy(&sbuf); +} + +TEST(MSGPACKC, simple_buffer_fixext8) +{ + msgpack_sbuffer sbuf; + msgpack_sbuffer_init(&sbuf); + msgpack_packer pk; + msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); + char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9 }; + + msgpack_pack_ext(&pk, sizeof(buf), 1); + msgpack_pack_ext_body(&pk, buf, sizeof(buf)); + msgpack_zone z; + msgpack_zone_init(&z, 2048); + msgpack_object obj; + msgpack_unpack_return ret = + msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); + EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); + EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); + EXPECT_EQ(8, obj.via.ext.size); + EXPECT_EQ(1, obj.via.ext.type); + EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); + msgpack_zone_destroy(&z); + msgpack_sbuffer_destroy(&sbuf); +} + +TEST(MSGPACKC, simple_buffer_fixext16) +{ + msgpack_sbuffer sbuf; + msgpack_sbuffer_init(&sbuf); + msgpack_packer pk; + msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); + char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 }; + + msgpack_pack_ext(&pk, sizeof(buf), 1); + msgpack_pack_ext_body(&pk, buf, sizeof(buf)); + msgpack_zone z; + msgpack_zone_init(&z, 2048); + msgpack_object obj; + msgpack_unpack_return ret = + msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); + EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); + EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); + EXPECT_EQ(16, obj.via.ext.size); + EXPECT_EQ(1, obj.via.ext.type); + EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); + msgpack_zone_destroy(&z); + msgpack_sbuffer_destroy(&sbuf); +} + +TEST(MSGPACKC, simple_buffer_fixext_1byte_0) +{ + const size_t size = 0; + msgpack_sbuffer sbuf; + msgpack_sbuffer_init(&sbuf); + msgpack_packer pk; + msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); + + msgpack_pack_ext(&pk, size, 77); + // fprintf(stderr, "size: %u, data: \"", sbuf.size); + // for (size_t i = 0; i < sbuf.size; i++) + // fprintf(stderr, "%02x ", (uint8_t)sbuf.data[i]); + // fprintf(stderr, "\"\n"); + msgpack_zone z; + msgpack_zone_init(&z, 2048); + msgpack_object obj; + msgpack_unpack_return ret = + msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); + EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); + EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); + EXPECT_EQ(size, obj.via.ext.size); + EXPECT_EQ(77, obj.via.ext.type); + msgpack_zone_destroy(&z); + msgpack_sbuffer_destroy(&sbuf); +} + +TEST(MSGPACKC, simple_buffer_fixext_1byte_255) +{ + const size_t size = 255; + char buf[size]; + for (int i = 0; i != size; ++i) buf[i] = i; + + msgpack_sbuffer sbuf; + msgpack_sbuffer_init(&sbuf); + msgpack_packer pk; + msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); + + msgpack_pack_ext(&pk, size, 78); + msgpack_pack_ext_body(&pk, buf, sizeof(buf)); + msgpack_zone z; + msgpack_zone_init(&z, 2048); + msgpack_object obj; + msgpack_unpack_return ret = + msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); + EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); + EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); + EXPECT_EQ(size, obj.via.ext.size); + EXPECT_EQ(78, obj.via.ext.type); + EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); + msgpack_zone_destroy(&z); + msgpack_sbuffer_destroy(&sbuf); +} + +TEST(MSGPACKC, simple_buffer_fixext_2byte_256) +{ + const size_t size = 256; + char buf[size]; + for (int i = 0; i != size; ++i) buf[i] = i; + + msgpack_sbuffer sbuf; + msgpack_sbuffer_init(&sbuf); + msgpack_packer pk; + msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); + + msgpack_pack_ext(&pk, size, 79); + msgpack_pack_ext_body(&pk, buf, sizeof(buf)); + msgpack_zone z; + msgpack_zone_init(&z, 2048); + msgpack_object obj; + msgpack_unpack_return ret = + msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); + EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); + EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); + EXPECT_EQ(size, obj.via.ext.size); + EXPECT_EQ(79, obj.via.ext.type); + EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); + msgpack_zone_destroy(&z); + msgpack_sbuffer_destroy(&sbuf); +} + +TEST(MSGPACKC, simple_buffer_fixext_2byte_65535) +{ + const size_t size = 65535; + char buf[size]; + for (int i = 0; i != size; ++i) buf[i] = i; + + msgpack_sbuffer sbuf; + msgpack_sbuffer_init(&sbuf); + msgpack_packer pk; + msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); + + msgpack_pack_ext(&pk, size, 80); + msgpack_pack_ext_body(&pk, buf, sizeof(buf)); + msgpack_zone z; + msgpack_zone_init(&z, 2048); + msgpack_object obj; + msgpack_unpack_return ret = + msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); + EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); + EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); + EXPECT_EQ(size, obj.via.ext.size); + EXPECT_EQ(80, obj.via.ext.type); + EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); + msgpack_zone_destroy(&z); + msgpack_sbuffer_destroy(&sbuf); +} + +TEST(MSGPACKC, simple_buffer_fixext_4byte_65536) +{ + const size_t size = 65536; + char buf[size]; + for (int i = 0; i != size; ++i) buf[i] = i; + + msgpack_sbuffer sbuf; + msgpack_sbuffer_init(&sbuf); + msgpack_packer pk; + msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); + + msgpack_pack_ext(&pk, size, 81); + msgpack_pack_ext_body(&pk, buf, sizeof(buf)); + msgpack_zone z; + msgpack_zone_init(&z, 2048); + msgpack_object obj; + msgpack_unpack_return ret = + msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); + EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); + EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); + EXPECT_EQ(size, obj.via.ext.size); + EXPECT_EQ(81, obj.via.ext.type); + EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); + msgpack_zone_destroy(&z); + msgpack_sbuffer_destroy(&sbuf); +} + TEST(MSGPACKC, simple_buffer_array) { unsigned int array_size = 5; @@ -417,20 +671,20 @@ TEST(MSGPACKC, simple_buffer_map) msgpack_sbuffer_destroy(&sbuf); } -TEST(MSGPACKC, simple_buffer_raw) +TEST(MSGPACKC, simple_buffer_str) { - unsigned int raw_size = 7; + unsigned int str_size = 7; msgpack_sbuffer sbuf; msgpack_sbuffer_init(&sbuf); msgpack_packer pk; msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - msgpack_pack_raw(&pk, raw_size); - msgpack_pack_raw_body(&pk, "fr", 2); - msgpack_pack_raw_body(&pk, "syuki", 5); + msgpack_pack_str(&pk, str_size); + msgpack_pack_str_body(&pk, "fr", 2); + msgpack_pack_str_body(&pk, "syuki", 5); // invalid data - msgpack_pack_raw_body(&pk, "", 0); - msgpack_pack_raw_body(&pk, "kzk", 0); + msgpack_pack_str_body(&pk, "", 0); + msgpack_pack_str_body(&pk, "kzk", 0); msgpack_zone z; msgpack_zone_init(&z, 2048); @@ -438,17 +692,37 @@ TEST(MSGPACKC, simple_buffer_raw) msgpack_unpack_return ret; ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_RAW, obj.type); - EXPECT_EQ(raw_size, obj.via.raw.size); - EXPECT_EQ(0, memcmp("frsyuki", obj.via.raw.ptr, raw_size)); + EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); + EXPECT_EQ(str_size, obj.via.str.size); + EXPECT_EQ(0, memcmp("frsyuki", obj.via.str.ptr, str_size)); msgpack_zone_destroy(&z); msgpack_sbuffer_destroy(&sbuf); } +TEST(MSGPACKC, unpack_fixstr) +{ + size_t str_size = 7; + const char buf[] = { + (char)0xa7, 'f', 'r', 's', 'y', 'u', 'k', 'i' + }; + + msgpack_zone z; + msgpack_zone_init(&z, 2048); + msgpack_object obj; + msgpack_unpack_return ret; + ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); + EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); + EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); + EXPECT_EQ(str_size, obj.via.str.size); + EXPECT_EQ(0, memcmp("frsyuki", obj.via.str.ptr, str_size)); + + msgpack_zone_destroy(&z); +} + TEST(MSGPACKC, unpack_str8) { - size_t raw_size = 7; + size_t str_size = 7; const char buf[] = { (char)0xd9, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' }; @@ -459,16 +733,56 @@ TEST(MSGPACKC, unpack_str8) msgpack_unpack_return ret; ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_RAW, obj.type); - EXPECT_EQ(raw_size, obj.via.raw.size); - EXPECT_EQ(0, memcmp("frsyuki", obj.via.raw.ptr, raw_size)); + EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); + EXPECT_EQ(str_size, obj.via.str.size); + EXPECT_EQ(0, memcmp("frsyuki", obj.via.str.ptr, str_size)); + + msgpack_zone_destroy(&z); +} + +TEST(MSGPACKC, unpack_str16) +{ + size_t str_size = 7; + const char buf[] = { + (char)0xda, 0, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' + }; + + msgpack_zone z; + msgpack_zone_init(&z, 2048); + msgpack_object obj; + msgpack_unpack_return ret; + ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); + EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); + EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); + EXPECT_EQ(str_size, obj.via.str.size); + EXPECT_EQ(0, memcmp("frsyuki", obj.via.str.ptr, str_size)); + + msgpack_zone_destroy(&z); +} + +TEST(MSGPACKC, unpack_str32) +{ + size_t str_size = 7; + const char buf[] = { + (char)0xdb, 0, 0, 0, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' + }; + + msgpack_zone z; + msgpack_zone_init(&z, 2048); + msgpack_object obj; + msgpack_unpack_return ret; + ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); + EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); + EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); + EXPECT_EQ(str_size, obj.via.str.size); + EXPECT_EQ(0, memcmp("frsyuki", obj.via.str.ptr, str_size)); msgpack_zone_destroy(&z); } TEST(MSGPACKC, unpack_bin8) { - size_t raw_size = 7; + size_t bin_size = 7; const char buf[] = { (char)0xc4, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' }; @@ -479,16 +793,16 @@ TEST(MSGPACKC, unpack_bin8) msgpack_unpack_return ret; ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_RAW, obj.type); - EXPECT_EQ(raw_size, obj.via.raw.size); - EXPECT_EQ(0, memcmp("frsyuki", obj.via.raw.ptr, raw_size)); + EXPECT_EQ(MSGPACK_OBJECT_BIN, obj.type); + EXPECT_EQ(bin_size, obj.via.bin.size); + EXPECT_EQ(0, memcmp("frsyuki", obj.via.bin.ptr, bin_size)); msgpack_zone_destroy(&z); } TEST(MSGPACKC, unpack_bin16) { - size_t raw_size = 7; + size_t bin_size = 7; const char buf[] = { (char)0xc5, 0, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' }; @@ -499,16 +813,16 @@ TEST(MSGPACKC, unpack_bin16) msgpack_unpack_return ret; ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_RAW, obj.type); - EXPECT_EQ(raw_size, obj.via.raw.size); - EXPECT_EQ(0, memcmp("frsyuki", obj.via.raw.ptr, raw_size)); + EXPECT_EQ(MSGPACK_OBJECT_BIN, obj.type); + EXPECT_EQ(bin_size, obj.via.bin.size); + EXPECT_EQ(0, memcmp("frsyuki", obj.via.bin.ptr, bin_size)); msgpack_zone_destroy(&z); } TEST(MSGPACKC, unpack_bin32) { - size_t raw_size = 7; + size_t bin_size = 7; const char buf[] = { (char)0xc6, 0, 0, 0, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' }; @@ -519,9 +833,9 @@ TEST(MSGPACKC, unpack_bin32) msgpack_unpack_return ret; ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_RAW, obj.type); - EXPECT_EQ(raw_size, obj.via.raw.size); - EXPECT_EQ(0, memcmp("frsyuki", obj.via.raw.ptr, raw_size)); + EXPECT_EQ(MSGPACK_OBJECT_BIN, obj.type); + EXPECT_EQ(bin_size, obj.via.bin.size); + EXPECT_EQ(0, memcmp("frsyuki", obj.via.bin.ptr, bin_size)); msgpack_zone_destroy(&z); } diff --git a/test/msgpack_container.cpp b/test/msgpack_container.cpp new file mode 100644 index 00000000..febef394 --- /dev/null +++ b/test/msgpack_container.cpp @@ -0,0 +1,591 @@ +#include "msgpack.hpp" + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +using namespace std; + +const unsigned int kLoop = 1000; +const unsigned int kElements = 100; +const double kEPS = 1e-10; + +TEST(MSGPACK_STL, simple_buffer_vector) +{ + for (unsigned int k = 0; k < kLoop; k++) { + vector val1; + for (unsigned int i = 0; i < kElements; i++) + val1.push_back(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(ret.get().type, msgpack::type::ARRAY); + vector val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + } +} + +TEST(MSGPACK_STL, simple_buffer_vector_char) +{ + for (unsigned int k = 0; k < kLoop; k++) { + vector val1; + for (unsigned int i = 0; i < kElements; i++) + val1.push_back(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(ret.get().type, msgpack::type::BIN); + vector val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + } +} + +TEST(MSGPACK_STL, simple_buffer_map) +{ + for (unsigned int k = 0; k < kLoop; k++) { + map val1; + for (unsigned int i = 0; i < kElements; i++) + val1[rand()] = rand(); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + map val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + } +} + +TEST(MSGPACK_STL, simple_buffer_deque) +{ + for (unsigned int k = 0; k < kLoop; k++) { + deque val1; + for (unsigned int i = 0; i < kElements; i++) + val1.push_back(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + deque val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + } +} + +TEST(MSGPACK_STL, simple_buffer_list) +{ + for (unsigned int k = 0; k < kLoop; k++) { + list val1; + for (unsigned int i = 0; i < kElements; i++) + val1.push_back(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + list val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + } +} + +TEST(MSGPACK_STL, simple_buffer_set) +{ + for (unsigned int k = 0; k < kLoop; k++) { + set val1; + for (unsigned int i = 0; i < kElements; i++) + val1.insert(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + set val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + } +} + +TEST(MSGPACK_STL, simple_buffer_pair) +{ + for (unsigned int k = 0; k < kLoop; k++) { + pair val1 = make_pair(rand(), rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + pair val2 = ret.get().as >(); + EXPECT_EQ(val1.first, val2.first); + EXPECT_EQ(val1.second, val2.second); + } +} + +TEST(MSGPACK_STL, simple_buffer_multimap) +{ + for (unsigned int k = 0; k < kLoop; k++) { + multimap val1; + for (unsigned int i = 0; i < kElements; i++) { + int i1 = rand(); + val1.insert(make_pair(i1, rand())); + val1.insert(make_pair(i1, rand())); + } + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + multimap val2 = ret.get().as >(); + + vector > v1, v2; + multimap::const_iterator it; + for (it = val1.begin(); it != val1.end(); ++it) + v1.push_back(make_pair(it->first, it->second)); + for (it = val2.begin(); it != val2.end(); ++it) + v2.push_back(make_pair(it->first, it->second)); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_EQ(v1.size(), v2.size()); + sort(v1.begin(), v1.end()); + sort(v2.begin(), v2.end()); + EXPECT_TRUE(v1 == v2); + } +} + +TEST(MSGPACK_STL, simple_buffer_multiset) +{ + for (unsigned int k = 0; k < kLoop; k++) { + multiset val1; + for (unsigned int i = 0; i < kElements; i++) + val1.insert(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + multiset val2 = ret.get().as >(); + + vector v1, v2; + multiset::const_iterator it; + for (it = val1.begin(); it != val1.end(); ++it) + v1.push_back(*it); + for (it = val2.begin(); it != val2.end(); ++it) + v2.push_back(*it); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_EQ(v1.size(), v2.size()); + sort(v1.begin(), v1.end()); + sort(v2.begin(), v2.end()); + EXPECT_TRUE(v1 == v2); + } +} + +TEST(MSGPACK_TUPLE, simple_tuple) +{ + msgpack::sbuffer sbuf; + msgpack::type::tuple val1(true, "kzk", 12.3); + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + msgpack::type::tuple val2 + = ret.get().as >(); + EXPECT_EQ(ret.get().via.array.size, 3); + EXPECT_EQ(val1.get<0>(), val2.get<0>()); + EXPECT_EQ(val1.get<1>(), val2.get<1>()); + EXPECT_EQ(val1.get<2>(), val2.get<2>()); +} + +TEST(MSGPACK_TUPLE, simple_tuple_empty) +{ + msgpack::sbuffer sbuf; + msgpack::type::tuple<> val1; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + ret.get().as >(); + EXPECT_EQ(ret.get().via.array.size, 0); +} + + +// TR1 + +#ifdef MSGPACK_HAS_STD_TR1_UNOURDERED_MAP +#include +#include "msgpack/adaptor/tr1/unordered_map.hpp" +TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map) +{ + for (unsigned int k = 0; k < kLoop; k++) { + tr1::unordered_map val1; + for (unsigned int i = 0; i < kElements; i++) + val1[rand()] = rand(); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + tr1::unordered_map val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + tr1::unordered_map::const_iterator it; + for (it = val1.begin(); it != val1.end(); ++it) { + EXPECT_TRUE(val2.find(it->first) != val2.end()); + EXPECT_EQ(it->second, val2.find(it->first)->second); + } + } +} + +TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap) +{ + for (unsigned int k = 0; k < kLoop; k++) { + tr1::unordered_multimap val1; + for (unsigned int i = 0; i < kElements; i++) { + int i1 = rand(); + val1.insert(make_pair(i1, rand())); + val1.insert(make_pair(i1, rand())); + } + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + tr1::unordered_multimap val2 = ret.get().as >(); + + vector > v1, v2; + tr1::unordered_multimap::const_iterator it; + for (it = val1.begin(); it != val1.end(); ++it) + v1.push_back(make_pair(it->first, it->second)); + for (it = val2.begin(); it != val2.end(); ++it) + v2.push_back(make_pair(it->first, it->second)); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_EQ(v1.size(), v2.size()); + sort(v1.begin(), v1.end()); + sort(v2.begin(), v2.end()); + EXPECT_TRUE(v1 == v2); + } +} +#endif + +#ifdef MSGPACK_HAS_STD_TR1_UNOURDERED_SET +#include +#include "msgpack/adaptor/tr1/unordered_set.hpp" +TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set) +{ + for (unsigned int k = 0; k < kLoop; k++) { + tr1::unordered_set val1; + for (unsigned int i = 0; i < kElements; i++) + val1.insert(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + tr1::unordered_set val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + tr1::unordered_set::const_iterator it; + for (it = val1.begin(); it != val1.end(); ++it) + EXPECT_TRUE(val2.find(*it) != val2.end()); + } +} + +TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset) +{ + for (unsigned int k = 0; k < kLoop; k++) { + tr1::unordered_multiset val1; + for (unsigned int i = 0; i < kElements; i++) + val1.insert(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + tr1::unordered_multiset val2 = ret.get().as >(); + + vector v1, v2; + tr1::unordered_multiset::const_iterator it; + for (it = val1.begin(); it != val1.end(); ++it) + v1.push_back(*it); + for (it = val2.begin(); it != val2.end(); ++it) + v2.push_back(*it); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_EQ(v1.size(), v2.size()); + sort(v1.begin(), v1.end()); + sort(v2.begin(), v2.end()); + EXPECT_TRUE(v1 == v2); + } +} +#endif + +#ifdef MSGPACK_HAS_STD_UNOURDERED_MAP +#include +#include "msgpack/adaptor/tr1/unordered_map.hpp" +TEST(MSGPACK_TR1, simple_buffer_unordered_map) +{ + for (unsigned int k = 0; k < kLoop; k++) { + unordered_map val1; + for (unsigned int i = 0; i < kElements; i++) + val1[rand()] = rand(); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + unordered_map val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + unordered_map::const_iterator it; + for (it = val1.begin(); it != val1.end(); ++it) { + EXPECT_TRUE(val2.find(it->first) != val2.end()); + EXPECT_EQ(it->second, val2.find(it->first)->second); + } + } +} + +TEST(MSGPACK_TR1, simple_buffer_unordered_multimap) +{ + for (unsigned int k = 0; k < kLoop; k++) { + unordered_multimap val1; + for (unsigned int i = 0; i < kElements; i++) { + int i1 = rand(); + val1.insert(make_pair(i1, rand())); + val1.insert(make_pair(i1, rand())); + } + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + unordered_multimap val2 = ret.get().as >(); + + vector > v1, v2; + unordered_multimap::const_iterator it; + for (it = val1.begin(); it != val1.end(); ++it) + v1.push_back(make_pair(it->first, it->second)); + for (it = val2.begin(); it != val2.end(); ++it) + v2.push_back(make_pair(it->first, it->second)); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_EQ(v1.size(), v2.size()); + sort(v1.begin(), v1.end()); + sort(v2.begin(), v2.end()); + EXPECT_TRUE(v1 == v2); + } +} +#endif + +#ifdef MSGPACK_HAS_STD_UNOURDERED_SET +#include +#include "msgpack/adaptor/tr1/unordered_set.hpp" +TEST(MSGPACK_TR1, simple_buffer_unordered_set) +{ + for (unsigned int k = 0; k < kLoop; k++) { + unordered_set val1; + for (unsigned int i = 0; i < kElements; i++) + val1.insert(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + unordered_set val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + unordered_set::const_iterator it; + for (it = val1.begin(); it != val1.end(); ++it) + EXPECT_TRUE(val2.find(*it) != val2.end()); + } +} + +TEST(MSGPACK_TR1, simple_buffer_unordered_multiset) +{ + for (unsigned int k = 0; k < kLoop; k++) { + unordered_multiset val1; + for (unsigned int i = 0; i < kElements; i++) + val1.insert(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + unordered_multiset val2 = ret.get().as >(); + + vector v1, v2; + unordered_multiset::const_iterator it; + for (it = val1.begin(); it != val1.end(); ++it) + v1.push_back(*it); + for (it = val2.begin(); it != val2.end(); ++it) + v2.push_back(*it); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_EQ(v1.size(), v2.size()); + sort(v1.begin(), v1.end()); + sort(v2.begin(), v2.end()); + EXPECT_TRUE(v1 == v2); + } +} +#endif + + +// User-Defined Structures + +class TestClass +{ +public: + TestClass() : i(0), s("kzk") {} + int i; + string s; + MSGPACK_DEFINE(i, s); +}; + +TEST(MSGPACK_USER_DEFINED, simple_buffer_class) +{ + for (unsigned int k = 0; k < kLoop; k++) { + TestClass val1; + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + TestClass val2 = ret.get().as(); + EXPECT_EQ(val1.i, val2.i); + EXPECT_EQ(val1.s, val2.s); + } +} + +class TestClass2 +{ +public: + TestClass2() : i(0), s("kzk") { + for (unsigned int i = 0; i < kElements; i++) + v.push_back(rand()); + } + int i; + string s; + vector v; + MSGPACK_DEFINE(i, s, v); +}; + +TEST(MSGPACK_USER_DEFINED, simple_buffer_class_old_to_new) +{ + for (unsigned int k = 0; k < kLoop; k++) { + TestClass val1; + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + TestClass2 val2 = ret.get().as(); + EXPECT_EQ(val1.i, val2.i); + EXPECT_EQ(val1.s, val2.s); + EXPECT_FALSE(val2.s.empty()); + } +} + +TEST(MSGPACK_USER_DEFINED, simple_buffer_class_new_to_old) +{ + for (unsigned int k = 0; k < kLoop; k++) { + TestClass2 val1; + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + TestClass val2 = ret.get().as(); + EXPECT_EQ(val1.i, val2.i); + EXPECT_EQ(val1.s, val2.s); + EXPECT_FALSE(val2.s.empty()); + } +} + +class TestEnumMemberClass +{ +public: + TestEnumMemberClass() + : t1(STATE_A), t2(STATE_B), t3(STATE_C) {} + + enum TestEnumType { + STATE_INVALID = 0, + STATE_A = 1, + STATE_B = 2, + STATE_C = 3 + }; + TestEnumType t1; + TestEnumType t2; + TestEnumType t3; + + MSGPACK_DEFINE(t1, t2, t3); +}; + +MSGPACK_ADD_ENUM(TestEnumMemberClass::TestEnumType); + +TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_member) +{ + TestEnumMemberClass val1; + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + TestEnumMemberClass val2 = ret.get().as(); + EXPECT_EQ(val1.t1, val2.t1); + EXPECT_EQ(val1.t2, val2.t2); + EXPECT_EQ(val1.t3, val2.t3); +} + +class TestUnionMemberClass +{ +public: + TestUnionMemberClass() {} + TestUnionMemberClass(double f) { + is_double = true; + value.f = f; + } + TestUnionMemberClass(int i) { + is_double = false; + value.i = i; + } + + union { + double f; + int i; + } value; + bool is_double; + + template + void msgpack_pack(Packer& pk) const + { + if (is_double) + pk.pack(msgpack::type::tuple(true, value.f)); + else + pk.pack(msgpack::type::tuple(false, value.i)); + } + + void msgpack_unpack(msgpack::object o) + { + msgpack::type::tuple tuple; + o.convert(&tuple); + + is_double = tuple.get<0>(); + if (is_double) + tuple.get<1>().convert(&value.f); + else + tuple.get<1>().convert(&value.i); + } +}; + +TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) +{ + { + // double + TestUnionMemberClass val1(1.0); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + TestUnionMemberClass val2 = ret.get().as(); + EXPECT_EQ(val1.is_double, val2.is_double); + EXPECT_TRUE(fabs(val1.value.f - val2.value.f) < kEPS); + } + { + // int + TestUnionMemberClass val1(1); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + TestUnionMemberClass val2 = ret.get().as(); + EXPECT_EQ(val1.is_double, val2.is_double); + EXPECT_EQ(val1.value.i, 1); + EXPECT_EQ(val1.value.i, val2.value.i); + } +} diff --git a/test/msgpack_cpp11.cpp b/test/msgpack_cpp11.cpp new file mode 100644 index 00000000..2d48043e --- /dev/null +++ b/test/msgpack_cpp11.cpp @@ -0,0 +1,124 @@ +#include "msgpack.hpp" + +#include + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +using namespace std; + +const unsigned int kLoop = 10000; +const unsigned int kElements = 100; + +#if !defined(MSGPACK_USE_CPP03) + +// C++11 + +TEST(MSGPACK_CPP11, simple_tuple) +{ + msgpack::sbuffer sbuf; + std::tuple val1(true, "kzk", 12.3); + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + std::tuple val2 = ret.get().as >(); + EXPECT_EQ(val1, val2); +} + +TEST(MSGPACK_CPP11, simple_tuple_empty) +{ + msgpack::sbuffer sbuf; + std::tuple<> val1; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + std::tuple<> val2 = ret.get().as >(); + EXPECT_EQ(val1, val2); +} + +TEST(MSGPACK_CPP11, simple_array) +{ + for (unsigned int k = 0; k < kLoop; k++) { + array val1; + for (unsigned int i = 0; i < kElements; i++) + val1[i] = rand(); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(ret.get().type, msgpack::type::ARRAY); + array val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + } +} + +TEST(MSGPACK_CPP11, simple_buffer_array_char) +{ + for (unsigned int k = 0; k < kLoop; k++) { + array val1; + for (unsigned int i = 0; i < kElements; i++) + val1[i] = rand(); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(ret.get().type, msgpack::type::BIN); + array val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + } +} + +TEST(MSGPACK_STL, simple_buffer_forward_list) +{ + for (unsigned int k = 0; k < kLoop; k++) { + forward_list val1; + for (unsigned int i = 0; i < kElements; i++) + val1.push_front(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + forward_list val2 = ret.get().as >(); + EXPECT_EQ(val1, val2); + } +} + + +class TestEnumClassMemberClass +{ +public: + TestEnumClassMemberClass() + : t1(TestEnumClassType::STATE_A), t2(TestEnumClassType::STATE_B), t3(TestEnumClassType::STATE_C) {} + + enum class TestEnumClassType:long { + STATE_INVALID = 0, + STATE_A = 1, + STATE_B = 2, + STATE_C = 3 + }; + TestEnumClassType t1; + TestEnumClassType t2; + TestEnumClassType t3; + + MSGPACK_DEFINE(t1, t2, t3); +}; + +MSGPACK_ADD_ENUM(TestEnumClassMemberClass::TestEnumClassType); + +TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_class_member) +{ + TestEnumClassMemberClass val1; + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + TestEnumClassMemberClass val2 = ret.get().as(); + EXPECT_EQ(val1.t1, val2.t1); + EXPECT_EQ(val1.t2, val2.t2); + EXPECT_EQ(val1.t3, val2.t3); +} + +#endif // !defined(MSGPACK_USE_CPP03) diff --git a/test/msgpack_stream.cpp b/test/msgpack_stream.cpp new file mode 100644 index 00000000..a317cca2 --- /dev/null +++ b/test/msgpack_stream.cpp @@ -0,0 +1,151 @@ +#include "msgpack.hpp" + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +using namespace std; + +const unsigned int kLoop = 1000; + + +#define GEN_TEST_STREAM(test_type) \ + for (unsigned int k = 0; k < kLoop; k++) { \ + msgpack::sbuffer sbuf; \ + msgpack::packer pk(sbuf); \ + typedef std::vector vec_type; \ + vec_type vec; \ + for(unsigned int i = 0; i < rand() % kLoop; ++i) { \ + vec_type::value_type r = rand(); \ + vec.push_back(r); \ + pk.pack(r); \ + } \ + msgpack::unpacker pac; \ + vec_type::const_iterator it = vec.begin(); \ + const char *p = sbuf.data(); \ + const char * const pend = p + sbuf.size(); \ + while (p < pend) { \ + const size_t sz = std::min(pend - p, rand() % 128); \ + pac.reserve_buffer(sz); \ + memcpy(pac.buffer(), p, sz); \ + pac.buffer_consumed(sz); \ + msgpack::unpacked result; \ + while (pac.next(result)) { \ + if (it == vec.end()) goto out; \ + msgpack::object obj = result.get(); \ + vec_type::value_type val; \ + obj.convert(&val); \ + EXPECT_EQ(*it, val); \ + ++it; \ + } \ + p += sz; \ + } \ + out: \ + ; \ + } + +TEST(MSGPACK, stream_char) +{ + GEN_TEST_STREAM(char); +} + +TEST(MSGPACK, stream_signed_char) +{ + GEN_TEST_STREAM(signed char); +} + +TEST(MSGPACK, stream_unsigned_char) +{ + GEN_TEST_STREAM(unsigned char); +} + +TEST(MSGPACK, stream_short) +{ + GEN_TEST_STREAM(short); +} + +TEST(MSGPACK, stream_int) +{ + GEN_TEST_STREAM(int); +} + +TEST(MSGPACK, stream_long) +{ + GEN_TEST_STREAM(long); +} + +TEST(MSGPACK, stream_long_long) +{ + GEN_TEST_STREAM(long long); +} + +TEST(MSGPACK, stream_unsigned_short) +{ + GEN_TEST_STREAM(unsigned short); +} + +TEST(MSGPACK, stream_unsigned_int) +{ + GEN_TEST_STREAM(unsigned int); +} + +TEST(MSGPACK, stream_unsigned_long) +{ + GEN_TEST_STREAM(unsigned long); +} + +TEST(MSGPACK, stream_unsigned_long_long) +{ + GEN_TEST_STREAM(unsigned long long); +} + +TEST(MSGPACK, stream_uint8) +{ + GEN_TEST_STREAM(uint8_t); +} + +TEST(MSGPACK, stream_uint16) +{ + GEN_TEST_STREAM(uint16_t); +} + +TEST(MSGPACK, stream_uint32) +{ + GEN_TEST_STREAM(uint32_t); +} + +TEST(MSGPACK, stream_uint64) +{ + GEN_TEST_STREAM(uint64_t); +} + +TEST(MSGPACK, stream_int8) +{ + GEN_TEST_STREAM(int8_t); +} + +TEST(MSGPACK, stream_int16) +{ + GEN_TEST_STREAM(int16_t); +} + +TEST(MSGPACK, stream_int32) +{ + GEN_TEST_STREAM(int32_t); +} + +TEST(MSGPACK, stream_int64) +{ + GEN_TEST_STREAM(int64_t); +} diff --git a/test/msgpack_test.cpp b/test/msgpack_test.cpp deleted file mode 100644 index 6917cafb..00000000 --- a/test/msgpack_test.cpp +++ /dev/null @@ -1,1199 +0,0 @@ -#include "msgpack.hpp" - -#include -#include -#include -#include -#include -#include -#include -#include - -#include - -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif - -using namespace std; - -const unsigned int kLoop = 10000; -const unsigned int kElements = 100; -const double kEPS = 1e-10; - -#define GEN_TEST(test_type) \ - do { \ - vector v; \ - v.push_back(0); \ - v.push_back(1); \ - v.push_back(2); \ - v.push_back(numeric_limits::min()); \ - v.push_back(numeric_limits::max()); \ - for (unsigned int i = 0; i < kLoop; i++) \ - v.push_back(rand()); \ - for (unsigned int i = 0; i < v.size() ; i++) { \ - msgpack::sbuffer sbuf; \ - test_type val1 = v[i]; \ - msgpack::pack(sbuf, val1); \ - msgpack::zone z; \ - msgpack::object obj; \ - msgpack::unpack_return ret = \ - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); \ - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); \ - test_type val2; \ - obj.convert(&val2); \ - EXPECT_EQ(val1, val2); \ - } \ -} while(0) - -TEST(MSGPACK, simple_buffer_char) -{ - GEN_TEST(char); -} - -TEST(MSGPACK, simple_buffer_signed_char) -{ - GEN_TEST(signed char); -} - -TEST(MSGPACK, simple_buffer_unsigned_char) -{ - GEN_TEST(unsigned char); -} - - -TEST(MSGPACK, simple_buffer_short) -{ - GEN_TEST(short); -} - -TEST(MSGPACK, simple_buffer_int) -{ - GEN_TEST(int); -} - -TEST(MSGPACK, simple_buffer_long) -{ - GEN_TEST(long); -} - -TEST(MSGPACK, simple_buffer_long_long) -{ - GEN_TEST(long long); -} - -TEST(MSGPACK, simple_buffer_unsigned_short) -{ - GEN_TEST(unsigned short); -} - -TEST(MSGPACK, simple_buffer_unsigned_int) -{ - GEN_TEST(unsigned int); -} - -TEST(MSGPACK, simple_buffer_unsigned_long) -{ - GEN_TEST(unsigned long); -} - -TEST(MSGPACK, simple_buffer_unsigned_long_long) -{ - GEN_TEST(unsigned long long); -} - -TEST(MSGPACK, simple_buffer_uint8) -{ - GEN_TEST(uint8_t); -} - -TEST(MSGPACK, simple_buffer_uint16) -{ - GEN_TEST(uint16_t); -} - -TEST(MSGPACK, simple_buffer_uint32) -{ - GEN_TEST(uint32_t); -} - -TEST(MSGPACK, simple_buffer_uint64) -{ - GEN_TEST(uint64_t); -} - -TEST(MSGPACK, simple_buffer_int8) -{ - GEN_TEST(int8_t); -} - -TEST(MSGPACK, simple_buffer_int16) -{ - GEN_TEST(int16_t); -} - -TEST(MSGPACK, simple_buffer_int32) -{ - GEN_TEST(int32_t); -} - -TEST(MSGPACK, simple_buffer_int64) -{ - GEN_TEST(int64_t); -} - -TEST(MSGPACK, simple_buffer_float) -{ - vector v; - v.push_back(0.0); - v.push_back(-0.0); - v.push_back(1.0); - v.push_back(-1.0); - v.push_back(numeric_limits::min()); - v.push_back(numeric_limits::max()); - v.push_back(nanf("tag")); - v.push_back(1.0/0.0); // inf - v.push_back(-(1.0/0.0)); // -inf - for (unsigned int i = 0; i < kLoop; i++) { - v.push_back(drand48()); - v.push_back(-drand48()); - } - for (unsigned int i = 0; i < v.size() ; i++) { - msgpack::sbuffer sbuf; - float val1 = v[i]; - msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - float val2; - obj.convert(&val2); - - if (isnan(val1)) - EXPECT_TRUE(isnan(val2)); - else if (isinf(val1)) - EXPECT_TRUE(isinf(val2)); - else - EXPECT_TRUE(fabs(val2 - val1) <= kEPS); - } -} - -namespace { -template -struct TypePair { - typedef F float_type; - typedef I integer_type; -}; -} // namespace - -template -class IntegerToFloatingPointTest : public testing::Test { -}; -TYPED_TEST_CASE_P(IntegerToFloatingPointTest); - -TYPED_TEST_P(IntegerToFloatingPointTest, simple_buffer) -{ - typedef typename TypeParam::float_type float_type; - typedef typename TypeParam::integer_type integer_type; - vector v; - v.push_back(0); - v.push_back(1); - if (numeric_limits::is_signed) v.push_back(-1); - else v.push_back(2); - for (unsigned int i = 0; i < kLoop; i++) { - v.push_back(rand() % 0x7FFFFF); - } - for (unsigned int i = 0; i < v.size() ; i++) { - msgpack::sbuffer sbuf; - integer_type val1 = v[i]; - msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - float_type val2; - obj.convert(&val2); - EXPECT_TRUE(fabs(val2 - val1) <= kEPS); - } -} - -REGISTER_TYPED_TEST_CASE_P(IntegerToFloatingPointTest, - simple_buffer); - -typedef testing::Types, - TypePair, - TypePair, - TypePair > IntegerToFloatingPointTestTypes; -INSTANTIATE_TYPED_TEST_CASE_P(IntegerToFloatingPointTestInstance, - IntegerToFloatingPointTest, - IntegerToFloatingPointTestTypes); - -TEST(MSGPACK, simple_buffer_double) -{ - vector v; - v.push_back(0.0); - v.push_back(-0.0); - v.push_back(1.0); - v.push_back(-1.0); - v.push_back(numeric_limits::min()); - v.push_back(numeric_limits::max()); - v.push_back(nanf("tag")); - v.push_back(1.0/0.0); // inf - v.push_back(-(1.0/0.0)); // -inf - for (unsigned int i = 0; i < kLoop; i++) { - v.push_back(drand48()); - v.push_back(-drand48()); - } - for (unsigned int i = 0; i < v.size() ; i++) { - msgpack::sbuffer sbuf; - double val1 = v[i]; - msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - double val2; - obj.convert(&val2); - - if (isnan(val1)) - EXPECT_TRUE(isnan(val2)); - else if (isinf(val1)) - EXPECT_TRUE(isinf(val2)); - else - EXPECT_TRUE(fabs(val2 - val1) <= kEPS); - } -} - -TEST(MSGPACK, simple_buffer_true) -{ - msgpack::sbuffer sbuf; - bool val1 = true; - msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - bool val2; - obj.convert(&val2); - EXPECT_EQ(val1, val2); -} - -TEST(MSGPACK, simple_buffer_false) -{ - msgpack::sbuffer sbuf; - bool val1 = false; - msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - bool val2; - obj.convert(&val2); - EXPECT_EQ(val1, val2); -} - -//----------------------------------------------------------------------------- - -// STL - -TEST(MSGPACK_STL, simple_buffer_string) -{ - for (unsigned int k = 0; k < kLoop; k++) { - string val1; - for (unsigned int i = 0; i < kElements; i++) - val1 += 'a' + rand() % 26; - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - string val2; - obj.convert(&val2); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_EQ(val1, val2); - } -} - -TEST(MSGPACK_STL, simple_buffer_vector) -{ - for (unsigned int k = 0; k < kLoop; k++) { - vector val1; - for (unsigned int i = 0; i < kElements; i++) - val1.push_back(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - vector val2; - obj.convert(&val2); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); - } -} - -TEST(MSGPACK_STL, simple_buffer_map) -{ - for (unsigned int k = 0; k < kLoop; k++) { - map val1; - for (unsigned int i = 0; i < kElements; i++) - val1[rand()] = rand(); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - map val2; - obj.convert(&val2); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); - } -} - -TEST(MSGPACK_STL, simple_buffer_deque) -{ - for (unsigned int k = 0; k < kLoop; k++) { - deque val1; - for (unsigned int i = 0; i < kElements; i++) - val1.push_back(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - deque val2; - obj.convert(&val2); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); - } -} - -TEST(MSGPACK_STL, simple_buffer_list) -{ - for (unsigned int k = 0; k < kLoop; k++) { - list val1; - for (unsigned int i = 0; i < kElements; i++) - val1.push_back(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - list val2; - obj.convert(&val2); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); - } -} - -TEST(MSGPACK_STL, simple_buffer_set) -{ - for (unsigned int k = 0; k < kLoop; k++) { - set val1; - for (unsigned int i = 0; i < kElements; i++) - val1.insert(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - set val2; - obj.convert(&val2); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); - } -} - -TEST(MSGPACK_STL, simple_buffer_pair) -{ - for (unsigned int k = 0; k < kLoop; k++) { - pair val1 = make_pair(rand(), rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - pair val2; - obj.convert(&val2); - EXPECT_EQ(val1.first, val2.first); - EXPECT_EQ(val1.second, val2.second); - } -} - -TEST(MSGPACK_STL, simple_buffer_multimap) -{ - for (unsigned int k = 0; k < kLoop; k++) { - multimap val1; - for (unsigned int i = 0; i < kElements; i++) { - int i1 = rand(); - val1.insert(make_pair(i1, rand())); - val1.insert(make_pair(i1, rand())); - } - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - multimap val2; - obj.convert(&val2); - - vector > v1, v2; - multimap::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) - v1.push_back(make_pair(it->first, it->second)); - for (it = val2.begin(); it != val2.end(); ++it) - v2.push_back(make_pair(it->first, it->second)); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_EQ(v1.size(), v2.size()); - sort(v1.begin(), v1.end()); - sort(v2.begin(), v2.end()); - EXPECT_TRUE(v1 == v2); - } -} - -TEST(MSGPACK_STL, simple_buffer_multiset) -{ - for (unsigned int k = 0; k < kLoop; k++) { - multiset val1; - for (unsigned int i = 0; i < kElements; i++) - val1.insert(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - multiset val2; - obj.convert(&val2); - - vector v1, v2; - multiset::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) - v1.push_back(*it); - for (it = val2.begin(); it != val2.end(); ++it) - v2.push_back(*it); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_EQ(v1.size(), v2.size()); - sort(v1.begin(), v1.end()); - sort(v2.begin(), v2.end()); - EXPECT_TRUE(v1 == v2); - } -} - -// TR1 - -#ifdef MSGPACK_HAS_STD_TR1_UNOURDERED_MAP -#include -#include "msgpack/type/tr1/unordered_map.hpp" -TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map) -{ - for (unsigned int k = 0; k < kLoop; k++) { - tr1::unordered_map val1; - for (unsigned int i = 0; i < kElements; i++) - val1[rand()] = rand(); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - tr1::unordered_map val2; - obj.convert(&val2); - EXPECT_EQ(val1.size(), val2.size()); - tr1::unordered_map::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) { - EXPECT_TRUE(val2.find(it->first) != val2.end()); - EXPECT_EQ(it->second, val2.find(it->first)->second); - } - } -} - -TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap) -{ - for (unsigned int k = 0; k < kLoop; k++) { - tr1::unordered_multimap val1; - for (unsigned int i = 0; i < kElements; i++) { - int i1 = rand(); - val1.insert(make_pair(i1, rand())); - val1.insert(make_pair(i1, rand())); - } - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - tr1::unordered_multimap val2; - obj.convert(&val2); - - vector > v1, v2; - tr1::unordered_multimap::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) - v1.push_back(make_pair(it->first, it->second)); - for (it = val2.begin(); it != val2.end(); ++it) - v2.push_back(make_pair(it->first, it->second)); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_EQ(v1.size(), v2.size()); - sort(v1.begin(), v1.end()); - sort(v2.begin(), v2.end()); - EXPECT_TRUE(v1 == v2); - } -} -#endif - -#ifdef MSGPACK_HAS_STD_TR1_UNOURDERED_SET -#include -#include "msgpack/type/tr1/unordered_set.hpp" -TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set) -{ - for (unsigned int k = 0; k < kLoop; k++) { - tr1::unordered_set val1; - for (unsigned int i = 0; i < kElements; i++) - val1.insert(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - tr1::unordered_set val2; - obj.convert(&val2); - EXPECT_EQ(val1.size(), val2.size()); - tr1::unordered_set::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) - EXPECT_TRUE(val2.find(*it) != val2.end()); - } -} - -TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset) -{ - for (unsigned int k = 0; k < kLoop; k++) { - tr1::unordered_multiset val1; - for (unsigned int i = 0; i < kElements; i++) - val1.insert(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - tr1::unordered_multiset val2; - obj.convert(&val2); - - vector v1, v2; - tr1::unordered_multiset::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) - v1.push_back(*it); - for (it = val2.begin(); it != val2.end(); ++it) - v2.push_back(*it); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_EQ(v1.size(), v2.size()); - sort(v1.begin(), v1.end()); - sort(v2.begin(), v2.end()); - EXPECT_TRUE(v1 == v2); - } -} -#endif - -#ifdef MSGPACK_HAS_STD_UNOURDERED_MAP -#include -#include "msgpack/type/tr1/unordered_map.hpp" -TEST(MSGPACK_TR1, simple_buffer_unordered_map) -{ - for (unsigned int k = 0; k < kLoop; k++) { - unordered_map val1; - for (unsigned int i = 0; i < kElements; i++) - val1[rand()] = rand(); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - unordered_map val2; - obj.convert(&val2); - EXPECT_EQ(val1.size(), val2.size()); - unordered_map::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) { - EXPECT_TRUE(val2.find(it->first) != val2.end()); - EXPECT_EQ(it->second, val2.find(it->first)->second); - } - } -} - -TEST(MSGPACK_TR1, simple_buffer_unordered_multimap) -{ - for (unsigned int k = 0; k < kLoop; k++) { - unordered_multimap val1; - for (unsigned int i = 0; i < kElements; i++) { - int i1 = rand(); - val1.insert(make_pair(i1, rand())); - val1.insert(make_pair(i1, rand())); - } - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - unordered_multimap val2; - obj.convert(&val2); - - vector > v1, v2; - unordered_multimap::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) - v1.push_back(make_pair(it->first, it->second)); - for (it = val2.begin(); it != val2.end(); ++it) - v2.push_back(make_pair(it->first, it->second)); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_EQ(v1.size(), v2.size()); - sort(v1.begin(), v1.end()); - sort(v2.begin(), v2.end()); - EXPECT_TRUE(v1 == v2); - } -} -#endif - -#ifdef MSGPACK_HAS_STD_UNOURDERED_SET -#include -#include "msgpack/type/tr1/unordered_set.hpp" -TEST(MSGPACK_TR1, simple_buffer_unordered_set) -{ - for (unsigned int k = 0; k < kLoop; k++) { - unordered_set val1; - for (unsigned int i = 0; i < kElements; i++) - val1.insert(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - unordered_set val2; - obj.convert(&val2); - EXPECT_EQ(val1.size(), val2.size()); - unordered_set::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) - EXPECT_TRUE(val2.find(*it) != val2.end()); - } -} - -TEST(MSGPACK_TR1, simple_buffer_unordered_multiset) -{ - for (unsigned int k = 0; k < kLoop; k++) { - unordered_multiset val1; - for (unsigned int i = 0; i < kElements; i++) - val1.insert(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - unordered_multiset val2; - obj.convert(&val2); - - vector v1, v2; - unordered_multiset::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) - v1.push_back(*it); - for (it = val2.begin(); it != val2.end(); ++it) - v2.push_back(*it); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_EQ(v1.size(), v2.size()); - sort(v1.begin(), v1.end()); - sort(v2.begin(), v2.end()); - EXPECT_TRUE(v1 == v2); - } -} -#endif - -// User-Defined Structures - -class TestClass -{ -public: - TestClass() : i(0), s("kzk") {} - int i; - string s; - MSGPACK_DEFINE(i, s); -}; - -TEST(MSGPACK_USER_DEFINED, simple_buffer_class) -{ - for (unsigned int k = 0; k < kLoop; k++) { - TestClass val1; - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - TestClass val2; - val2.i = -1; - val2.s = ""; - obj.convert(&val2); - EXPECT_EQ(val1.i, val2.i); - EXPECT_EQ(val1.s, val2.s); - } -} - -class TestClass2 -{ -public: - TestClass2() : i(0), s("kzk") { - for (unsigned int i = 0; i < kElements; i++) - v.push_back(rand()); - } - int i; - string s; - vector v; - MSGPACK_DEFINE(i, s, v); -}; - -TEST(MSGPACK_USER_DEFINED, simple_buffer_class_old_to_new) -{ - for (unsigned int k = 0; k < kLoop; k++) { - TestClass val1; - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - TestClass2 val2; - val2.i = -1; - val2.s = ""; - val2.v = vector(); - obj.convert(&val2); - EXPECT_EQ(val1.i, val2.i); - EXPECT_EQ(val1.s, val2.s); - EXPECT_FALSE(val2.s.empty()); - } -} - -TEST(MSGPACK_USER_DEFINED, simple_buffer_class_new_to_old) -{ - for (unsigned int k = 0; k < kLoop; k++) { - TestClass2 val1; - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - TestClass val2; - val2.i = -1; - val2.s = ""; - obj.convert(&val2); - EXPECT_EQ(val1.i, val2.i); - EXPECT_EQ(val1.s, val2.s); - EXPECT_FALSE(val2.s.empty()); - } -} - -class TestEnumMemberClass -{ -public: - TestEnumMemberClass() - : t1(STATE_A), t2(STATE_B), t3(STATE_C) {} - - enum TestEnumType { - STATE_INVALID = 0, - STATE_A = 1, - STATE_B = 2, - STATE_C = 3 - }; - TestEnumType t1; - TestEnumType t2; - TestEnumType t3; - - MSGPACK_DEFINE(t1, t2, t3); -}; - -MSGPACK_ADD_ENUM(TestEnumMemberClass::TestEnumType); - -TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_member) -{ - TestEnumMemberClass val1; - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - TestEnumMemberClass val2; - val2.t1 = TestEnumMemberClass::STATE_INVALID; - val2.t2 = TestEnumMemberClass::STATE_INVALID; - val2.t3 = TestEnumMemberClass::STATE_INVALID; - obj.convert(&val2); - EXPECT_EQ(val1.t1, val2.t1); - EXPECT_EQ(val1.t2, val2.t2); - EXPECT_EQ(val1.t3, val2.t3); -} - -class TestUnionMemberClass -{ -public: - TestUnionMemberClass() {} - TestUnionMemberClass(double f) { - is_double = true; - value.f = f; - } - TestUnionMemberClass(int i) { - is_double = false; - value.i = i; - } - - union { - double f; - int i; - } value; - bool is_double; - - template - void msgpack_pack(Packer& pk) const - { - if (is_double) - pk.pack(msgpack::type::tuple(true, value.f)); - else - pk.pack(msgpack::type::tuple(false, value.i)); - } - - void msgpack_unpack(msgpack::object o) - { - msgpack::type::tuple tuple; - o.convert(&tuple); - - is_double = tuple.get<0>(); - if (is_double) - tuple.get<1>().convert(&value.f); - else - tuple.get<1>().convert(&value.i); - } -}; - -TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) -{ - { - // double - TestUnionMemberClass val1(1.0); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - TestUnionMemberClass val2; - obj.convert(&val2); - EXPECT_EQ(val1.is_double, val2.is_double); - EXPECT_TRUE(fabs(val1.value.f - val2.value.f) < kEPS); - } - { - // int - TestUnionMemberClass val1(1); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - TestUnionMemberClass val2; - obj.convert(&val2); - EXPECT_EQ(val1.is_double, val2.is_double); - EXPECT_EQ(val1.value.i, 1); - EXPECT_EQ(val1.value.i, val2.value.i); - } -} - -//----------------------------------------------------------------------------- - -#define GEN_TEST_VREF(test_type) \ - do { \ - vector v; \ - v.push_back(0); \ - for (unsigned int i = 0; i < v.size(); i++) { \ - test_type val1 = v[i]; \ - msgpack::vrefbuffer vbuf; \ - msgpack::pack(vbuf, val1); \ - msgpack::sbuffer sbuf; \ - const struct iovec* cur = vbuf.vector(); \ - const struct iovec* end = cur + vbuf.vector_size(); \ - for(; cur != end; ++cur) \ - sbuf.write((const char*)cur->iov_base, cur->iov_len); \ - msgpack::zone z; \ - msgpack::object obj; \ - msgpack::unpack_return ret = \ - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); \ - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); \ - test_type val2; \ - obj.convert(&val2); \ - EXPECT_EQ(val1, val2); \ - } \ - } while(0); - -TEST(MSGPACK, vrefbuffer_char) -{ - GEN_TEST_VREF(char); -} - -TEST(MSGPACK, vrefbuffer_signed_char) -{ - GEN_TEST_VREF(signed char); -} - -TEST(MSGPACK, vrefbuffer_unsigned_char) -{ - GEN_TEST_VREF(unsigned char); -} - -TEST(MSGPACK, vrefbuffer_short) -{ - GEN_TEST_VREF(short); -} - -TEST(MSGPACK, vrefbuffer_int) -{ - GEN_TEST_VREF(int); -} - -TEST(MSGPACK, vrefbuffer_long) -{ - GEN_TEST_VREF(long); -} - -TEST(MSGPACK, vrefbuffer_long_long) -{ - GEN_TEST_VREF(long long); -} - -TEST(MSGPACK, vrefbuffer_unsigned_short) -{ - GEN_TEST_VREF(unsigned short); -} - -TEST(MSGPACK, vrefbuffer_unsigned_int) -{ - GEN_TEST_VREF(unsigned int); -} - -TEST(MSGPACK, vrefbuffer_unsigned_long) -{ - GEN_TEST_VREF(unsigned long); -} - -TEST(MSGPACK, vrefbuffer_unsigned_long_long) -{ - GEN_TEST_VREF(unsigned long long); -} - -TEST(MSGPACK, vrefbuffer_uint8) -{ - GEN_TEST_VREF(uint8_t); -} - -TEST(MSGPACK, vrefbuffer_uint16) -{ - GEN_TEST_VREF(uint16_t); -} - -TEST(MSGPACK, vrefbuffer_uint32) -{ - GEN_TEST_VREF(uint32_t); -} - -TEST(MSGPACK, vrefbuffer_uint64) -{ - GEN_TEST_VREF(uint64_t); -} - -TEST(MSGPACK, vrefbuffer_int8) -{ - GEN_TEST_VREF(int8_t); -} - -TEST(MSGPACK, vrefbuffer_int16) -{ - GEN_TEST_VREF(int16_t); -} - -TEST(MSGPACK, vrefbuffer_int32) -{ - GEN_TEST_VREF(int32_t); -} - -TEST(MSGPACK, vrefbuffer_int64) -{ - GEN_TEST_VREF(int64_t); -} - -//----------------------------------------------------------------------------- - -#define GEN_TEST_STREAM(test_type) \ - for (unsigned int k = 0; k < kLoop; k++) { \ - msgpack::sbuffer sbuf; \ - msgpack::packer pk(sbuf); \ - typedef std::vector vec_type; \ - vec_type vec; \ - for(unsigned int i = 0; i < rand() % kLoop; ++i) { \ - vec_type::value_type r = rand(); \ - vec.push_back(r); \ - pk.pack(r); \ - } \ - msgpack::unpacker pac; \ - vec_type::const_iterator it = vec.begin(); \ - const char *p = sbuf.data(); \ - const char * const pend = p + sbuf.size(); \ - while (p < pend) { \ - const size_t sz = std::min(pend - p, rand() % 128); \ - pac.reserve_buffer(sz); \ - memcpy(pac.buffer(), p, sz); \ - pac.buffer_consumed(sz); \ - while (pac.execute()) { \ - if (it == vec.end()) goto out; \ - msgpack::object obj = pac.data(); \ - msgpack::zone *life = pac.release_zone(); \ - EXPECT_TRUE(life != NULL); \ - pac.reset(); \ - vec_type::value_type val; \ - obj.convert(&val); \ - EXPECT_EQ(*it, val); \ - ++it; \ - msgpack_zone_free(life); \ - } \ - p += sz; \ - } \ - out: \ - ; \ - } - -TEST(MSGPACK, stream_char) -{ - GEN_TEST_STREAM(char); -} - -TEST(MSGPACK, stream_signed_char) -{ - GEN_TEST_STREAM(signed char); -} - -TEST(MSGPACK, stream_unsigned_char) -{ - GEN_TEST_STREAM(unsigned char); -} - -TEST(MSGPACK, stream_short) -{ - GEN_TEST_STREAM(short); -} - -TEST(MSGPACK, stream_int) -{ - GEN_TEST_STREAM(int); -} - -TEST(MSGPACK, stream_long) -{ - GEN_TEST_STREAM(long); -} - -TEST(MSGPACK, stream_long_long) -{ - GEN_TEST_STREAM(long long); -} - -TEST(MSGPACK, stream_unsigned_short) -{ - GEN_TEST_STREAM(unsigned short); -} - -TEST(MSGPACK, stream_unsigned_int) -{ - GEN_TEST_STREAM(unsigned int); -} - -TEST(MSGPACK, stream_unsigned_long) -{ - GEN_TEST_STREAM(unsigned long); -} - -TEST(MSGPACK, stream_unsigned_long_long) -{ - GEN_TEST_STREAM(unsigned long long); -} - -TEST(MSGPACK, stream_uint8) -{ - GEN_TEST_STREAM(uint8_t); -} - -TEST(MSGPACK, stream_uint16) -{ - GEN_TEST_STREAM(uint16_t); -} - -TEST(MSGPACK, stream_uint32) -{ - GEN_TEST_STREAM(uint32_t); -} - -TEST(MSGPACK, stream_uint64) -{ - GEN_TEST_STREAM(uint64_t); -} - -TEST(MSGPACK, stream_int8) -{ - GEN_TEST_STREAM(int8_t); -} - -TEST(MSGPACK, stream_int16) -{ - GEN_TEST_STREAM(int16_t); -} - -TEST(MSGPACK, stream_int32) -{ - GEN_TEST_STREAM(int32_t); -} - -TEST(MSGPACK, stream_int64) -{ - GEN_TEST_STREAM(int64_t); -} diff --git a/test/msgpack_tuple.cpp b/test/msgpack_tuple.cpp new file mode 100644 index 00000000..9779d06a --- /dev/null +++ b/test/msgpack_tuple.cpp @@ -0,0 +1,103 @@ +#include +#include + + +TEST(msgpack_tuple, member_get) +{ + msgpack::type::tuple t1(42, true, "ABC"); + EXPECT_EQ(42, t1.get<0>()); + EXPECT_EQ(true, t1.get<1>()); + EXPECT_EQ("ABC", t1.get<2>()); + t1.get<0>() = 40; + t1.get<1>() = false; + t1.get<2>() = "DEFG"; + EXPECT_EQ(40, t1.get<0>()); + EXPECT_EQ(false, t1.get<1>()); + EXPECT_EQ("DEFG", t1.get<2>()); +} + +TEST(msgpack_tuple, non_member_get) +{ + msgpack::type::tuple t1(42, true, "ABC"); + EXPECT_EQ(42, msgpack::type::get<0>(t1)); + EXPECT_EQ(true, msgpack::type::get<1>(t1)); + EXPECT_EQ("ABC", msgpack::type::get<2>(t1)); + msgpack::type::get<0>(t1) = 40; + msgpack::type::get<1>(t1) = false; + msgpack::type::get<2>(t1) = "DEFG"; + EXPECT_EQ(40, msgpack::type::get<0>(t1)); + EXPECT_EQ(false, msgpack::type::get<1>(t1)); + EXPECT_EQ("DEFG", msgpack::type::get<2>(t1)); +} + +#if __cplusplus >= 201103 +TEST(msgpack_tuple, std_non_member_get) +{ + msgpack::type::tuple t1(42, true, "ABC"); + EXPECT_EQ(42, std::get<0>(t1)); + EXPECT_EQ(true, std::get<1>(t1)); + EXPECT_EQ("ABC", std::get<2>(t1)); + std::get<0>(t1) = 40; + std::get<1>(t1) = false; + std::get<2>(t1) = "DEFG"; + EXPECT_EQ(40, std::get<0>(t1)); + EXPECT_EQ(false, std::get<1>(t1)); + EXPECT_EQ("DEFG", std::get<2>(t1)); +} + +TEST(msgpack_tuple, make_tuple) +{ + msgpack::type::tuple t1 = msgpack::type::make_tuple(42, true, "ABC"); + EXPECT_EQ(42, t1.get<0>()); + EXPECT_EQ(true, t1.get<1>()); + EXPECT_EQ("ABC", t1.get<2>()); + t1.get<0>() = 40; + t1.get<1>() = false; + t1.get<2>() = "DEFG"; + EXPECT_EQ(40, t1.get<0>()); + EXPECT_EQ(false, t1.get<1>()); + EXPECT_EQ("DEFG", t1.get<2>()); +} + +TEST(msgpack_tuple, std_make_tuple) +{ + msgpack::type::tuple t1 = std::make_tuple(42, true, "ABC"); + EXPECT_EQ(42, t1.get<0>()); + EXPECT_EQ(true, t1.get<1>()); + EXPECT_EQ("ABC", t1.get<2>()); +} + +TEST(msgpack_tuple, tie) +{ + int i(43); + bool b(false); + std::string s("DEFG"); + msgpack::type::tie(i, b, s) = msgpack::type::make_tuple(42, true, "ABC"); + EXPECT_EQ(42, i); + EXPECT_EQ(true, b); + EXPECT_EQ("ABC", s); +} + +TEST(msgpack_tuple, tuple_cat) +{ + msgpack::type::tuple t1 = msgpack::type::make_tuple(42); + msgpack::type::tuple t2 = msgpack::type::make_tuple(true, "ABC"); + msgpack::type::tuple t3 = msgpack::type::tuple_cat(t1, std::move(t2)); + EXPECT_EQ(42, t3.get<0>()); + EXPECT_EQ(true, t3.get<1>()); + EXPECT_EQ("ABC", t3.get<2>()); +} + +TEST(msgpack_tuple, swap) +{ + msgpack::type::tuple t1 = msgpack::type::make_tuple(42, true, "ABC"); + msgpack::type::tuple t2 = msgpack::type::make_tuple(40, false, "DEFG"); + msgpack::type::swap(t1, t2); + EXPECT_EQ(42, t2.get<0>()); + EXPECT_EQ(true, t2.get<1>()); + EXPECT_EQ("ABC", t2.get<2>()); + EXPECT_EQ(40, t1.get<0>()); + EXPECT_EQ(false, t1.get<1>()); + EXPECT_EQ("DEFG", t1.get<2>()); +} +#endif diff --git a/test/msgpack_vref.cpp b/test/msgpack_vref.cpp new file mode 100644 index 00000000..845fe7c9 --- /dev/null +++ b/test/msgpack_vref.cpp @@ -0,0 +1,266 @@ +#include "msgpack.hpp" + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +using namespace std; + +#define GEN_TEST_VREF(test_type, vbuf) \ + do { \ + vector v; \ + v.push_back(0); \ + for (unsigned int i = 0; i < v.size(); i++) { \ + test_type val1 = v[i]; \ + msgpack::pack(vbuf, val1); \ + msgpack::sbuffer sbuf; \ + const struct iovec* cur = vbuf.vector(); \ + const struct iovec* end = cur + vbuf.vector_size(); \ + for(; cur != end; ++cur) \ + sbuf.write((const char*)cur->iov_base, cur->iov_len); \ + msgpack::unpacked ret; \ + msgpack::unpack(ret, sbuf.data(), sbuf.size()); \ + test_type val2 = ret.get().as(); \ + EXPECT_EQ(val1, val2); \ + } \ + } while(0); + +TEST(MSGPACK, vrefbuffer_char) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(char, vbuf); +} + +TEST(MSGPACK, vrefbuffer_signed_char) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(signed char, vbuf); +} + +TEST(MSGPACK, vrefbuffer_unsigned_char) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(unsigned char, vbuf); +} + +TEST(MSGPACK, vrefbuffer_short) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(short, vbuf); +} + +TEST(MSGPACK, vrefbuffer_int) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(int, vbuf); +} + +TEST(MSGPACK, vrefbuffer_long) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(long, vbuf); +} + +TEST(MSGPACK, vrefbuffer_long_long) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(long long, vbuf); +} + +TEST(MSGPACK, vrefbuffer_unsigned_short) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(unsigned short, vbuf); +} + +TEST(MSGPACK, vrefbuffer_unsigned_int) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(unsigned int, vbuf); +} + +TEST(MSGPACK, vrefbuffer_unsigned_long) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(unsigned long, vbuf); +} + +TEST(MSGPACK, vrefbuffer_unsigned_long_long) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(unsigned long long, vbuf); +} + +TEST(MSGPACK, vrefbuffer_uint8) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(uint8_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_uint16) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(uint16_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_uint32) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(uint32_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_uint64) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(uint64_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_int8) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(int8_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_int16) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(int16_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_int32) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(int32_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_int64) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(int64_t, vbuf); +} + +// small ref_size and chunk_size +TEST(MSGPACK, vrefbuffer_small_char) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(char, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_signed_char) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(signed char, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_unsigned_char) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(unsigned char, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_short) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(short, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_int) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(int, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_long) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(long, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_long_long) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(long long, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_unsigned_short) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(unsigned short, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_unsigned_int) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(unsigned int, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_unsigned_long) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(unsigned long, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_unsigned_long_long) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(unsigned long long, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_uint8) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(uint8_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_uint16) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(uint16_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_uint32) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(uint32_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_uint64) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(uint64_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_int8) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(int8_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_int16) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(int16_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_int32) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(int32_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_int64) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(int64_t, vbuf); +} diff --git a/test/object.cc b/test/object.cc deleted file mode 100644 index 5d187224..00000000 --- a/test/object.cc +++ /dev/null @@ -1,170 +0,0 @@ -#include -#include -#include -#include -#include - -struct myclass { - myclass() : num(0), str("default") { } - - myclass(int n, const std::string& s) : - num(n), str(s) { } - - ~myclass() { } - - int num; - std::string str; - std::vector vec; - std::map map; - - MSGPACK_DEFINE(num, str, vec, map); - - bool operator==(const myclass& o) const - { - return num == o.num && str == o.str && vec == o.vec && map == o.map; - } -}; - -std::ostream& operator<<(std::ostream& o, const myclass& m) -{ - return o << "myclass("<()); -} - - -TEST(object, cross_zone_copy) -{ - myclass m1(1, "custom"); - m1.vec.push_back(1.0); - m1.vec.push_back(0.1); - m1.map["one"] = "two"; - - msgpack::zone z1; - msgpack::object::with_zone obj1(&z1); - - { - msgpack::zone z2; - msgpack::object::with_zone obj2(&z2); - obj2 << m1; - - obj1 << obj2; - - EXPECT_EQ(obj1.via.array.ptr[2].via.array.ptr[0].via.dec, 1.0); - EXPECT_EQ(obj1.via.array.ptr[3].via.map.ptr[0].val.via.raw.ptr[0], 't'); - EXPECT_NE( - obj1.via.array.ptr[2].via.array.ptr, - obj2.via.array.ptr[2].via.array.ptr); - EXPECT_NE( - obj1.via.array.ptr[3].via.map.ptr[0].val.via.raw.ptr, - obj2.via.array.ptr[3].via.map.ptr[0].val.via.raw.ptr); - } - - EXPECT_EQ(m1, obj1.as()); -} - - -TEST(object, print) -{ - msgpack::object obj; - std::cout << obj << std::endl; -} - - -TEST(object, is_nil) -{ - msgpack::object obj; - EXPECT_TRUE(obj.is_nil()); -} - - -TEST(object, type_error) -{ - msgpack::object obj(1); - EXPECT_THROW(obj.as(), msgpack::type_error); - EXPECT_THROW(obj.as >(), msgpack::type_error); - EXPECT_EQ(1, obj.as()); - EXPECT_EQ(1, obj.as()); - EXPECT_EQ(1u, obj.as()); - EXPECT_EQ(1u, obj.as()); -} - - -TEST(object, equal_primitive) -{ - msgpack::object obj_nil; - EXPECT_EQ(obj_nil, msgpack::object()); - - msgpack::object obj_int(1); - EXPECT_EQ(obj_int, msgpack::object(1)); - EXPECT_EQ(obj_int, 1); - - msgpack::object obj_double(1.2); - EXPECT_EQ(obj_double, msgpack::object(1.2)); - EXPECT_EQ(obj_double, 1.2); - - msgpack::object obj_bool(true); - EXPECT_EQ(obj_bool, msgpack::object(true)); - EXPECT_EQ(obj_bool, true); -} - - -TEST(object, construct_primitive) -{ - msgpack::object obj_nil; - EXPECT_EQ(msgpack::type::NIL, obj_nil.type); - - msgpack::object obj_uint(1); - EXPECT_EQ(msgpack::type::POSITIVE_INTEGER, obj_uint.type); - EXPECT_EQ(1u, obj_uint.via.u64); - - msgpack::object obj_int(-1); - EXPECT_EQ(msgpack::type::NEGATIVE_INTEGER, obj_int.type); - EXPECT_EQ(-1, obj_int.via.i64); - - msgpack::object obj_double(1.2); - EXPECT_EQ(msgpack::type::DOUBLE, obj_double.type); - EXPECT_EQ(1.2, obj_double.via.dec); - - msgpack::object obj_bool(true); - EXPECT_EQ(msgpack::type::BOOLEAN, obj_bool.type); - EXPECT_EQ(true, obj_bool.via.boolean); -} - diff --git a/test/object.cpp b/test/object.cpp new file mode 100644 index 00000000..0cb5c889 --- /dev/null +++ b/test/object.cpp @@ -0,0 +1,125 @@ +#include +#include + +struct myclass { + myclass() : num(0), str("default") { } + + myclass(int num, const std::string& str) : + num(num), str(str) { } + + ~myclass() { } + + int num; + std::string str; + + MSGPACK_DEFINE(num, str); + + bool operator==(const myclass& o) const + { + return num == o.num && str == o.str; + } +}; + +std::ostream& operator<<(std::ostream& o, const myclass& m) +{ + return o << "myclass("<()); +} + + +TEST(object, print) +{ + msgpack::object obj; + std::cout << obj << std::endl; +} + + +TEST(object, is_nil) +{ + msgpack::object obj; + EXPECT_TRUE(obj.is_nil()); +} + + +TEST(object, type_error) +{ + msgpack::object obj(1); + EXPECT_THROW(obj.as(), msgpack::type_error); + EXPECT_THROW(obj.as >(), msgpack::type_error); + EXPECT_EQ(1, obj.as()); + EXPECT_EQ(1, obj.as()); + EXPECT_EQ(1u, obj.as()); + EXPECT_EQ(1u, obj.as()); +} + + +TEST(object, equal_primitive) +{ + msgpack::object obj_nil; + EXPECT_EQ(obj_nil, msgpack::object()); + + msgpack::object obj_int(1); + EXPECT_EQ(obj_int, msgpack::object(1)); + EXPECT_EQ(obj_int, 1); + + msgpack::object obj_double(1.2); + EXPECT_EQ(obj_double, msgpack::object(1.2)); + EXPECT_EQ(obj_double, 1.2); + + msgpack::object obj_bool(true); + EXPECT_EQ(obj_bool, msgpack::object(true)); + EXPECT_EQ(obj_bool, true); +} + + +TEST(object, construct_primitive) +{ + msgpack::object obj_nil; + EXPECT_EQ(msgpack::type::NIL, obj_nil.type); + + msgpack::object obj_uint(1); + EXPECT_EQ(msgpack::type::POSITIVE_INTEGER, obj_uint.type); + EXPECT_EQ(1u, obj_uint.via.u64); + + msgpack::object obj_int(-1); + EXPECT_EQ(msgpack::type::NEGATIVE_INTEGER, obj_int.type); + EXPECT_EQ(-1, obj_int.via.i64); + + msgpack::object obj_double(1.2); + EXPECT_EQ(msgpack::type::DOUBLE, obj_double.type); + EXPECT_EQ(1.2, obj_double.via.dec); + + msgpack::object obj_bool(true); + EXPECT_EQ(msgpack::type::BOOLEAN, obj_bool.type); + EXPECT_EQ(true, obj_bool.via.boolean); +} diff --git a/test/object_with_zone.cpp b/test/object_with_zone.cpp new file mode 100644 index 00000000..b020e3b3 --- /dev/null +++ b/test/object_with_zone.cpp @@ -0,0 +1,701 @@ +#include +#include +#include + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +using namespace std; + +const unsigned int kLoop = 1000; +const unsigned int kElements = 100; +const double kEPS = 1e-10; + +// bool +TEST(object_with_zone, bool) +{ + bool v = true; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); + v = false; + EXPECT_TRUE(obj.as()); +} + +// char +TEST(object_with_zone, char) +{ + char v = 1; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); + v = 2; + EXPECT_EQ(obj.as(), 1); +} + +// signed integer family +TEST(object_with_zone, signed_char) +{ + signed char v = -1; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); + v = -2; + EXPECT_EQ(obj.as(), -1); +} + +TEST(object_with_zone, signed_short) +{ + signed short v = -1; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); + v = -2; + EXPECT_EQ(obj.as(), -1); +} + +TEST(object_with_zone, signed_int) +{ + signed int v = -1; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); + v = -2; + EXPECT_EQ(obj.as(), -1); +} + +TEST(object_with_zone, signed_long) +{ + signed long v = -1; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); + v = -2; + EXPECT_EQ(obj.as(), -1); +} + +TEST(object_with_zone, signed_long_long) +{ + signed long long v = -1; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); + v = -2; + EXPECT_EQ(obj.as(), -1); +} + +// unsigned integer family +TEST(object_with_zone, unsigned_char) +{ + unsigned char v = 1; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); + v = 2; + EXPECT_EQ(obj.as(), 1); +} + +TEST(object_with_zone, unsigned_short) +{ + unsigned short v = 1; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); + v = 2; + EXPECT_EQ(obj.as(), 1); +} + +TEST(object_with_zone, unsigned_int) +{ + unsigned int v = 1; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); + v = 2; + EXPECT_EQ(obj.as(), 1); +} + +TEST(object_with_zone, unsigned_long) +{ + unsigned long v = 1; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); + v = 2; + EXPECT_EQ(obj.as(), 1); +} + +TEST(object_with_zone, unsigned_long_long) +{ + unsigned long long v = 1; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); + v = 2; + EXPECT_EQ(obj.as(), 1); +} + +// float +TEST(object_with_zone, float) +{ + float v = 1.23; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_TRUE(fabs(obj.as() - v) <= kEPS); + v = 4.56; + EXPECT_TRUE(fabs(obj.as() - static_cast(1.23)) <= kEPS); +} + +// double +TEST(object_with_zone, double) +{ + double v = 1.23; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_TRUE(fabs(obj.as() - v) <= kEPS); + v = 4.56; + EXPECT_TRUE(fabs(obj.as() - 1.23) <= kEPS); +} + +// vector + +TEST(object_with_zone, vector) +{ + for (unsigned int k = 0; k < kLoop; k++) { + vector v1; + v1.push_back(1); + for (unsigned int i = 1; i < kElements; i++) + v1.push_back(i); + msgpack::zone z; + msgpack::object obj(v1, z); + EXPECT_EQ(obj.as >(), v1); + v1.front() = 42; + EXPECT_EQ(obj.as >().front(), 1); + } +} + +// vector_char +TEST(object_with_zone, vector_char) +{ + for (unsigned int k = 0; k < kLoop; k++) { + vector v1; + v1.push_back(1); + for (unsigned int i = 1; i < kElements; i++) + v1.push_back(static_cast(i)); + msgpack::zone z; + msgpack::object obj(v1, z); + EXPECT_EQ(obj.as >(), v1); + v1.front() = 42; + EXPECT_EQ(obj.as >().front(), 1); + } +} + +TEST(object_without_zone, vector_char) +{ + for (unsigned int k = 0; k < kLoop; k++) { + vector v1; + v1.push_back(1); + for (unsigned int i = 1; i < kElements; i++) + v1.push_back(static_cast(i)); + msgpack::object obj(v1); + EXPECT_EQ(obj.as >(), v1); + v1.front() = 42; + // obj refer to v1 + EXPECT_EQ(obj.as >().front(), 42); + } +} + +// list +TEST(object_with_zone, list) +{ + for (unsigned int k = 0; k < kLoop; k++) { + list v1; + v1.push_back(1); + for (unsigned int i = 1; i < kElements; i++) + v1.push_back(i); + msgpack::zone z; + msgpack::object obj(v1, z); + EXPECT_EQ(obj.as >(), v1); + v1.front() = 42; + EXPECT_EQ(obj.as >().front(), 1); + } +} + +// deque +TEST(object_with_zone, deque) +{ + for (unsigned int k = 0; k < kLoop; k++) { + deque v1; + v1.push_back(1); + for (unsigned int i = 1; i < kElements; i++) + v1.push_back(i); + msgpack::zone z; + msgpack::object obj(v1, z); + EXPECT_EQ(obj.as >(), v1); + v1.front() = 42; + EXPECT_EQ(obj.as >().front(), 1); + } +} + +// string +TEST(object_with_zone, string) +{ + string v = "abc"; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); + v[0] = 'd'; + EXPECT_EQ(obj.as()[0], 'a'); +} + +TEST(object_without_zone, string) +{ + string v = "abc"; + msgpack::zone z; + msgpack::object obj(v); + EXPECT_EQ(obj.as(), v); + v[0] = 'd'; + EXPECT_EQ(obj.as()[0], 'd'); +} + +// char* +TEST(object_with_zone, char_ptr) +{ + char v[] = "abc"; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), std::string(v)); + v[0] = 'd'; + EXPECT_EQ(obj.as()[0], 'a'); +} + +TEST(object_without_zone, char_ptr) +{ + char v[] = "abc"; + msgpack::zone z; + msgpack::object obj(v); + EXPECT_EQ(obj.as(), std::string(v)); + v[0] = 'd'; + EXPECT_EQ(obj.as()[0], 'd'); +} + + +// raw_ref +TEST(object_with_zone, raw_ref) +{ + string s = "abc"; + msgpack::type::raw_ref v(s.data(), s.size()); + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); + s[0] = 'd'; + // even if with_zone, not copied due to raw_ref + // Basically, the combination raw_ref and object::wit_zone + // is meaningless. + EXPECT_EQ(obj.as(), v); +} + +TEST(object_without_zone, raw_ref) +{ + string s = "abc"; + msgpack::type::raw_ref v(s.data(), s.size()); + msgpack::zone z; + msgpack::object obj(v); + EXPECT_EQ(obj.as(), v); + s[0] = 'd'; + EXPECT_EQ(obj.as(), v); +} + +// pair +TEST(object_with_zone, pair) +{ + typedef pair test_t; + test_t v(1, "abc"); + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); + v.first = 42; + EXPECT_EQ(obj.as().first, 1); +} + +// set +TEST(object_with_zone, set) +{ + for (unsigned int k = 0; k < kLoop; k++) { + set v1; + for (unsigned int i = 0; i < kElements; i++) + v1.insert(i); + msgpack::zone z; + msgpack::object obj(v1, z); + EXPECT_EQ(obj.as >(), v1); + } +} + +// multiset +TEST(object_with_zone, multiset) +{ + for (unsigned int k = 0; k < kLoop; k++) { + multiset v1; + for (unsigned int i = 0; i < kElements; i++) + v1.insert(i % (kElements / 2)); + msgpack::zone z; + msgpack::object obj(v1, z); + EXPECT_EQ(obj.as >(), v1); + } +} + +// map +TEST(object_with_zone, map) +{ + typedef map test_t; + for (unsigned int k = 0; k < kLoop; k++) { + test_t v1; + for (unsigned int i = 0; i < kElements; i++) + v1.insert(std::make_pair(i, i*2)); + msgpack::zone z; + msgpack::object obj(v1, z); + EXPECT_EQ(obj.as(), v1); + } +} + +// multimap +TEST(object_with_zone, multimap) +{ + typedef multimap test_t; + for (unsigned int k = 0; k < kLoop; k++) { + test_t v1; + for (unsigned int i = 0; i < kElements; i++) + v1.insert(std::make_pair(i % (kElements / 2), i*2)); + msgpack::zone z; + msgpack::object obj(v1, z); + EXPECT_EQ(obj.as(), v1); + } +} + +// msgpack_tuple +TEST(object_with_zone, msgpack_tuple) +{ + typedef msgpack::type::tuple test_t; + test_t v(1, "abc", true); + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(msgpack::type::get<0>(obj.as()), 1); + EXPECT_EQ(msgpack::type::get<1>(obj.as()), "abc"); + EXPECT_EQ(msgpack::type::get<2>(obj.as()), true); + msgpack::type::get<0>(v) = 42; + EXPECT_EQ(msgpack::type::get<0>(obj.as()), 1); +} + +TEST(object_with_zone, msgpack_tuple_empty) +{ + typedef msgpack::type::tuple<> test_t; + test_t v; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.via.array.size, 0); +} + +// TR1 + +#ifdef MSGPACK_HAS_STD_TR1_UNOURDERED_MAP +#include +#include "msgpack/adaptor/tr1/unordered_map.hpp" +TEST(object_with_zone, tr1_unordered_map) +{ + typedef tr1::unordered_map test_t; + for (unsigned int k = 0; k < kLoop; k++) { + test_t v1; + for (unsigned int i = 0; i < kElements; i++) + v1[rand()] = rand(); + msgpack::zone z; + msgpack::object obj(v1, z); + test_t v2 = obj.as(); + EXPECT_EQ(v1.size(), v2.size()); + test_t::const_iterator it; + for (it = v1.begin(); it != v1.end(); ++it) { + EXPECT_TRUE(v2.find(it->first) != v2.end()); + EXPECT_EQ(it->second, v2.find(it->first)->second); + } + } +} + + +TEST(object_with_zone, tr1_unordered_multimap) +{ + typedef tr1::unordered_multimap test_t; + for (unsigned int k = 0; k < kLoop; k++) { + test_t v1; + for (unsigned int i = 0; i < kElements; i++) { + int i1 = rand(); + v1.insert(make_pair(i1, rand())); + v1.insert(make_pair(i1, rand())); + } + msgpack::zone z; + msgpack::object obj(v1, z); + test_t v2 = obj.as(); + vector > vec1, vec2; + tr1::unordered_multimap::const_iterator it; + for (it = v1.begin(); it != v1.end(); ++it) + vec1.push_back(make_pair(it->first, it->second)); + for (it = v2.begin(); it != v2.end(); ++it) + vec2.push_back(make_pair(it->first, it->second)); + EXPECT_EQ(v1.size(), v2.size()); + EXPECT_EQ(vec1.size(), vec2.size()); + sort(vec1.begin(), vec1.end()); + sort(vec2.begin(), vec2.end()); + EXPECT_TRUE(vec1 == vec2); + } +} +#endif + +#ifdef MSGPACK_HAS_STD_TR1_UNOURDERED_SET +#include +#include "msgpack/adaptor/tr1/unordered_set.hpp" +TEST(object_with_zone, tr1_unordered_set) +{ + typedef tr1::unordered_set test_t; + for (unsigned int k = 0; k < kLoop; k++) { + test_t v1; + for (unsigned int i = 0; i < kElements; i++) + v1.insert(rand()); + msgpack::zone z; + msgpack::object obj(v1, z); + test_t v2 = obj.as(); + EXPECT_EQ(v1.size(), v2.size()); + tr1::unordered_set::const_iterator it; + for (it = v1.begin(); it != v1.end(); ++it) + EXPECT_TRUE(v2.find(*it) != v2.end()); + } +} + +TEST(object_with_zone, tr1_unordered_multiset) +{ + typedef tr1::unordered_set test_t; + for (unsigned int k = 0; k < kLoop; k++) { + test_t v1; + for (unsigned int i = 0; i < kElements; i++) { + int i1 = rand(); + v1.insert(i1); + v1.insert(i1); + } + msgpack::zone z; + msgpack::object obj(v1, z); + test_t v2 = obj.as(); + vector vec1, vec2; + tr1::unordered_multiset::const_iterator it; + for (it = v1.begin(); it != v1.end(); ++it) + vec1.push_back(*it); + for (it = v2.begin(); it != v2.end(); ++it) + vec2.push_back(*it); + EXPECT_EQ(v1.size(), v2.size()); + EXPECT_EQ(vec1.size(), vec2.size()); + sort(vec1.begin(), vec1.end()); + sort(vec2.begin(), vec2.end()); + EXPECT_TRUE(vec1 == vec2); + } +} +#endif + +#ifdef MSGPACK_HAS_STD_UNOURDERED_MAP +#include +#include "msgpack/adaptor/tr1/unordered_map.hpp" +TEST(object_with_zone, unordered_map) +{ + typedef unordered_map test_t; + for (unsigned int k = 0; k < kLoop; k++) { + test_t v1; + for (unsigned int i = 0; i < kElements; i++) + v1[rand()] = rand(); + msgpack::zone z; + msgpack::object obj(v1, z); + test_t v2 = obj.as(); + EXPECT_EQ(v1.size(), v2.size()); + test_t::const_iterator it; + for (it = v1.begin(); it != v1.end(); ++it) { + EXPECT_TRUE(v2.find(it->first) != v2.end()); + EXPECT_EQ(it->second, v2.find(it->first)->second); + } + } +} + +TEST(object_with_zone, unordered_multimap) +{ + typedef unordered_multimap test_t; + for (unsigned int k = 0; k < kLoop; k++) { + test_t v1; + for (unsigned int i = 0; i < kElements; i++) { + int i1 = rand(); + v1.insert(make_pair(i1, rand())); + v1.insert(make_pair(i1, rand())); + } + msgpack::zone z; + msgpack::object obj(v1, z); + test_t v2 = obj.as(); + vector > vec1, vec2; + unordered_multimap::const_iterator it; + for (it = v1.begin(); it != v1.end(); ++it) + vec1.push_back(make_pair(it->first, it->second)); + for (it = v2.begin(); it != v2.end(); ++it) + vec2.push_back(make_pair(it->first, it->second)); + EXPECT_EQ(v1.size(), v2.size()); + EXPECT_EQ(vec1.size(), vec2.size()); + sort(vec1.begin(), vec1.end()); + sort(vec2.begin(), vec2.end()); + EXPECT_TRUE(vec1 == vec2); + } +} +#endif + +#ifdef MSGPACK_HAS_STD_UNOURDERED_SET +#include +#include "msgpack/adaptor/tr1/unordered_set.hpp" +TEST(object_with_zone, unordered_set) +{ + typedef unordered_set test_t; + for (unsigned int k = 0; k < kLoop; k++) { + test_t v1; + for (unsigned int i = 0; i < kElements; i++) + v1.insert(rand()); + msgpack::zone z; + msgpack::object obj(v1, z); + test_t v2 = obj.as(); + EXPECT_EQ(v1.size(), v2.size()); + unordered_set::const_iterator it; + for (it = v1.begin(); it != v1.end(); ++it) + EXPECT_TRUE(v2.find(*it) != v2.end()); + } +} + +TEST(object_with_zone, unordered_multiset) +{ + typedef unordered_set test_t; + for (unsigned int k = 0; k < kLoop; k++) { + test_t v1; + for (unsigned int i = 0; i < kElements; i++) { + int i1 = rand(); + v1.insert(i1); + v1.insert(i1); + } + msgpack::zone z; + msgpack::object obj(v1, z); + test_t v2 = obj.as(); + vector vec1, vec2; + unordered_multiset::const_iterator it; + for (it = v1.begin(); it != v1.end(); ++it) + vec1.push_back(*it); + for (it = v2.begin(); it != v2.end(); ++it) + vec2.push_back(*it); + EXPECT_EQ(v1.size(), v2.size()); + EXPECT_EQ(vec1.size(), vec2.size()); + sort(vec1.begin(), vec1.end()); + sort(vec2.begin(), vec2.end()); + EXPECT_TRUE(vec1 == vec2); + } +} +#endif + +// User defined class +class TestClass +{ +public: + TestClass() : i(0), s("kzk") {} + int i; + string s; + MSGPACK_DEFINE(i, s); +}; + +TEST(object_with_zone, user_defined) +{ + TestClass v1; + msgpack::zone z; + msgpack::object obj(v1, z); + TestClass v2 = obj.as(); + EXPECT_EQ(v1.i, v2.i); + EXPECT_EQ(v1.s, v2.s); +} + +#if !defined(MSGPACK_USE_CPP03) + +TEST(object_with_zone, array) +{ + typedef array test_t; + for (unsigned int k = 0; k < kLoop; k++) { + test_t v1; + v1[0] = 1; + for (unsigned int i = 1; i < kElements; i++) + v1[i] = rand(); + msgpack::zone z; + msgpack::object obj(v1, z); + EXPECT_EQ(obj.as(), v1); + v1.front() = 42; + EXPECT_EQ(obj.as().front(), 1); + } +} + +TEST(object_with_zone, array_char) +{ + typedef array test_t; + for (unsigned int k = 0; k < kLoop; k++) { + test_t v1; + v1[0] = 1; + for (unsigned int i = 1; i < kElements; i++) + v1[i] = rand(); + msgpack::zone z; + msgpack::object obj(v1, z); + EXPECT_EQ(obj.as(), v1); + v1.front() = 42; + EXPECT_EQ(obj.as().front(), 1); + } +} + +TEST(object_without_zone, array_char) +{ + typedef array test_t; + for (unsigned int k = 0; k < kLoop; k++) { + test_t v1; + v1[0] = 1; + for (unsigned int i = 1; i < kElements; i++) + v1[i] = rand(); + msgpack::object obj(v1); + EXPECT_EQ(obj.as(), v1); + v1.front() = 42; + // obj refer to v1 + EXPECT_EQ(obj.as().front(), 42); + } +} + + +TEST(object_with_zone, forward_list) +{ + for (unsigned int k = 0; k < kLoop; k++) { + forward_list v1; + for (unsigned int i = 0; i < kElements; i++) + v1.push_front(i); + msgpack::zone z; + msgpack::object obj(v1, z); + EXPECT_EQ(obj.as >(), v1); + v1.front() = 42; + EXPECT_EQ(obj.as >().front(), kElements - 1); + } +} + +TEST(object_with_zone, tuple) +{ + typedef tuple test_t; + test_t v(1, "abc", true); + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); +} + +TEST(object_with_zone, tuple_empty) +{ + typedef tuple<> test_t; + test_t v; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); +} + +#endif diff --git a/test/pack_unpack.cc b/test/pack_unpack.cc deleted file mode 100644 index ac47f2d9..00000000 --- a/test/pack_unpack.cc +++ /dev/null @@ -1,123 +0,0 @@ -#include -#include -#include - -TEST(pack, num) -{ - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, 1); -} - - -TEST(pack, vector) -{ - msgpack::sbuffer sbuf; - std::vector vec; - vec.push_back(1); - vec.push_back(2); - vec.push_back(3); - msgpack::pack(sbuf, vec); -} - - -TEST(pack, to_ostream) -{ - std::ostringstream stream; - msgpack::pack(stream, 1); -} - - -struct myclass { - myclass() : num(0), str("default") { } - - myclass(int num, const std::string& str) : - num(num), str(str) { } - - ~myclass() { } - - int num; - std::string str; - - MSGPACK_DEFINE(num, str); -}; - - -TEST(pack, myclass) -{ - msgpack::sbuffer sbuf; - myclass m(1, "msgpack"); - msgpack::pack(sbuf, m); -} - - -TEST(unpack, myclass) -{ - msgpack::sbuffer sbuf; - myclass m1(1, "phraser"); - msgpack::pack(sbuf, m1); - - msgpack::zone z; - msgpack::object obj; - - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); - - EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); - - myclass m2 = obj.as(); - EXPECT_EQ(m1.num, m2.num); - EXPECT_EQ(m1.str, m2.str); -} - - -TEST(unpack, sequence) -{ - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, 1); - msgpack::pack(sbuf, 2); - msgpack::pack(sbuf, 3); - - size_t offset = 0; - - msgpack::unpacked msg; - - msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &offset); - EXPECT_EQ(1, msg.get().as()); - - msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &offset); - EXPECT_EQ(2, msg.get().as()); - - msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &offset); - EXPECT_EQ(3, msg.get().as()); -} - - -TEST(unpack, sequence_compat) -{ - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, 1); - msgpack::pack(sbuf, 2); - msgpack::pack(sbuf, 3); - - size_t offset = 0; - - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret; - - ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, &z, &obj); - EXPECT_TRUE(ret >= 0); - EXPECT_EQ(ret, msgpack::UNPACK_EXTRA_BYTES); - EXPECT_EQ(1, obj.as()); - - ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, &z, &obj); - EXPECT_TRUE(ret >= 0); - EXPECT_EQ(ret, msgpack::UNPACK_EXTRA_BYTES); - EXPECT_EQ(2, obj.as()); - - ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, &z, &obj); - EXPECT_TRUE(ret >= 0); - EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); - EXPECT_EQ(3, obj.as()); -} - diff --git a/test/pack_unpack.cpp b/test/pack_unpack.cpp new file mode 100644 index 00000000..da635683 --- /dev/null +++ b/test/pack_unpack.cpp @@ -0,0 +1,242 @@ +#include +#include +#include + +TEST(pack, num) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); +} + + +TEST(pack, vector) +{ + msgpack::sbuffer sbuf; + std::vector vec; + vec.push_back(1); + vec.push_back(2); + vec.push_back(3); + msgpack::pack(sbuf, vec); +} + + +TEST(pack, to_ostream) +{ + std::ostringstream stream; + msgpack::pack(stream, 1); +} + + +struct myclass { + myclass() : num(0), str("default") { } + + myclass(int num, const std::string& str) : + num(num), str(str) { } + + ~myclass() { } + + int num; + std::string str; + + MSGPACK_DEFINE(num, str); +}; + + +TEST(pack, myclass) +{ + msgpack::sbuffer sbuf; + myclass m(1, "msgpack"); + msgpack::pack(sbuf, m); +} + + +#if !defined(MSGPACK_USE_CPP03) + +TEST(unpack, int_ret_no_offset_no_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + + msgpack::unpacked msg = msgpack::unpack(sbuf.data(), sbuf.size()); + EXPECT_EQ(1, msg.get().as()); +} + +TEST(unpack, int_ret_offset_no_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + + std::size_t off = 0; + + msgpack::unpacked msg = msgpack::unpack(sbuf.data(), sbuf.size(), off); + EXPECT_EQ(1, msg.get().as()); + EXPECT_EQ(off, sbuf.size()); +} + +TEST(unpack, int_ret_no_offset_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + bool referenced; + + msgpack::unpacked msg = msgpack::unpack(sbuf.data(), sbuf.size(), referenced); + EXPECT_EQ(1, msg.get().as()); + EXPECT_EQ(false, referenced); +} + +TEST(unpack, int_ret_offset_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + std::size_t off = 0; + bool referenced; + + msgpack::unpacked msg = msgpack::unpack(sbuf.data(), sbuf.size(), off, referenced); + EXPECT_EQ(1, msg.get().as()); + EXPECT_EQ(false, referenced); + EXPECT_EQ(off, sbuf.size()); +} + +#endif // !defined(MSGPACK_USE_CPP03) + + +TEST(unpack, int_no_offset_no_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::unpacked msg; + + msgpack::unpack(msg, sbuf.data(), sbuf.size()); + EXPECT_EQ(1, msg.get().as()); +} + +TEST(unpack, int_offset_no_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::unpacked msg; + + std::size_t off = 0; + + msgpack::unpack(msg, sbuf.data(), sbuf.size(), off); + EXPECT_EQ(1, msg.get().as()); + EXPECT_EQ(off, sbuf.size()); +} + +TEST(unpack, int_no_offset_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::unpacked msg; + bool referenced; + + msgpack::unpack(msg, sbuf.data(), sbuf.size(), referenced); + EXPECT_EQ(1, msg.get().as()); + EXPECT_EQ(false, referenced); +} + +TEST(unpack, int_offset_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::unpacked msg; + std::size_t off = 0; + bool referenced; + + msgpack::unpack(msg, sbuf.data(), sbuf.size(), off, referenced); + EXPECT_EQ(1, msg.get().as()); + EXPECT_EQ(false, referenced); + EXPECT_EQ(off, sbuf.size()); +} + + +TEST(unpack, int_pointer_off_no_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::unpacked msg; + + std::size_t off = 0; + + // obsolete + msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &off); + EXPECT_EQ(1, msg.get().as()); + EXPECT_EQ(off, sbuf.size()); +} + +TEST(unpack, int_pointer_off_no_ref_explicit) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::unpacked msg; + + std::size_t off = 0; + + // obsolete + msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &off, nullptr); + EXPECT_EQ(1, msg.get().as()); + EXPECT_EQ(off, sbuf.size()); +} + +TEST(unpack, int_pointer_no_off_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::unpacked msg; + bool referenced; + + // obsolete + msgpack::unpack(&msg, sbuf.data(), sbuf.size(), nullptr, &referenced); + EXPECT_EQ(1, msg.get().as()); + EXPECT_EQ(false, referenced); +} + +TEST(unpack, int_pointer_off_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::unpacked msg; + bool referenced; + std::size_t off = 0; + + // obsolete + msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &off, &referenced); + EXPECT_EQ(1, msg.get().as()); + EXPECT_EQ(off, sbuf.size()); + EXPECT_EQ(false, referenced); +} + + +TEST(unpack, int_default_null_pointer) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::unpacked msg; + + // obsolete + msgpack::unpack(&msg, sbuf.data(), sbuf.size()); + EXPECT_EQ(1, msg.get().as()); +} + +TEST(unpack, sequence) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::pack(sbuf, 2); + msgpack::pack(sbuf, 3); + + std::size_t off = 0; + + msgpack::unpacked msg; + + msgpack::unpack(msg, sbuf.data(), sbuf.size(), off); + EXPECT_EQ(1, msg.get().as()); + + msgpack::unpack(msg, sbuf.data(), sbuf.size(), off); + EXPECT_EQ(2, msg.get().as()); + + msgpack::unpack(msg, sbuf.data(), sbuf.size(), off); + EXPECT_EQ(3, msg.get().as()); + + EXPECT_EQ(off, sbuf.size()); +} diff --git a/test/pack_unpack_c.cc b/test/pack_unpack_c.cc deleted file mode 100644 index e9a03892..00000000 --- a/test/pack_unpack_c.cc +++ /dev/null @@ -1,70 +0,0 @@ -#include -#include -#include - -TEST(pack, num) -{ - msgpack_sbuffer* sbuf = msgpack_sbuffer_new(); - msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write); - - EXPECT_EQ(0, msgpack_pack_int(pk, 1)); - - msgpack_sbuffer_free(sbuf); - msgpack_packer_free(pk); -} - - -TEST(pack, array) -{ - msgpack_sbuffer* sbuf = msgpack_sbuffer_new(); - msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write); - - EXPECT_EQ(0, msgpack_pack_array(pk, 3)); - EXPECT_EQ(0, msgpack_pack_int(pk, 1)); - EXPECT_EQ(0, msgpack_pack_int(pk, 2)); - EXPECT_EQ(0, msgpack_pack_int(pk, 3)); - - msgpack_sbuffer_free(sbuf); - msgpack_packer_free(pk); -} - - -TEST(unpack, sequence) -{ - msgpack_sbuffer* sbuf = msgpack_sbuffer_new(); - msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write); - - EXPECT_EQ(0, msgpack_pack_int(pk, 1)); - EXPECT_EQ(0, msgpack_pack_int(pk, 2)); - EXPECT_EQ(0, msgpack_pack_int(pk, 3)); - - msgpack_packer_free(pk); - - bool success; - size_t offset = 0; - - msgpack_unpacked msg; - msgpack_unpacked_init(&msg); - - success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset); - EXPECT_TRUE(success); - EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, msg.data.type); - EXPECT_EQ(1, msg.data.via.u64); - - success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset); - EXPECT_TRUE(success); - EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, msg.data.type); - EXPECT_EQ(2, msg.data.via.u64); - - success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset); - EXPECT_TRUE(success); - EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, msg.data.type); - EXPECT_EQ(3, msg.data.via.u64); - - success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset); - EXPECT_FALSE(success); - - msgpack_sbuffer_free(sbuf); - msgpack_unpacked_destroy(&msg); -} - diff --git a/test/pack_unpack_c.cpp b/test/pack_unpack_c.cpp new file mode 100644 index 00000000..60e0e00e --- /dev/null +++ b/test/pack_unpack_c.cpp @@ -0,0 +1,70 @@ +#include +#include +#include + +TEST(pack, num) +{ + msgpack_sbuffer* sbuf = msgpack_sbuffer_new(); + msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write); + + EXPECT_EQ(0, msgpack_pack_int(pk, 1)); + + msgpack_sbuffer_free(sbuf); + msgpack_packer_free(pk); +} + + +TEST(pack, array) +{ + msgpack_sbuffer* sbuf = msgpack_sbuffer_new(); + msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write); + + EXPECT_EQ(0, msgpack_pack_array(pk, 3)); + EXPECT_EQ(0, msgpack_pack_int(pk, 1)); + EXPECT_EQ(0, msgpack_pack_int(pk, 2)); + EXPECT_EQ(0, msgpack_pack_int(pk, 3)); + + msgpack_sbuffer_free(sbuf); + msgpack_packer_free(pk); +} + + +TEST(unpack, sequence) +{ + msgpack_sbuffer* sbuf = msgpack_sbuffer_new(); + msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write); + + EXPECT_EQ(0, msgpack_pack_int(pk, 1)); + EXPECT_EQ(0, msgpack_pack_int(pk, 2)); + EXPECT_EQ(0, msgpack_pack_int(pk, 3)); + + msgpack_packer_free(pk); + + bool success; + size_t offset = 0; + + msgpack_unpacked msg; + msgpack_unpacked_init(&msg); + + success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset); + EXPECT_TRUE(success); + EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, msg.data.type); + EXPECT_EQ(1, msg.data.via.u64); + + success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset); + EXPECT_TRUE(success); + EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, msg.data.type); + EXPECT_EQ(2, msg.data.via.u64); + + success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset); + EXPECT_TRUE(success); + EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, msg.data.type); + EXPECT_EQ(3, msg.data.via.u64); + + success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset); + EXPECT_FALSE(success); + + msgpack_sbuffer_free(sbuf); + msgpack_unpacked_destroy(&msg); +} + diff --git a/test/reference.cpp b/test/reference.cpp new file mode 100644 index 00000000..7c338a38 --- /dev/null +++ b/test/reference.cpp @@ -0,0 +1,461 @@ +#include +#include + +TEST(reference, unpack_int) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::unpacked ret; + bool referenced; + + msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced); + EXPECT_FALSE(referenced); +} + +TEST(reference, unpack_string) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, std::string("abcdefg")); + msgpack::unpacked ret; + bool referenced; + + msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced); + EXPECT_FALSE(referenced); +} + +TEST(reference, unpack_bin) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char c[] = { 1, 2, 3, 4, 5, 6 }; + packer.pack_bin(sizeof(c)); + packer.pack_bin_body(c, sizeof(c)); + + msgpack::unpacked ret; + bool referenced; + msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced); + EXPECT_FALSE(referenced); +} + +TEST(reference, unpack_ext) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2 }; + + packer.pack_ext(sizeof(buf), 1); + packer.pack_ext_body(buf, sizeof(buf)); + msgpack::unpacked ret; + bool referenced; + msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced); + EXPECT_FALSE(referenced); +} + +bool never_called(msgpack::type::object_type, std::size_t, void*) +{ + EXPECT_TRUE(false); + return false; +} + +bool always_reference(msgpack::type::object_type, std::size_t, void*) +{ + return true; +} + +TEST(reference, unpack_int_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::unpacked ret; + bool referenced; + + msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, never_called); + EXPECT_FALSE(referenced); +} + +TEST(reference, unpack_string_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, std::string("abcdefg")); + msgpack::unpacked ret; + bool referenced; + + + msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, always_reference); + EXPECT_TRUE(referenced); +} + +TEST(reference, unpack_bin_ref) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char c[] = { 1, 2, 3, 4, 5, 6 }; + packer.pack_bin(sizeof(c)); + packer.pack_bin_body(c, sizeof(c)); + + msgpack::unpacked ret; + bool referenced; + msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, always_reference); + EXPECT_TRUE(referenced); +} + +TEST(reference, unpack_ext_ref) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2 }; + + packer.pack_ext(sizeof(buf), 1); + packer.pack_ext_body(buf, sizeof(buf)); + msgpack::unpacked ret; + bool referenced; + msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, always_reference); + EXPECT_TRUE(referenced); +} + +static void* s_p; + +bool sized_reference(msgpack::type::object_type t, std::size_t s, void* p) +{ + s_p = p; + switch (t) { + case msgpack::type::STR: + if (s >= 5) return true; + break; + case msgpack::type::BIN: + if (s >= 6) return true; + break; + case msgpack::type::EXT: + if (s >= 7) return true; + break; + default: + EXPECT_TRUE(false); + } + return false; +} + +TEST(reference, unpack_int_sized_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + + msgpack::unpacked ret; + bool referenced; + s_p = nullptr; + msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, never_called, &sbuf); + EXPECT_FALSE(referenced); + EXPECT_EQ(nullptr, s_p); +} + +TEST(reference, unpack_string_sized_ref_4) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, std::string("1234")); + + msgpack::unpacked ret; + bool referenced; + s_p = nullptr; + // the last argument sbuf is any pointer as a user data. + // That is stored to s_p in sized_reference + msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); + EXPECT_FALSE(referenced); + // compare the passed argument with stored s_p. + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpack_string_sized_ref_5) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, std::string("12345")); + + msgpack::unpacked ret; + bool referenced; + s_p = nullptr; + msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); + EXPECT_TRUE(referenced); + EXPECT_EQ(&sbuf, s_p); +} + + +TEST(reference, unpack_bin_sized_ref_5) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char c[] = { 1, 2, 3, 4, 5 }; + packer.pack_bin(sizeof(c)); + packer.pack_bin_body(c, sizeof(c)); + + msgpack::unpacked ret; + bool referenced; + s_p = nullptr; + msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); + EXPECT_FALSE(referenced); + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpack_bin_sized_ref_6) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char c[] = { 1, 2, 3, 4, 5, 6 }; + packer.pack_bin(sizeof(c)); + packer.pack_bin_body(c, sizeof(c)); + + msgpack::unpacked ret; + bool referenced; + s_p = nullptr; + msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); + EXPECT_TRUE(referenced); + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpack_ext_sized_ref_6) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 1, 2, 3, 4, 5 }; + + packer.pack_ext(sizeof(buf), 1); // 5 + 1(type) = 6 + packer.pack_ext_body(buf, sizeof(buf)); + + msgpack::unpacked ret; + bool referenced; + s_p = nullptr; + msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); + EXPECT_FALSE(referenced); + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpack_ext_sized_ref_7) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 1, 2, 3, 4, 5, 6 }; + + packer.pack_ext(sizeof(buf), 1); // 6 + 1(type) = 7 + packer.pack_ext_body(buf, sizeof(buf)); + + msgpack::unpacked ret; + bool referenced; + s_p = nullptr; + msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); + EXPECT_TRUE(referenced); + EXPECT_EQ(&sbuf, s_p); +} + +// default reference function +// STR, BIN, and EXT are always referenced, otherwise copied (converted). + +TEST(reference, unpacker_int) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + + msgpack::unpacker unp; + msgpack::unpacked ret; + bool referenced; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + bool b = unp.next(ret, referenced); + EXPECT_TRUE(b); + EXPECT_FALSE(referenced); +} + +TEST(reference, unpacker_string) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, std::string("a")); + + msgpack::unpacker unp; + msgpack::unpacked ret; + bool referenced; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + bool b = unp.next(ret, referenced); + EXPECT_TRUE(b); + EXPECT_TRUE(referenced); +} + +TEST(reference, unpacker_bin) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char c[] = { 1 }; + packer.pack_bin(sizeof(c)); + packer.pack_bin_body(c, sizeof(c)); + + msgpack::unpacker unp; + msgpack::unpacked ret; + bool referenced; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + bool b = unp.next(ret, referenced); + EXPECT_TRUE(b); + EXPECT_TRUE(referenced); +} + +TEST(reference, unpacker_ext) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2 }; + + packer.pack_ext(sizeof(buf), 1); + packer.pack_ext_body(buf, sizeof(buf)); + + msgpack::unpacker unp; + msgpack::unpacked ret; + bool referenced; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + bool b = unp.next(ret, referenced); + EXPECT_TRUE(b); + EXPECT_TRUE(referenced); +} + +// pass user custom reference function + +TEST(reference, unpacker_int_sized_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + + msgpack::unpacker unp(never_called, &sbuf); + msgpack::unpacked ret; + bool referenced; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + s_p = nullptr; + bool b = unp.next(ret, referenced); + EXPECT_TRUE(b); + EXPECT_FALSE(referenced); + EXPECT_EQ(nullptr, s_p); +} + +TEST(reference, unpacker_string_sized_ref_4) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, std::string("1234")); + + msgpack::unpacker unp(sized_reference, &sbuf); + msgpack::unpacked ret; + bool referenced; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + s_p = nullptr; + bool b = unp.next(ret, referenced); + EXPECT_TRUE(b); + EXPECT_FALSE(referenced); + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpacker_string_sized_ref_5) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, std::string("12345")); + + msgpack::unpacker unp(sized_reference, &sbuf); + msgpack::unpacked ret; + bool referenced; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + s_p = nullptr; + bool b = unp.next(ret, referenced); + EXPECT_TRUE(b); + EXPECT_TRUE(referenced); + EXPECT_EQ(&sbuf, s_p); +} + + +TEST(reference, unpacker_bin_sized_ref_5) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char c[] = { 1, 2, 3, 4, 5 }; + packer.pack_bin(sizeof(c)); + packer.pack_bin_body(c, sizeof(c)); + + msgpack::unpacker unp(sized_reference, &sbuf); + msgpack::unpacked ret; + bool referenced; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + s_p = nullptr; + bool b = unp.next(ret, referenced); + EXPECT_TRUE(b); + EXPECT_FALSE(referenced); + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpacker_bin_sized_ref_6) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char c[] = { 1, 2, 3, 4, 5, 6 }; + packer.pack_bin(sizeof(c)); + packer.pack_bin_body(c, sizeof(c)); + + msgpack::unpacker unp(sized_reference, &sbuf); + msgpack::unpacked ret; + bool referenced; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + s_p = nullptr; + bool b = unp.next(ret, referenced); + EXPECT_TRUE(b); + EXPECT_TRUE(referenced); + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpacker_ext_sized_ref_6) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 1, 2, 3, 4, 5 }; + + packer.pack_ext(sizeof(buf), 1); // 5 + 1(type) = 6 + packer.pack_ext_body(buf, sizeof(buf)); + + msgpack::unpacker unp(sized_reference, &sbuf); + msgpack::unpacked ret; + bool referenced; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + s_p = nullptr; + bool b = unp.next(ret, referenced); + EXPECT_TRUE(b); + EXPECT_FALSE(referenced); + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpacker_ext_sized_ref_7) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 1, 2, 3, 4, 5, 6 }; + + packer.pack_ext(sizeof(buf), 1); // 6 + 1(type) = 7 + packer.pack_ext_body(buf, sizeof(buf)); + + msgpack::unpacker unp(sized_reference, &sbuf); + msgpack::unpacked ret; + bool referenced; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + s_p = nullptr; + bool b = unp.next(ret, referenced); + EXPECT_TRUE(b); + EXPECT_TRUE(referenced); + EXPECT_EQ(&sbuf, s_p); +} diff --git a/test/reference_cpp11.cpp b/test/reference_cpp11.cpp new file mode 100644 index 00000000..e4112024 --- /dev/null +++ b/test/reference_cpp11.cpp @@ -0,0 +1,232 @@ +#include +#include + +#if !defined(MSGPACK_USE_CPP03) + +TEST(reference, unpack_int) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + bool referenced; + + msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced); + EXPECT_FALSE(referenced); +} + +TEST(reference, unpack_string) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, std::string("abcdefg")); + bool referenced; + + msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced); + EXPECT_FALSE(referenced); +} + +TEST(reference, unpack_bin) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char c[] = { 1, 2, 3, 4, 5, 6 }; + packer.pack_bin(sizeof(c)); + packer.pack_bin_body(c, sizeof(c)); + + bool referenced; + msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced); + EXPECT_FALSE(referenced); +} + +TEST(reference, unpack_ext) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2 }; + + packer.pack_ext(sizeof(buf), 1); + packer.pack_ext_body(buf, sizeof(buf)); + bool referenced; + msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced); + EXPECT_FALSE(referenced); +} + +bool never_called(msgpack::type::object_type, std::size_t, void*) +{ + EXPECT_TRUE(false); + return false; +} + +bool always_reference(msgpack::type::object_type, std::size_t, void*) +{ + return true; +} + +TEST(reference, unpack_int_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + bool referenced; + + msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, never_called); + EXPECT_FALSE(referenced); +} + +TEST(reference, unpack_string_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, std::string("abcdefg")); + bool referenced; + + msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, always_reference); + EXPECT_TRUE(referenced); +} + +TEST(reference, unpack_bin_ref) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char c[] = { 1, 2, 3, 4, 5, 6 }; + packer.pack_bin(sizeof(c)); + packer.pack_bin_body(c, sizeof(c)); + + bool referenced; + msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, always_reference); + EXPECT_TRUE(referenced); +} + +TEST(reference, unpack_ext_ref) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2 }; + + packer.pack_ext(sizeof(buf), 1); + packer.pack_ext_body(buf, sizeof(buf)); + bool referenced; + msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, always_reference); + EXPECT_TRUE(referenced); +} + +static void* s_p; + +bool sized_reference(msgpack::type::object_type t, std::size_t s, void* p) +{ + s_p = p; + switch (t) { + case msgpack::type::STR: + if (s >= 5) return true; + break; + case msgpack::type::BIN: + if (s >= 6) return true; + break; + case msgpack::type::EXT: + if (s >= 7) return true; + break; + default: + EXPECT_TRUE(false); + } + return false; +} + +TEST(reference, unpack_int_sized_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + + bool referenced; + s_p = nullptr; + msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, never_called, &sbuf); + EXPECT_FALSE(referenced); + EXPECT_EQ(nullptr, s_p); +} + +TEST(reference, unpack_string_sized_ref_4) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, std::string("1234")); + + bool referenced; + s_p = nullptr; + // the last argument sbuf is any pointer as a user data. + // That is stored to s_p in sized_reference + msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); + EXPECT_FALSE(referenced); + // compare the passed argument with stored s_p. + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpack_string_sized_ref_5) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, std::string("12345")); + + bool referenced; + s_p = nullptr; + msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); + EXPECT_TRUE(referenced); + EXPECT_EQ(&sbuf, s_p); +} + + +TEST(reference, unpack_bin_sized_ref_5) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char c[] = { 1, 2, 3, 4, 5 }; + packer.pack_bin(sizeof(c)); + packer.pack_bin_body(c, sizeof(c)); + + bool referenced; + s_p = nullptr; + msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); + EXPECT_FALSE(referenced); + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpack_bin_sized_ref_6) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char c[] = { 1, 2, 3, 4, 5, 6 }; + packer.pack_bin(sizeof(c)); + packer.pack_bin_body(c, sizeof(c)); + + bool referenced; + s_p = nullptr; + msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); + EXPECT_TRUE(referenced); + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpack_ext_sized_ref_6) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 1, 2, 3, 4, 5 }; + + packer.pack_ext(sizeof(buf), 1); // 5 + 1(type) = 6 + packer.pack_ext_body(buf, sizeof(buf)); + + bool referenced; + s_p = nullptr; + msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); + EXPECT_FALSE(referenced); + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpack_ext_sized_ref_7) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 1, 2, 3, 4, 5, 6 }; + + packer.pack_ext(sizeof(buf), 1); // 6 + 1(type) = 7 + packer.pack_ext_body(buf, sizeof(buf)); + + bool referenced; + s_p = nullptr; + msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); + EXPECT_TRUE(referenced); + EXPECT_EQ(&sbuf, s_p); +} + +#endif // !defined(MSGPACK_USE_CPP03) diff --git a/test/streaming.cc b/test/streaming.cc deleted file mode 100644 index e80c671b..00000000 --- a/test/streaming.cc +++ /dev/null @@ -1,220 +0,0 @@ -#include -#include -#include - -TEST(streaming, basic) -{ - msgpack::sbuffer buffer; - - msgpack::packer pk(&buffer); - pk.pack(1); - pk.pack(2); - pk.pack(3); - - const char* input = buffer.data(); - const char* const eof = input + buffer.size(); - - msgpack::unpacker pac; - msgpack::unpacked result; - - int count = 0; - while(count < 3) { - pac.reserve_buffer(32*1024); - - // read buffer into pac.buffer() upto - // pac.buffer_capacity() bytes. - size_t len = 1; - memcpy(pac.buffer(), input, len); - input += len; - - pac.buffer_consumed(len); - - while(pac.next(&result)) { - msgpack::object obj = result.get(); - switch(count++) { - case 0: - EXPECT_EQ(1, obj.as()); - break; - case 1: - EXPECT_EQ(2, obj.as()); - break; - case 2: - EXPECT_EQ(3, obj.as()); - return; - } - } - - EXPECT_TRUE(input < eof); - } -} - - -class event_handler { -public: - event_handler(std::istream& input) : input(input) { } - ~event_handler() { } - - void on_read() - { - while(true) { - pac.reserve_buffer(32*1024); - - size_t len = input.readsome(pac.buffer(), pac.buffer_capacity()); - - if(len == 0) { - return; - } - - pac.buffer_consumed(len); - - msgpack::unpacked result; - while(pac.next(&result)) { - on_message(result.get(), result.zone()); - } - - if(pac.message_size() > 10*1024*1024) { - throw std::runtime_error("message is too large"); - } - } - } - - void on_message(msgpack::object obj, std::auto_ptr z) - { - EXPECT_EQ(expect, obj.as()); - } - - int expect; - -private: - std::istream& input; - msgpack::unpacker pac; -}; - -TEST(streaming, event) -{ - std::stringstream stream; - msgpack::packer pk(&stream); - - event_handler handler(stream); - - pk.pack(1); - handler.expect = 1; - handler.on_read(); - - pk.pack(2); - handler.expect = 2; - handler.on_read(); - - pk.pack(3); - handler.expect = 3; - handler.on_read(); -} - - -// backward compatibility -TEST(streaming, basic_compat) -{ - std::ostringstream stream; - msgpack::packer pk(&stream); - - pk.pack(1); - pk.pack(2); - pk.pack(3); - - std::istringstream input(stream.str()); - - msgpack::unpacker pac; - - int count = 0; - while(count < 3) { - pac.reserve_buffer(32*1024); - - size_t len = input.readsome(pac.buffer(), pac.buffer_capacity()); - pac.buffer_consumed(len); - - while(pac.execute()) { - std::auto_ptr z(pac.release_zone()); - msgpack::object obj = pac.data(); - pac.reset(); - - switch(count++) { - case 0: - EXPECT_EQ(1, obj.as()); - break; - case 1: - EXPECT_EQ(2, obj.as()); - break; - case 2: - EXPECT_EQ(3, obj.as()); - return; - } - - } - } -} - - -// backward compatibility -class event_handler_compat { -public: - event_handler_compat(std::istream& input) : input(input) { } - ~event_handler_compat() { } - - void on_read() - { - while(true) { - pac.reserve_buffer(32*1024); - - size_t len = input.readsome(pac.buffer(), pac.buffer_capacity()); - - if(len == 0) { - return; - } - - pac.buffer_consumed(len); - - while(pac.execute()) { - std::auto_ptr z(pac.release_zone()); - msgpack::object obj = pac.data(); - pac.reset(); - on_message(obj, z); - } - - if(pac.message_size() > 10*1024*1024) { - throw std::runtime_error("message is too large"); - } - } - } - - void on_message(msgpack::object obj, std::auto_ptr z) - { - EXPECT_EQ(expect, obj.as()); - } - - int expect; - -private: - std::istream& input; - msgpack::unpacker pac; -}; - -TEST(streaming, event_compat) -{ - std::stringstream stream; - msgpack::packer pk(&stream); - - event_handler_compat handler(stream); - - pk.pack(1); - handler.expect = 1; - handler.on_read(); - - pk.pack(2); - handler.expect = 2; - handler.on_read(); - - pk.pack(3); - handler.expect = 3; - handler.on_read(); -} - diff --git a/test/streaming.cpp b/test/streaming.cpp new file mode 100644 index 00000000..b9d2199e --- /dev/null +++ b/test/streaming.cpp @@ -0,0 +1,316 @@ +#include +#include +#include + +TEST(streaming, basic) +{ + msgpack::sbuffer buffer; + + msgpack::packer pk(&buffer); + pk.pack(1); + pk.pack(2); + pk.pack(3); + + const char* input = buffer.data(); + const char* const eof = input + buffer.size(); + + msgpack::unpacker pac; + msgpack::unpacked result; + + int count = 0; + while(count < 3) { + pac.reserve_buffer(32*1024); + + // read buffer into pac.buffer() upto + // pac.buffer_capacity() bytes. + size_t len = 1; + memcpy(pac.buffer(), input, len); + input += len; + + pac.buffer_consumed(len); + + while(pac.next(result)) { + msgpack::object obj = result.get(); + switch(count++) { + case 0: + EXPECT_EQ(1, obj.as()); + break; + case 1: + EXPECT_EQ(2, obj.as()); + break; + case 2: + EXPECT_EQ(3, obj.as()); + return; + } + } + + EXPECT_TRUE(input < eof); + } +} + +TEST(streaming, basic_pointer) +{ + msgpack::sbuffer buffer; + + msgpack::packer pk(&buffer); + pk.pack(1); + pk.pack(2); + pk.pack(3); + + const char* input = buffer.data(); + const char* const eof = input + buffer.size(); + + msgpack::unpacker pac; + msgpack::unpacked result; + + int count = 0; + while(count < 3) { + pac.reserve_buffer(32*1024); + + // read buffer into pac.buffer() upto + // pac.buffer_capacity() bytes. + size_t len = 1; + memcpy(pac.buffer(), input, len); + input += len; + + pac.buffer_consumed(len); + + while(pac.next(&result)) { + msgpack::object obj = result.get(); + switch(count++) { + case 0: + EXPECT_EQ(1, obj.as()); + break; + case 1: + EXPECT_EQ(2, obj.as()); + break; + case 2: + EXPECT_EQ(3, obj.as()); + return; + } + } + + EXPECT_TRUE(input < eof); + } +} + +#if !defined(MSGPACK_USE_CPP03) + +TEST(streaming, move) +{ + msgpack::sbuffer buffer; + + msgpack::packer pk(&buffer); + pk.pack(1); + pk.pack(2); + pk.pack(3); + + const char* input = buffer.data(); + const char* const eof = input + buffer.size(); + + msgpack::unpacker pac; + msgpack::unpacked result; + + int count = 0; + while(count < 3) { + msgpack::unpacker pac_in(std::move(pac)); + pac_in.reserve_buffer(32*1024); + + // read buffer into pac_in.buffer() upto + // pac_in.buffer_capac_inity() bytes. + size_t len = 1; + memcpy(pac_in.buffer(), input, len); + input += len; + + pac_in.buffer_consumed(len); + + while(pac_in.next(result)) { + msgpack::object obj = result.get(); + switch(count++) { + case 0: + EXPECT_EQ(1, obj.as()); + break; + case 1: + EXPECT_EQ(2, obj.as()); + break; + case 2: + EXPECT_EQ(3, obj.as()); + return; + } + } + + EXPECT_TRUE(input < eof); + pac = std::move(pac_in); + } +} + +#endif // !defined(MSGPACK_USE_CPP03) + +class event_handler { +public: + event_handler(std::istream& input) : input(input) { } + ~event_handler() { } + + void on_read() + { + while(true) { + pac.reserve_buffer(32*1024); + + size_t len = input.readsome(pac.buffer(), pac.buffer_capacity()); + + if(len == 0) { + return; + } + + pac.buffer_consumed(len); + + msgpack::unpacked result; + while(pac.next(result)) { + on_message(result.get(), msgpack::move(result.zone())); + } + + if(pac.message_size() > 10*1024*1024) { + throw std::runtime_error("message is too large"); + } + } + } + + void on_message(msgpack::object obj, msgpack::unique_ptr) + { + EXPECT_EQ(expect, obj.as()); + } + + int expect; + +private: + std::istream& input; + msgpack::unpacker pac; +}; + +TEST(streaming, event) +{ + std::stringstream stream; + msgpack::packer pk(&stream); + + event_handler handler(stream); + + pk.pack(1); + handler.expect = 1; + handler.on_read(); + + pk.pack(2); + handler.expect = 2; + handler.on_read(); + + pk.pack(3); + handler.expect = 3; + handler.on_read(); +} + + +// backward compatibility +TEST(streaming, basic_compat) +{ + std::ostringstream stream; + msgpack::packer pk(&stream); + + pk.pack(1); + pk.pack(2); + pk.pack(3); + + std::istringstream input(stream.str()); + + msgpack::unpacker pac; + + int count = 0; + while(count < 3) { + pac.reserve_buffer(32*1024); + + size_t len = input.readsome(pac.buffer(), pac.buffer_capacity()); + pac.buffer_consumed(len); + + while(pac.execute()) { + msgpack::unique_ptr z(pac.release_zone()); + msgpack::object obj = pac.data(); + pac.reset(); + + switch(count++) { + case 0: + EXPECT_EQ(1, obj.as()); + break; + case 1: + EXPECT_EQ(2, obj.as()); + break; + case 2: + EXPECT_EQ(3, obj.as()); + return; + } + + } + } +} + + +// backward compatibility +class event_handler_compat { +public: + event_handler_compat(std::istream& input) : input(input) { } + ~event_handler_compat() { } + + void on_read() + { + while(true) { + pac.reserve_buffer(32*1024); + + size_t len = input.readsome(pac.buffer(), pac.buffer_capacity()); + + if(len == 0) { + return; + } + + pac.buffer_consumed(len); + + while(pac.execute()) { + msgpack::unique_ptr z(pac.release_zone()); + msgpack::object obj = pac.data(); + pac.reset(); + on_message(obj, msgpack::move(z)); + } + + if(pac.message_size() > 10*1024*1024) { + throw std::runtime_error("message is too large"); + } + } + } + + void on_message(msgpack::object obj, msgpack::unique_ptr) + { + EXPECT_EQ(expect, obj.as()); + } + + int expect; + +private: + std::istream& input; + msgpack::unpacker pac; +}; + +TEST(streaming, event_compat) +{ + std::stringstream stream; + msgpack::packer pk(&stream); + + event_handler_compat handler(stream); + + pk.pack(1); + handler.expect = 1; + handler.on_read(); + + pk.pack(2); + handler.expect = 2; + handler.on_read(); + + pk.pack(3); + handler.expect = 3; + handler.on_read(); +} diff --git a/test/streaming_c.cc b/test/streaming_c.cc deleted file mode 100644 index 1b7ad8b6..00000000 --- a/test/streaming_c.cc +++ /dev/null @@ -1,98 +0,0 @@ -#include -#include -#include - -TEST(streaming, basic) -{ - msgpack_sbuffer* buffer = msgpack_sbuffer_new(); - - msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write); - - // 1, 2, 3, "raw", ["data"], {0.3: 0.4} - EXPECT_EQ(0, msgpack_pack_int(pk, 1)); - EXPECT_EQ(0, msgpack_pack_int(pk, 2)); - EXPECT_EQ(0, msgpack_pack_int(pk, 3)); - EXPECT_EQ(0, msgpack_pack_raw(pk, 3)); - EXPECT_EQ(0, msgpack_pack_raw_body(pk, "raw", 3)); - EXPECT_EQ(0, msgpack_pack_array(pk, 1)); - EXPECT_EQ(0, msgpack_pack_raw(pk, 4)); - EXPECT_EQ(0, msgpack_pack_raw_body(pk, "data", 4)); - EXPECT_EQ(0, msgpack_pack_map(pk, 1)); - EXPECT_EQ(0, msgpack_pack_float(pk, 0.4)); - EXPECT_EQ(0, msgpack_pack_double(pk, 0.8)); - int max_count = 6; - - msgpack_packer_free(pk); - - const char* input = buffer->data; - const char* const eof = input + buffer->size; - - msgpack_unpacker pac; - msgpack_unpacker_init(&pac, MSGPACK_UNPACKER_INIT_BUFFER_SIZE); - - msgpack_unpacked result; - msgpack_unpacked_init(&result); - - int count = 0; - while(count < max_count) { - bool unpacked = false; - - msgpack_unpacker_reserve_buffer(&pac, 32*1024); - - while(!unpacked) { - /* read buffer into msgpack_unapcker_buffer(&pac) upto - * msgpack_unpacker_buffer_capacity(&pac) bytes. */ - memcpy(msgpack_unpacker_buffer(&pac), input, 1); - input += 1; - - EXPECT_TRUE(input <= eof); - - msgpack_unpacker_buffer_consumed(&pac, 1); - - while(msgpack_unpacker_next(&pac, &result)) { - unpacked = 1; - msgpack_object obj = result.data; - msgpack_object e; - switch(count++) { - case 0: - EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); - EXPECT_EQ(1, obj.via.u64); - break; - case 1: - EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); - EXPECT_EQ(2, obj.via.u64); - break; - case 2: - EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); - EXPECT_EQ(3, obj.via.u64); - break; - case 3: - EXPECT_EQ(MSGPACK_OBJECT_RAW, obj.type); - EXPECT_EQ(std::string("raw",3), std::string(obj.via.raw.ptr, obj.via.raw.size)); - break; - case 4: - EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type); - EXPECT_EQ(1, obj.via.array.size); - e = obj.via.array.ptr[0]; - EXPECT_EQ(MSGPACK_OBJECT_RAW, e.type); - EXPECT_EQ(std::string("data",4), std::string(e.via.raw.ptr, e.via.raw.size)); - break; - case 5: - EXPECT_EQ(MSGPACK_OBJECT_MAP, obj.type); - EXPECT_EQ(1, obj.via.map.size); - e = obj.via.map.ptr[0].key; - EXPECT_EQ(MSGPACK_OBJECT_DOUBLE, e.type); - ASSERT_FLOAT_EQ(0.4, (float)e.via.dec); - e = obj.via.map.ptr[0].val; - EXPECT_EQ(MSGPACK_OBJECT_DOUBLE, e.type); - ASSERT_DOUBLE_EQ(0.8, e.via.dec); - break; - } - } - } - } - - msgpack_unpacker_destroy(&pac); - msgpack_unpacked_destroy(&result); -} - diff --git a/test/streaming_c.cpp b/test/streaming_c.cpp new file mode 100644 index 00000000..34fbfa98 --- /dev/null +++ b/test/streaming_c.cpp @@ -0,0 +1,114 @@ +#include +#include +#include + +TEST(streaming, basic) +{ + msgpack_sbuffer* buffer = msgpack_sbuffer_new(); + + msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write); + + // 1, 2, 3, "str", ["str_data"], "bin", ["bin_data"], {0.3: 0.4} + EXPECT_EQ(0, msgpack_pack_int(pk, 1)); + EXPECT_EQ(0, msgpack_pack_int(pk, 2)); + EXPECT_EQ(0, msgpack_pack_int(pk, 3)); + EXPECT_EQ(0, msgpack_pack_str(pk, 3)); + EXPECT_EQ(0, msgpack_pack_str_body(pk, "str", 3)); + EXPECT_EQ(0, msgpack_pack_array(pk, 1)); + EXPECT_EQ(0, msgpack_pack_str(pk, 8)); + EXPECT_EQ(0, msgpack_pack_str_body(pk, "str_data", 8)); + EXPECT_EQ(0, msgpack_pack_bin(pk, 3)); + EXPECT_EQ(0, msgpack_pack_bin_body(pk, "bin", 3)); + EXPECT_EQ(0, msgpack_pack_array(pk, 1)); + EXPECT_EQ(0, msgpack_pack_bin(pk, 8)); + EXPECT_EQ(0, msgpack_pack_bin_body(pk, "bin_data", 8)); + EXPECT_EQ(0, msgpack_pack_map(pk, 1)); + EXPECT_EQ(0, msgpack_pack_float(pk, 0.4)); + EXPECT_EQ(0, msgpack_pack_double(pk, 0.8)); + int max_count = 6; + + msgpack_packer_free(pk); + + const char* input = buffer->data; + const char* const eof = input + buffer->size; + + msgpack_unpacker pac; + msgpack_unpacker_init(&pac, MSGPACK_UNPACKER_INIT_BUFFER_SIZE); + + msgpack_unpacked result; + msgpack_unpacked_init(&result); + + int count = 0; + while(count < max_count) { + bool unpacked = false; + + msgpack_unpacker_reserve_buffer(&pac, 32*1024); + + while(!unpacked) { + /* read buffer into msgpack_unapcker_buffer(&pac) upto + * msgpack_unpacker_buffer_capacity(&pac) bytes. */ + memcpy(msgpack_unpacker_buffer(&pac), input, 1); + input += 1; + + EXPECT_TRUE(input <= eof); + + msgpack_unpacker_buffer_consumed(&pac, 1); + + while(msgpack_unpacker_next(&pac, &result) == MSGPACK_UNPACK_SUCCESS) { + unpacked = 1; + msgpack_object obj = result.data; + msgpack_object e; + switch(count++) { + case 0: + EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); + EXPECT_EQ(1, obj.via.u64); + break; + case 1: + EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); + EXPECT_EQ(2, obj.via.u64); + break; + case 2: + EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); + EXPECT_EQ(3, obj.via.u64); + break; + case 3: + EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); + EXPECT_EQ(std::string("str",3), std::string(obj.via.str.ptr, obj.via.str.size)); + break; + case 4: + EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type); + EXPECT_EQ(1, obj.via.array.size); + e = obj.via.array.ptr[0]; + EXPECT_EQ(MSGPACK_OBJECT_STR, e.type); + EXPECT_EQ(std::string("str_data",8), std::string(e.via.str.ptr, e.via.str.size)); + break; + case 5: + EXPECT_EQ(MSGPACK_OBJECT_BIN, obj.type); + EXPECT_EQ(std::string("bin",3), std::string(obj.via.bin.ptr, obj.via.bin.size)); + break; + case 6: + EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type); + EXPECT_EQ(1, obj.via.array.size); + e = obj.via.array.ptr[0]; + EXPECT_EQ(MSGPACK_OBJECT_BIN, e.type); + EXPECT_EQ(std::string("bin_data",8), std::string(e.via.bin.ptr, e.via.bin.size)); + break; + case 7: + EXPECT_EQ(MSGPACK_OBJECT_MAP, obj.type); + EXPECT_EQ(1, obj.via.map.size); + e = obj.via.map.ptr[0].key; + EXPECT_EQ(MSGPACK_OBJECT_DOUBLE, e.type); + ASSERT_FLOAT_EQ(0.4, (float)e.via.dec); + e = obj.via.map.ptr[0].val; + EXPECT_EQ(MSGPACK_OBJECT_DOUBLE, e.type); + ASSERT_DOUBLE_EQ(0.8, e.via.dec); + break; + } + } + } + } + + msgpack_unpacker_destroy(&pac); + msgpack_unpacked_destroy(&result); + msgpack_sbuffer_free(buffer); +} diff --git a/test/version.cc b/test/version.cc deleted file mode 100644 index 9357271e..00000000 --- a/test/version.cc +++ /dev/null @@ -1,13 +0,0 @@ -#include -#include - -TEST(version, print) -{ - printf("MSGPACK_VERSION : %s\n", MSGPACK_VERSION); - printf("MSGPACK_VERSION_MAJOR : %d\n", MSGPACK_VERSION_MAJOR); - printf("MSGPACK_VERSION_MINOR : %d\n", MSGPACK_VERSION_MINOR); - printf("msgpack_version() : %s\n", msgpack_version()); - printf("msgpack_version_major() : %d\n", msgpack_version_major()); - printf("msgpack_version_minor() : %d\n", msgpack_version_minor()); -} - diff --git a/test/version.cpp b/test/version.cpp new file mode 100644 index 00000000..6bb39018 --- /dev/null +++ b/test/version.cpp @@ -0,0 +1,14 @@ +#include +#include + +TEST(version, print) +{ + printf("MSGPACK_VERSION : %s\n", MSGPACK_VERSION); + printf("MSGPACK_VERSION_MAJOR : %d\n", MSGPACK_VERSION_MAJOR); + printf("MSGPACK_VERSION_MINOR : %d\n", MSGPACK_VERSION_MINOR); + printf("MSGPACK_VERSION_REVISION : %d\n", MSGPACK_VERSION_REVISION); + printf("msgpack_version() : %s\n", msgpack_version()); + printf("msgpack_version_major() : %d\n", msgpack_version_major()); + printf("msgpack_version_minor() : %d\n", msgpack_version_minor()); + printf("msgpack_version_revision() : %d\n", msgpack_version_revision()); +} diff --git a/test/zone.cc b/test/zone.cc deleted file mode 100644 index 5274e9f0..00000000 --- a/test/zone.cc +++ /dev/null @@ -1,78 +0,0 @@ -#include -#include - -TEST(zone, malloc) -{ - msgpack::zone z; - char* buf1 = (char*)z.malloc(4); - memcpy(buf1, "test", 4); - char* buf2 = (char*)z.malloc(4); - memcpy(buf2, "test", 4); -} - - -class myclass { -public: - myclass() : num(0), str("default") { } - - myclass(int num, const std::string& str) : - num(num), str(str) { } - - ~myclass() { } - - int num; - std::string str; - -private: - myclass(const myclass&); -}; - - -TEST(zone, allocate) -{ - msgpack::zone z; - myclass* m = z.allocate(); - EXPECT_EQ(m->num, 0); - EXPECT_EQ(m->str, "default"); -} - - -TEST(zone, allocate_constructor) -{ - msgpack::zone z; - myclass* m = z.allocate(7, "msgpack"); - EXPECT_EQ(m->num, 7); - EXPECT_EQ(m->str, "msgpack"); -} - - -static void custom_finalizer_func(void* user) -{ - myclass* m = (myclass*)user; - delete m; -} - -TEST(zone, push_finalizer) -{ - msgpack::zone z; - myclass* m = new myclass(); - z.push_finalizer(custom_finalizer_func, (void*)m); -} - - -TEST(zone, push_finalizer_auto_ptr) -{ - msgpack::zone z; - std::auto_ptr am(new myclass()); - z.push_finalizer(am); -} - - -TEST(zone, malloc_no_align) -{ - msgpack::zone z; - char* buf1 = (char*)z.malloc_no_align(4); - char* buf2 = (char*)z.malloc_no_align(4); - EXPECT_EQ(buf1+4, buf2); -} - diff --git a/test/zone.cpp b/test/zone.cpp new file mode 100644 index 00000000..b2dc543e --- /dev/null +++ b/test/zone.cpp @@ -0,0 +1,78 @@ +#include +#include + +TEST(zone, allocate_align) +{ + msgpack::zone z; + char* buf1 = (char*)z.allocate_align(4); + memcpy(buf1, "test", 4); + char* buf2 = (char*)z.allocate_align(4); + memcpy(buf2, "test", 4); +} + + +class myclass { +public: + myclass() : num(0), str("default") { } + + myclass(int num, const std::string& str) : + num(num), str(str) { } + + ~myclass() { } + + int num; + std::string str; + +private: + myclass(const myclass&); +}; + + +TEST(zone, allocate) +{ + msgpack::zone z; + myclass* m = z.allocate(); + EXPECT_EQ(m->num, 0); + EXPECT_EQ(m->str, "default"); +} + + +TEST(zone, allocate_constructor) +{ + msgpack::zone z; + myclass* m = z.allocate(7, "msgpack"); + EXPECT_EQ(m->num, 7); + EXPECT_EQ(m->str, "msgpack"); +} + + +static void custom_finalizer_func(void* user) +{ + myclass* m = (myclass*)user; + delete m; +} + +TEST(zone, push_finalizer) +{ + msgpack::zone z; + myclass* m = new myclass(); + z.push_finalizer(custom_finalizer_func, (void*)m); +} + + +TEST(zone, push_finalizer_unique_ptr) +{ + msgpack::zone z; + msgpack::unique_ptr am(new myclass()); + z.push_finalizer(msgpack::move(am)); +} + + +TEST(zone, allocate_no_align) +{ + msgpack::zone z; + char* buf1 = (char*)z.allocate_no_align(4); + char* buf2 = (char*)z.allocate_no_align(4); + EXPECT_EQ(buf1+4, buf2); +} +