Merge pull request #384 from jpetso/jpetso_refwrap

Support to-object conversions for std::reference_wrapper<const T>.

.gitmodules

@@ -0,0 +1,6 @@
+[submodule "external/boost/predef"]
+	path = external/boost/predef
+	url = https://github.com/boostorg/predef.git
+[submodule "external/boost/preprocessor"]
+	path = external/boost/preprocessor
+	url = https://github.com/boostorg/preprocessor.git

.travis.yml

@@ -1,34 +1,91 @@
 language: cpp
+os:
+  - linux
+  - osx
 cache:
   - apt
 compiler:
   - clang
   - gcc
+os:
+  - osx
+  - linux
 before_install:
-  - 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
+  - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test; fi
+  - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo add-apt-repository -y ppa:h-rayflood/llvm-upper; fi
+  - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo apt-get update -qq; fi
+  - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo apt-get update; fi
 install:
-  - 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
+  - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo apt-get install -qq gcc-4.8-multilib g++-4.8-multilib; fi
+  - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo apt-get install --allow-unauthenticated -qq clang-3.6; fi
+  - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.8 90; fi
+  - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.8 90; fi
+  - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo apt-get install -y lib32gcc1; fi
+  - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo apt-get install -y libc6-i386; fi
+  - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo apt-get install -y lib32z1-dev; fi
+  - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo apt-get install -y lib32stdc++6; fi
+  - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo apt-get install -y bzip2; fi
+  - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo apt-get install -y libc6-dbg; fi
   - 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 ..
+  - wget http://valgrind.org/downloads/valgrind-3.10.1.tar.bz2 && tar xjf valgrind-3.10.1.tar.bz2 && cd valgrind-3.10.1 && ./configure && make && sudo make install && cd ..
+
+  - if [ "$TRAVIS_OS_NAME" == "osx" ]; then brew unlink boost; fi
+  - if [ "$BOOST" == "boost" ]; then wget http://sourceforge.net/projects/boost/files/boost/1.58.0/boost_1_58_0.zip && unzip -q boost_1_58_0.zip && cd boost_1_58_0 && ./bootstrap.sh && ./b2 --with-timer --with-chrono address-model="$ARCH" > /dev/null && sudo ./b2 --with-timer --with-chrono address-model="$ARCH" install > /dev/null && cd ..; fi
+
+  - if [ "$TRAVIS_OS_NAME" == "linux" ]; then unzip -q 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 ..; fi
+  - if [ "$TRAVIS_OS_NAME" == "osx" ]; then unzip -q gtest-1.7.0.zip && cd gtest-1.7.0 && sudo cp -r include/gtest /usr/local/include && clang++ 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 && cd ..; fi
+
 env:
-  - 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"
+  - ACTION="ci/build_autotools.sh" VERSION="cpp03" ARCH="64" LIBPATH="/usr/local/lib"   BOOST="boost" BOOST_INC="/usr/local/boost"
+  - ACTION="ci/build_autotools.sh" VERSION="cpp03" ARCH="32" LIBPATH="/usr/local/lib32" BOOST=""      BOOST_INC=""
+  - ACTION="ci/build_cmake.sh"     VERSION="cpp11" ARCH="64" LIBPATH="/usr/local/lib"   BOOST="boost" BOOST_INC="/usr/local/boost"
+  - ACTION="ci/build_cmake.sh"     VERSION="cpp11" ARCH="32" LIBPATH="/usr/local/lib32" BOOST=""      BOOST_INC=""                 SHARED="OFF"
+  - ACTION="ci/build_autotools.sh" VERSION="cpp11" ARCH="64" LIBPATH="/usr/local/lib"   BOOST=""      BOOST_INC=""
+  - ACTION="ci/build_autotools.sh" VERSION="cpp11" ARCH="32" LIBPATH="/usr/local/lib32" BOOST="boost" BOOST_INC="/usr/local/boost"
+  - ACTION="ci/build_cmake.sh"     VERSION="cpp03" ARCH="64" LIBPATH="/usr/local/lib"   BOOST=""      BOOST_INC=""
+  - ACTION="ci/build_cmake.sh"     VERSION="cpp03" ARCH="32" LIBPATH="/usr/local/lib32" BOOST="boost" BOOST_INC="/usr/local/boost" SHARED="OFF"
+
+before_script:
+ - export PATH=/usr/local/bin:$PATH && rm -rf install
+
+matrix:
+  exclude:
+    - os: osx
+      compiler: gcc
+    - os: osx
+      env: ACTION="ci/build_autotools.sh" VERSION="cpp03" ARCH="32" LIBPATH="/usr/local/lib32" BOOST=""      BOOST_INC=""
+    - os: osx
+      env: ACTION="ci/build_cmake.sh"     VERSION="cpp11" ARCH="32" LIBPATH="/usr/local/lib32" BOOST=""      BOOST_INC=""                 SHARED="OFF"
+    - os: osx
+      env: ACTION="ci/build_autotools.sh" VERSION="cpp11" ARCH="32" LIBPATH="/usr/local/lib32" BOOST="boost" BOOST_INC="/usr/local/boost"
+    - os: osx
+      env: ACTION="ci/build_cmake.sh"     VERSION="cpp03" ARCH="32" LIBPATH="/usr/local/lib32" BOOST="boost" BOOST_INC="/usr/local/boost" SHARED="OFF"
+
+    - os: linux
+      compiler: gcc
+      env: ACTION="ci/build_autotools.sh" VERSION="cpp03" ARCH="64" LIBPATH="/usr/local/lib"   BOOST="boost" BOOST_INC="/usr/local/boost"
+    - os: linux
+      compiler: gcc
+      env: ACTION="ci/build_autotools.sh" VERSION="cpp03" ARCH="32" LIBPATH="/usr/local/lib32" BOOST=""      BOOST_INC=""
+    - os: linux
+      compiler: gcc
+      env: ACTION="ci/build_cmake.sh"     VERSION="cpp11" ARCH="64" LIBPATH="/usr/local/lib"   BOOST="boost" BOOST_INC="/usr/local/boost"
+    - os: linux
+      compiler: gcc
+      env: ACTION="ci/build_cmake.sh"     VERSION="cpp11" ARCH="32" LIBPATH="/usr/local/lib32" BOOST=""      BOOST_INC=""                 SHARED="OFF"
+
+    - os: linux
+      compiler: clang
+      env: ACTION="ci/build_autotools.sh" VERSION="cpp11" ARCH="64" LIBPATH="/usr/local/lib"   BOOST=""      BOOST_INC=""
+    - os: linux
+      compiler: clang
+      env: ACTION="ci/build_autotools.sh" VERSION="cpp11" ARCH="32" LIBPATH="/usr/local/lib32" BOOST="boost" BOOST_INC="/usr/local/boost"
+    - os: linux
+      compiler: clang
+      env: ACTION="ci/build_cmake.sh"     VERSION="cpp03" ARCH="64" LIBPATH="/usr/local/lib"   BOOST=""      BOOST_INC=""
+    - os: linux
+      compiler: clang
+      env: ACTION="ci/build_cmake.sh"     VERSION="cpp03" ARCH="32" LIBPATH="/usr/local/lib32" BOOST="boost" BOOST_INC="/usr/local/boost" SHARED="OFF"
 
 script:
-  - git clean -xdf && CMAKE_LIBRARY_PATH=${LIBPATH} ${ACTION} ${VERSION} ${ARCH}
+  - git clean -xdf && CMAKE_LIBRARY_PATH=${LIBPATH} ${ACTION} ${VERSION} ${ARCH} ${BOOST} ${BOOST_INC}

CHANGELOG.md

@@ -1,3 +1,46 @@
+2015-09-04 version 1.2.0
+  << breaking change >>
+  * Change std::vector<unsigned char> and std::array<unsigned char>
+    mapped to BIN instead of ARRAY (#243)
+  * Remove redundant copy (#285)
+
+  * Add array_ref to map to ARRAY (#243)
+  * Add variant type and adaptor (#349)
+  * Add object::convert_if_not_nil() (#357)
+  * Fix invalid offset update (#354)
+  * Add C++11 support on MSVC2015(#339, #347)
+  * Fix and Improve build system (#346, #350, #361, #363)
+  * Import Boost.Preprocessor as a part of msgpack-c (#312)
+  * Fix OSX with libc++ specific errors (#334, #362)
+  * Add customized containers support (#330)
+  * Add std::unique_ptr and std::shared_ptr support (#329)
+  * Add missing install files (#328)
+  * Add shared/static library switching option (#316)
+  * Improve no throw description on C++11 (#313)
+  * Import Boost.Predef as a part of msgpack-c (#312)
+  * Add map based serialize support (#306)
+  * Add Boost.Fusion support (#305)
+  * Add v4 format RAW support (#304)
+  * Fix zbuffer with empty string problem (#303)
+  * Add non default constructible class support (#302, #324, #327, #331, #332, #345)
+  * Add inline keyword to function (template) (#299)
+  * Add EXT type supporting classes (#292, #308)
+  * Fix raw_ref != comparison (#290)
+  * Add object deep copy (#288)
+  * Remove some warnings (#284, #322, #323, #335)
+  * Improve compiler version checking (#283)
+  * Add return value to object::convert() (#282)
+  * Improve move semantic support in C++11 (#279, #353)
+  * Add Boost.StringRef support (#278)
+  * Improve CI environment (#276, #294, #338)
+  * Add converting to JSON (#274, #301)
+  * Fix iOS specific problem (#270)
+  * Improve doxtgen document generation (#269)
+  * Add Boost.Optional support (#268)
+  * Fix msvc specific problem (#267, #295)
+  * Add base class serialization. (#265, #277)
+  * Add and improve examples. (#264, #310, #311, #341, #342, #344)
+  * Fix wiki URL. (#263)
 2015-04-03 version 1.1.0
   << breaking change >>
   * Remove msgpack_fwd.hpp
@@ -116,4 +159,3 @@
   * Add operator==(object, const T&)
   * MSGPACK_DEFINE macro defines msgpack_object(object* obj, zone* z)
   * C++ programs doesn't need to link "msgpackc" library.
-

CMakeLists.txt

@@ -17,6 +17,19 @@ SET (includedir "\${prefix}/include")
 
 OPTION (MSGPACK_CXX11 "Using c++11 compiler" OFF)
 OPTION (MSGPACK_32BIT "32bit compile" OFF)
+OPTION (MSGPACK_BOOST "Using boost libraries" OFF)
+
+IF (APPLE)
+    SET(CMAKE_MACOSX_RPATH ON)
+    SET(CMAKE_SKIP_BUILD_RPATH FALSE)
+    SET(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)
+    SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
+    SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
+    LIST(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${CMAKE_INSTALL_PREFIX}/lib" isSystemDir)
+    IF ("${isSystemDir}" STREQUAL "-1")
+        SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
+    ENDIF ()
+ENDIF ()
 
 IF (MSGPACK_CXX11)
    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
@@ -24,7 +37,19 @@ IF (MSGPACK_CXX11)
    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.")
+      IF (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19)
+          MESSAGE ( FATAL_ERROR "MSVC doesn't support C++11.")
+      ENDIF ()
+   ENDIF ()
+ELSE ()
+   IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+      SET (CMAKE_CXX_FLAGS "-std=c++03 ${CMAKE_CXX_FLAGS}")
+   ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+      SET (CMAKE_CXX_FLAGS "-std=c++03 ${CMAKE_CXX_FLAGS}")
+   ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+      IF (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 18)
+          SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_CPP03 ${CMAKE_CXX_FLAGS}")
+      ENDIF ()
    ENDIF ()
 ENDIF ()
 
@@ -40,14 +65,47 @@ IF (MSGPACK_32BIT)
    ENDIF ()
 ENDIF ()
 
+IF (MSGPACK_BOOST)
+   SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_BOOST ${CMAKE_CXX_FLAGS}")
+   SET (Boost_USE_STATIC_LIBS        ON) # only find static libs
+   SET (Boost_USE_MULTITHREADED      ON)
+   SET (Boost_USE_STATIC_RUNTIME    OFF)
+   FIND_PACKAGE (Boost COMPONENTS chrono timer system)
+   INCLUDE_DIRECTORIES (
+       ${MSGPACK_BOOST_DIR}
+   )
+ENDIF ()
+
+FILE (GLOB_RECURSE PREDEF_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/external/boost/predef/include/boost ${CMAKE_CURRENT_SOURCE_DIR}/external/boost/predef/include/boost/*.h)
+FOREACH (F ${PREDEF_FILES})
+   SET(M "Converting ${F}")
+   MESSAGE(STATUS ${M})
+   FILE (READ ${CMAKE_CURRENT_SOURCE_DIR}/external/boost/predef/include/boost/${F} CONTENT)
+   STRING(REPLACE "BOOST_" "MSGPACK_" CONTENT ${CONTENT})
+   STRING(REPLACE "boost/" "msgpack/" CONTENT ${CONTENT})
+   FILE (WRITE ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/${F} ${CONTENT})
+ENDFOREACH ()
+
+FILE (GLOB_RECURSE PREPROCESSOR_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/external/boost/preprocessor/include/boost ${CMAKE_CURRENT_SOURCE_DIR}/external/boost/preprocessor/include/boost/*.hpp)
+FOREACH (F ${PREPROCESSOR_FILES})
+   SET(M "Converting ${F}")
+   MESSAGE(STATUS ${M})
+   FILE (READ ${CMAKE_CURRENT_SOURCE_DIR}/external/boost/preprocessor/include/boost/${F} CONTENT)
+   STRING(REPLACE "BOOST_" "MSGPACK_" CONTENT ${CONTENT})
+   STRING(REPLACE "boost/" "msgpack/" CONTENT ${CONTENT})
+   FILE (WRITE ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/${F} ${CONTENT})
+ENDFOREACH ()
+
 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)
 ENDIF ()
+OPTION (MSGPACK_BUILD_EXAMPLES "Build msgpack examples." ON)
 
 OPTION (MSGPACK_ENABLE_CXX "Enable C++ interface." ON)
+OPTION (MSGPACK_ENABLE_SHARED "Build shared libaries in addition to static libraries." ON)
 
 INCLUDE (CheckCXXSourceCompiles)
 CHECK_CXX_SOURCE_COMPILES ("
@@ -84,8 +142,10 @@ LIST (APPEND msgpack_HEADERS
     include/msgpack/util.h
     include/msgpack/sysdep.h
     include/msgpack/gcc_atomic.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
@@ -95,25 +155,42 @@ LIST (APPEND msgpack_HEADERS
     include/msgpack/zone.h
 )
 
+FILE (GLOB_RECURSE PREDEF_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/predef/*.h)
+
+LIST (APPEND msgpack_HEADERS ${PREDEF_FILES})
+LIST (APPEND msgpack_HEADERS include/msgpack/predef.h)
+
 IF (MSGPACK_ENABLE_CXX)
     LIST (APPEND msgpack_HEADERS
         include/msgpack.hpp
         include/msgpack/adaptor/adaptor_base.hpp
+        include/msgpack/adaptor/array_ref.hpp
         include/msgpack/adaptor/bool.hpp
+        include/msgpack/adaptor/boost/fusion.hpp
+        include/msgpack/adaptor/boost/msgpack_variant.hpp
+        include/msgpack/adaptor/boost/optional.hpp
+        include/msgpack/adaptor/boost/string_ref.hpp
         include/msgpack/adaptor/char_ptr.hpp
         include/msgpack/adaptor/check_container_size.hpp
         include/msgpack/adaptor/cpp11/array.hpp
         include/msgpack/adaptor/cpp11/array_char.hpp
+        include/msgpack/adaptor/cpp11/array_unsigned_char.hpp
         include/msgpack/adaptor/cpp11/forward_list.hpp
+        include/msgpack/adaptor/cpp11/reference_wrapper.hpp
+        include/msgpack/adaptor/cpp11/shared_ptr.hpp
         include/msgpack/adaptor/cpp11/tuple.hpp
+        include/msgpack/adaptor/cpp11/unique_ptr.hpp
         include/msgpack/adaptor/cpp11/unordered_map.hpp
         include/msgpack/adaptor/cpp11/unordered_set.hpp
         include/msgpack/adaptor/define.hpp
         include/msgpack/adaptor/deque.hpp
-        include/msgpack/adaptor/detail/cpp03_define.hpp
+        include/msgpack/adaptor/detail/cpp03_define_array.hpp
+        include/msgpack/adaptor/detail/cpp03_define_map.hpp
         include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp
-        include/msgpack/adaptor/detail/cpp11_define.hpp
+        include/msgpack/adaptor/detail/cpp11_define_array.hpp
+        include/msgpack/adaptor/detail/cpp11_define_map.hpp
         include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp
+        include/msgpack/adaptor/ext.hpp
         include/msgpack/adaptor/fixint.hpp
         include/msgpack/adaptor/float.hpp
         include/msgpack/adaptor/int.hpp
@@ -123,6 +200,7 @@ IF (MSGPACK_ENABLE_CXX)
         include/msgpack/adaptor/nil.hpp
         include/msgpack/adaptor/pair.hpp
         include/msgpack/adaptor/raw.hpp
+        include/msgpack/adaptor/v4raw.hpp
         include/msgpack/adaptor/set.hpp
         include/msgpack/adaptor/string.hpp
         include/msgpack/adaptor/tr1/unordered_map.hpp
@@ -130,10 +208,13 @@ IF (MSGPACK_ENABLE_CXX)
         include/msgpack/adaptor/vector.hpp
         include/msgpack/adaptor/vector_bool.hpp
         include/msgpack/adaptor/vector_char.hpp
+        include/msgpack/adaptor/vector_unsigned_char.hpp
         include/msgpack/cpp_config.hpp
         include/msgpack/detail/cpp03_zone.hpp
         include/msgpack/detail/cpp11_zone.hpp
         include/msgpack/fbuffer.hpp
+        include/msgpack/iterator.hpp
+        include/msgpack/meta.hpp
         include/msgpack/object.hpp
         include/msgpack/object_fwd.hpp
         include/msgpack/pack.hpp
@@ -146,6 +227,10 @@ IF (MSGPACK_ENABLE_CXX)
         include/msgpack/zbuffer.hpp
         include/msgpack/zone.hpp
     )
+    FILE (GLOB_RECURSE PREPROCESSOR_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/preprocessor/*.hpp)
+
+    LIST (APPEND msgpack_HEADERS ${PREPROCESSOR_FILES})
+    LIST (APPEND msgpack_HEADERS include/msgpack/preprocessor.hpp)
 ENDIF ()
 
 EXECUTE_PROCESS (
@@ -164,10 +249,12 @@ INCLUDE_DIRECTORIES (
     ${CMAKE_CURRENT_BINARY_DIR}/include/
 )
 
+IF (MSGPACK_ENABLE_SHARED)
     ADD_LIBRARY (msgpack SHARED
         ${msgpack_SOURCES}
         ${msgpack_HEADERS}
     )
+ENDIF ()
 
 ADD_LIBRARY (msgpack-static STATIC
     ${msgpack_SOURCES}
@@ -175,26 +262,31 @@ ADD_LIBRARY (msgpack-static STATIC
 )
 
 SET_TARGET_PROPERTIES (msgpack-static PROPERTIES OUTPUT_NAME "msgpack")
+IF (MSGPACK_ENABLE_SHARED)
     SET_TARGET_PROPERTIES (msgpack PROPERTIES IMPORT_SUFFIX "_import.lib")
     SET_TARGET_PROPERTIES (msgpack PROPERTIES SOVERSION 3 VERSION 4.0.0)
+ENDIF ()
 
 IF (MSGPACK_BUILD_TESTS)
     ENABLE_TESTING ()
-    SET(CTEST_MEMORYCHECK_COMMAND "/usr/bin/valgrind")
+    # MEMORYCHECK_COMMAND_OPTIONS needs to place prior to CTEST_MEMORYCHECK_COMMAND
+    SET (MEMORYCHECK_COMMAND_OPTIONS "--leak-check=full --show-leak-kinds=definite,possible --error-exitcode=1")
+    FIND_PROGRAM(CTEST_MEMORYCHECK_COMMAND NAMES 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" )
+    IF (MSGPACK_ENABLE_SHARED)
+        SET_PROPERTY (TARGET msgpack APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Wno-mismatched-tags -Werror -g -O3 -DPIC")
+    ENDIF ()
+    SET_PROPERTY (TARGET msgpack-static APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Wno-mismatched-tags -Werror -g -O3" )
 ENDIF ()
 IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
     IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
-        STRING(REGEX REPLACE "/W[0-4]" "/W3" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+        STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
     ELSE ()
-        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3")
+        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
     ENDIF ()
 ENDIF ()
 
@@ -206,31 +298,59 @@ IF (NOT DEFINED CMAKE_INSTALL_LIBDIR)
     SET(CMAKE_INSTALL_LIBDIR lib)
 ENDIF ()
 
-INSTALL (TARGETS msgpack msgpack-static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+IF (MSGPACK_BUILD_EXAMPLES)
+    ADD_SUBDIRECTORY (example)
+ENDIF ()
+
+IF (MSGPACK_ENABLE_SHARED)
+    SET (MSGPACK_INSTALLTARGETS msgpack msgpack-static)
+ELSE()
+    SET (MSGPACK_INSTALLTARGETS msgpack-static)
+ENDIF ()
+
+INSTALL (TARGETS ${MSGPACK_INSTALLTARGETS} DESTINATION ${CMAKE_INSTALL_LIBDIR})
 INSTALL (DIRECTORY include DESTINATION ${CMAKE_INSTALL_PREFIX})
+IF (NOT MSVC)
     INSTALL (FILES ${CMAKE_CURRENT_BINARY_DIR}/msgpack.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+ENDIF ()
 
 # Doxygen
 FIND_PACKAGE (Doxygen)
 IF (DOXYGEN_FOUND)
-    ADD_CUSTOM_TARGET (
-        doxygen_c
+    LIST (APPEND Doxyfile_c_CONTENT
         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 "INPUT              = ${CMAKE_CURRENT_SOURCE_DIR}/include" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c
         COMMAND ${CMAKE_COMMAND} -E echo "EXTRACT_ALL        = YES" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c
         COMMAND ${CMAKE_COMMAND} -E echo "PROJECT_NAME       = \"MessagePack for C\"" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c
+    )
+    IF (DOXYGEN_DOT_FOUND)
+        LIST (APPEND Doxyfile_c_CONTENT
+            COMMAND ${CMAKE_COMMAND} -E echo "HAVE_DOT       = YES" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c
+        )
+    ENDIF ()
+    ADD_CUSTOM_TARGET (
+        doxygen_c
+        ${Doxyfile_c_CONTENT}
         COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c
         VERBATIM
     )
-    ADD_CUSTOM_TARGET (
-        doxygen_cpp
+    LIST (APPEND Doxyfile_cpp_CONTENT
         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 "INPUT              = ${CMAKE_CURRENT_SOURCE_DIR}/include" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp
         COMMAND ${CMAKE_COMMAND} -E echo "EXTRACT_ALL        = YES" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp
+    )
+    IF (DOXYGEN_DOT_FOUND)
+        LIST (APPEND Doxyfile_cpp_CONTENT
+            COMMAND ${CMAKE_COMMAND} -E echo "HAVE_DOT       = YES" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp
+        )
+    ENDIF ()
+    ADD_CUSTOM_TARGET (
+        doxygen_cpp
+        ${Doxyfile_cpp_CONTENT}
         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

Makefile.am

@@ -5,11 +5,10 @@ DOC_FILES = \
 		LICENSE \
 		NOTICE \
 		msgpack_vc8.vcproj \
-		msgpack_vc8.sln \
-		msgpack_vc.postbuild.bat
+		msgpack_vc8.sln
 
 EXTRA_DIST = \
-		$(DOC_FILES) CMakeLists.txt test/CMakeLists.txt
+		$(DOC_FILES) CMakeLists.txt test/CMakeLists.txt example
 
 pkgconfigdir = $(libdir)/pkgconfig
 pkgconfig_DATA = msgpack.pc
@@ -18,4 +17,3 @@ doxygen:
 	./preprocess clean
 	cd src && $(MAKE) doxygen
 	./preprocess
-

NOTICE

@@ -0,0 +1,36 @@
+This product bundles Boost Predef, which is available under a
+Boost Software License - Version 1.0.  For details, see the following files
+
+external/boost/predef
+include/msgpack/predef.h
+include/msgpack/predef/*
+
+external/boost/preprocessor
+include/msgpack/preprocessor.hpp
+include/msgpack/preprocessor/*
+
+---------------------------------------------------------------------------
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+---------------------------------------------------------------------------

README.md

@@ -1,7 +1,7 @@
 `msgpack` for C/C++
 ===================
 
-Version 1.1.0 [![Build Status](https://travis-ci.org/msgpack/msgpack-c.svg?branch=master)](https://travis-ci.org/msgpack/msgpack-c)
+Version 1.2.0 [![Build Status](https://travis-ci.org/msgpack/msgpack-c.svg?branch=master)](https://travis-ci.org/msgpack/msgpack-c) [![Build status](https://ci.appveyor.com/api/projects/status/8kstcgt79qj123mw/branch/master?svg=true)](https://ci.appveyor.com/project/redboltz/msgpack-c/branch/master)
 
 It's like JSON but small and fast.
 

appveyor.yml

@@ -0,0 +1,42 @@
+version: 1.1.0.{build}
+before_build:
+- appveyor DownloadFile http://googletest.googlecode.com/files/gtest-1.7.0.zip -FileName gtest-1.7.0.zip
+- 7z x gtest-1.7.0.zip > NUL
+- cd gtest-1.7.0
+- md build
+- cd build
+- cmake -DBUILD_SHARED_LIBS=ON ..
+- cmake --build . --config Release
+- cd ..
+- cd ..
+- appveyor DownloadFile http://zlib.net/zlib-1.2.8.tar.gz -FileName zlib-1.2.8.tar.gz
+- 7z x zlib-1.2.8.tar.gz > NUL
+- 7z x zlib-1.2.8.tar > NUL
+- cd zlib-1.2.8
+- md build
+- cd build
+- cmake ..
+- cmake --build . --config Release
+- copy zconf.h ..
+- cd ..
+- cd ..
+
+environment:
+  matrix:
+    - cpp11: -DMSGPACK_CXX11=ON
+      boost: -DMSGPACK_BOOST=ON
+    - cpp11: -DMSGPACK_CXX11=OFF
+      boost: -DMSGPACK_BOOST=ON
+    - cpp11: -DMSGPACK_CXX11=ON
+      boost: -DMSGPACK_BOOST=OFF
+    - cpp11: -DMSGPACK_CXX11=OFF
+      boost: -DMSGPACK_BOOST=OFF
+build_script:
+- md build
+- cd build
+- cmake %cpp11% %boost% -DMSGPACK_BOOST_DIR=C:\Libraries\\boost_1_58_0 -DGTEST_LIBRARY=%APPVEYOR_BUILD_FOLDER%\gtest-1.7.0\build\Release\gtest.lib -DGTEST_MAIN_LIBRARY=%APPVEYOR_BUILD_FOLDER%\gtest-1.7.0\build\Release\gtest_main.lib -DGTEST_INCLUDE_DIR=%APPVEYOR_BUILD_FOLDER%\gtest-1.7.0\include -DZLIB_LIBRARY=%APPVEYOR_BUILD_FOLDER%\zlib-1.2.8\build\Release\zlib.lib -DZLIB_INCLUDE_DIR=%APPVEYOR_BUILD_FOLDER%\zlib-1.2.8 ..
+- cmake --build . --config Release
+
+test_script:
+- set PATH=%PATH%;%APPVEYOR_BUILD_FOLDER%\gtest-1.7.0\build\Release;%APPVEYOR_BUILD_FOLDER%\zlib-1.2.8\build\Release;%APPVEYOR_BUILD_FOLDER%\build\release
+- ctest -V

ci/build_autotools.sh

@@ -9,21 +9,27 @@ fi
 
 if [ $1 = "cpp11" ]
 then
+    cpp11="-std=c++11"
+else
+    cpp11=""
+fi
+
 if [ $2 = "32" ]
 then
-        ./configure CFLAGS="-m32" CXXFLAGS="-std=c++11 -m32"
+    bit32="-m32"
 else
-        ./configure CXXFLAGS="-std=c++11"
+    bit32=""
 fi
-else
-    if [ $2 = "32" ]
+
+if [ $3 = "boost" ]
 then
-        ./configure CFLAGS="-m32" CXXFLAGS="-m32"
+    boost="-DMSGPACK_USE_BOOST"
 else
-        ./configure
-    fi
+    boost=""
 fi
 
+./configure CFLAGS="$bit32" CXXFLAGS="$bit32 $cpp11 $boost -I$4"
+
 ret=$?
 if [ $ret -ne 0 ]
 then
@@ -46,7 +52,7 @@ then
     exit $ret
 fi
 
-make install DESTDIR=`pwd`/install
+make install DESTDIR=`pwd`/build/install
 
 ret=$?
 if [ $ret -ne 0 ]

ci/build_cmake.sh

@@ -18,21 +18,41 @@ fi
 
 if [ $1 = "cpp11" ]
 then
+    cpp11="-DMSGPACK_CXX11=ON"
+else
+    cpp11=""
+fi
+
 if [ $2 = "32" ]
 then
-        cmake -DMSGPACK_CXX11=ON -DMSGPACK_32BIT=ON ..
+    bit32="-DMSGPACK_32BIT=ON"
 else
-        cmake -DMSGPACK_CXX11=ON ..
+    bit32=""
 fi
-else
-    if [ $2 = "32" ]
+
+if [ $3 = "boost" ]
 then
-        cmake -DMSGPACK_32BIT=ON ..
+    boost="-DMSGPACK_BOOST=ON"
 else
-        cmake ..
+    boost=""
 fi
+
+if [ "$4" != "" ]
+then
+    boost_dir="-DMSGPACK_BOOST_DIR=$4"
+else
+    boost_dir=""
 fi
 
+if [ "$5" = "OFF" ]
+then
+    shared="-DMSGPACK_ENABLE_SHARED=OFF"
+else
+    shared=""
+fi
+
+cmake $cpp11 $bit32 $boost $boost_dir $shared ..
+
 ret=$?
 if [ $ret -ne 0 ]
 then
@@ -63,7 +83,7 @@ then
     exit $ret
 fi
 
-if [ $2 != "32" ]
+if [ "$2" != "32" ]
 then
     ctest -T memcheck | tee memcheck.log
 

configure.in

@@ -3,10 +3,10 @@ AC_CONFIG_AUX_DIR(ac)
 AM_INIT_AUTOMAKE
 AC_CONFIG_HEADER(config.h)
 AC_SUBST(CFLAGS)
-CFLAGS="-O3 -Wall $CFLAGS"
+CFLAGS="-O3 -Wall -Wextra -Werror $CFLAGS"
 
 AC_SUBST(CXXFLAGS)
-CXXFLAGS="-O3 -Wall $CXXFLAGS"
+CXXFLAGS="-O3 -Wall -Wextra -Wno-mismatched-tags -Werror $CXXFLAGS"
 
 
 AC_PROG_CC

erb/cpp03_define_array.hpp.erb

@@ -15,30 +15,32 @@
 //    See the License for the specific language governing permissions and
 //    limitations under the License.
 //
-#ifndef MSGPACK_CPP03_DEFINE_HPP
-#define MSGPACK_CPP03_DEFINE_HPP
+#ifndef MSGPACK_CPP03_DEFINE_ARRAY_HPP
+#define MSGPACK_CPP03_DEFINE_ARRAY_HPP
 
 #include "msgpack/versioning.hpp"
 #include "msgpack/adaptor/msgpack_tuple.hpp"
 #include "msgpack/adaptor/adaptor_base.hpp"
 #include "msgpack/object_fwd.hpp"
 
-#define MSGPACK_DEFINE(...) \
+#define MSGPACK_DEFINE_ARRAY(...) \
     template <typename Packer> \
     void msgpack_pack(Packer& pk) const \
     { \
-        msgpack::type::make_define(__VA_ARGS__).msgpack_pack(pk); \
+        msgpack::type::make_define_array(__VA_ARGS__).msgpack_pack(pk); \
     } \
     void msgpack_unpack(msgpack::object const& o) \
     { \
-        msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \
+        msgpack::type::make_define_array(__VA_ARGS__).msgpack_unpack(o); \
     }\
     template <typename MSGPACK_OBJECT> \
     void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone& z) const \
     { \
-        msgpack::type::make_define(__VA_ARGS__).msgpack_object(o, z); \
+        msgpack::type::make_define_array(__VA_ARGS__).msgpack_object(o, z); \
     }
 
+#define MSGPACK_BASE_ARRAY(base) (*const_cast<base *>(static_cast<base const*>(this)))
+
 // MSGPACK_ADD_ENUM must be used in the global namespace.
 #define MSGPACK_ADD_ENUM(enum_name) \
   namespace msgpack { \
@@ -89,12 +91,12 @@ namespace type {
 /// @cond
 <% GENERATION_LIMIT = 31 %>
 template <typename A0 = void<%1.upto(GENERATION_LIMIT+1) {|i|%>, typename A<%=i%> = void<%}%>>
-struct define;
+struct define_array;
 /// @endcond
 
 template <>
-struct define<> {
-    typedef define<> value_type;
+struct define_array<> {
+    typedef define_array<> value_type;
     typedef tuple<> tuple_type;
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -116,10 +118,10 @@ struct define<> {
 /// @cond
 <%0.upto(GENERATION_LIMIT) {|i|%>
 template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-struct define<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
-    typedef define<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> value_type;
+struct define_array<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
+    typedef define_array<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> value_type;
     typedef tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> tuple_type;
-    define(A0& _a0<%1.upto(i) {|j|%>, A<%=j%>& _a<%=j%><%}%>) :
+    define_array(A0& _a0<%1.upto(i) {|j|%>, A<%=j%>& _a<%=j%><%}%>) :
         a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -154,17 +156,17 @@ struct define<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
 <%}%>
 /// @endcond
 
-inline define<> make_define()
+inline define_array<> make_define_array()
 {
-    return define<>();
+    return define_array<>();
 }
 
 /// @cond
 <%0.upto(GENERATION_LIMIT) {|i|%>
 template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-define<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_define(A0& a0<%1.upto(i) {|j|%>, A<%=j%>& a<%=j%><%}%>)
+inline define_array<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_define_array(A0& a0<%1.upto(i) {|j|%>, A<%=j%>& a<%=j%><%}%>)
 {
-    return define<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>);
+    return define_array<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>);
 }
 <%}%>
 /// @endcond
@@ -176,4 +178,4 @@ define<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_define(A0& a0<%1.upto(i) {|j|%>,
 }  // namespace msgpack
 
 
-#endif // MSGPACK_CPP03_DEFINE_HPP
+#endif // MSGPACK_CPP03_DEFINE_ARRAY_HPP

erb/cpp03_define_map.hpp.erb

@@ -0,0 +1,181 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2015 KONDO Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_CPP03_DEFINE_MAP_HPP
+#define MSGPACK_CPP03_DEFINE_MAP_HPP
+
+// BOOST_PP_VARIADICS is defined in boost/preprocessor/config/config.hpp
+// http://www.boost.org/libs/preprocessor/doc/ref/variadics.html
+// However, supporting compiler detection is not complete. msgpack-c requires
+// variadic macro arguments support. So BOOST_PP_VARIADICS is defined here explicitly.
+#if !defined(MSGPACK_PP_VARIADICS)
+#define MSGPACK_PP_VARIADICS
+#endif
+
+#include <msgpack/preprocessor.hpp>
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/msgpack_tuple.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/object_fwd.hpp"
+
+#define MSGPACK_DEFINE_MAP_EACH_PROC(r, data, elem) \
+    MSGPACK_PP_IF( \
+        MSGPACK_PP_IS_BEGIN_PARENS(elem), \
+        elem, \
+        (MSGPACK_PP_STRINGIZE(elem))(elem) \
+    )
+
+#define MSGPACK_DEFINE_MAP_IMPL(...) \
+    MSGPACK_PP_SEQ_TO_TUPLE( \
+        MSGPACK_PP_SEQ_FOR_EACH( \
+            MSGPACK_DEFINE_MAP_EACH_PROC, \
+            0, \
+            MSGPACK_PP_VARIADIC_TO_SEQ(__VA_ARGS__) \
+        ) \
+    )
+
+#define MSGPACK_DEFINE_MAP(...) \
+    template <typename Packer> \
+    void msgpack_pack(Packer& pk) const \
+    { \
+        msgpack::type::make_define_map \
+            MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \
+            .msgpack_pack(pk); \
+    } \
+    void msgpack_unpack(msgpack::object const& o) \
+    { \
+        msgpack::type::make_define_map \
+            MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \
+            .msgpack_unpack(o); \
+    }\
+    template <typename MSGPACK_OBJECT> \
+    void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone& z) const \
+    { \
+        msgpack::type::make_define_map \
+            MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \
+            .msgpack_object(o, z); \
+    }
+
+#define MSGPACK_BASE_MAP(base) \
+    (MSGPACK_PP_STRINGIZE(base))(*const_cast<base *>(static_cast<base const*>(this)))
+
+namespace msgpack {
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+namespace type {
+
+/// @cond
+<% GENERATION_LIMIT = 31 %>
+template <typename A0 = void<%1.upto(GENERATION_LIMIT+1) {|i|%>, typename A<%=i%> = void<%}%>>
+struct define_map;
+/// @endcond
+
+template <>
+struct define_map<> {
+    template <typename Packer>
+    void msgpack_pack(Packer& pk) const
+    {
+        pk.pack_map(0);
+    }
+    void msgpack_unpack(msgpack::object const& o) const
+    {
+        if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
+    }
+    void msgpack_object(msgpack::object* o, msgpack::zone&) const
+    {
+        o->type = msgpack::type::MAP;
+        o->via.map.ptr = nullptr;
+        o->via.map.size = 0;
+    }
+};
+
+/// @cond
+<%1.step(GENERATION_LIMIT+1,2) {|i|%>
+template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
+struct define_map<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
+    define_map(A0& _a0<%1.upto(i) {|j|%>, A<%=j%>& _a<%=j%><%}%>) :
+        a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {}
+    template <typename Packer>
+    void msgpack_pack(Packer& pk) const
+    {
+        pk.pack_map(<%=(i+1)/2%>);
+        <%0.upto(i) {|j|%>
+        pk.pack(a<%=j%>);<%}%>
+    }
+    void msgpack_unpack(msgpack::object const& o) const
+    {
+        if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
+        std::map<std::string, msgpack::object const*> kvmap;
+        for (uint32_t i = 0; i < o.via.map.size; ++i) {
+            kvmap.insert(
+                std::map<std::string, msgpack::object const*>::value_type(
+                    std::string(
+                        o.via.map.ptr[i].key.via.str.ptr,
+                        o.via.map.ptr[i].key.via.str.size),
+                    &o.via.map.ptr[i].val
+                )
+            );
+        }
+        <%0.step(i,2) {|j|%>
+        {
+            std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a<%=j%>);
+            if (it != kvmap.end()) {
+                it->second->convert(a<%=j+1%>);
+            }
+        }
+        <%}%>
+    }
+    void msgpack_object(msgpack::object* o, msgpack::zone& z) const
+    {
+        o->type = msgpack::type::MAP;
+        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*<%=(i+1)/2%>));
+        o->via.map.size = <%=(i+1)/2%>;
+        <%0.step(i,2) {|j|%>
+        o->via.map.ptr[<%=j/2%>].key = msgpack::object(a<%=j%>, z);
+        o->via.map.ptr[<%=j/2%>].val = msgpack::object(a<%=j+1%>, z);
+        <%}%>
+    }
+    <%0.upto(i) {|j|%>
+    A<%=j%>& a<%=j%>;<%}%>
+};
+<%}%>
+/// @endcond
+
+inline define_map<> make_define_map()
+{
+    return define_map<>();
+}
+
+/// @cond
+<%0.upto(GENERATION_LIMIT) {|i|%>
+template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
+inline define_map<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_define_map(A0& a0<%1.upto(i) {|j|%>, A<%=j%>& a<%=j%><%}%>)
+{
+    return define_map<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>);
+}
+<%}%>
+/// @endcond
+
+}  // namespace type
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+}  // namespace msgpack
+
+#endif // MSGPACK_CPP03_DEFINE_MAP_HPP

erb/cpp03_zone.hpp.erb

@@ -308,6 +308,12 @@ inline void zone::undo_allocate(size_t size)
     m_chunk_list.m_free += size;
 }
 
+inline std::size_t aligned_size(
+    std::size_t size,
+    std::size_t align = MSGPACK_ZONE_ALIGN) {
+    return (size + align - 1) / align * align;
+}
+
 /// @cond
 <%0.upto(GENERATION_LIMIT) {|i|%>
 template <typename T<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>

example/CMakeLists.txt

@@ -0,0 +1,4 @@
+ADD_SUBDIRECTORY (c)
+ADD_SUBDIRECTORY (cpp03)
+ADD_SUBDIRECTORY (cpp11)
+ADD_SUBDIRECTORY (boost)

example/boost/CMakeLists.txt

@@ -0,0 +1,24 @@
+IF (MSGPACK_BOOST)
+    LIST (APPEND exec_PROGRAMS
+        msgpack_variant_capitalize.cpp
+        msgpack_variant_mapbased.cpp
+    )
+ENDIF ()
+
+FOREACH (source_file ${exec_PROGRAMS})
+    GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
+    ADD_EXECUTABLE (
+        ${source_file_we}
+        ${source_file}
+    )
+    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 -Wextra -Werror -Wno-mismatched-tags -g -O3")
+    ENDIF ()
+    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+        IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
+            STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+        ELSE ()
+            SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
+        ENDIF ()
+    ENDIF ()
+ENDFOREACH ()

example/boost/msgpack_variant_capitalize.cpp

@@ -0,0 +1,102 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2015 KONDO Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+
+#include <string>
+#include <sstream>
+#include <iostream>
+#include <algorithm>
+#include <cctype>
+
+#include <msgpack.hpp>
+
+struct user {
+    std::string name;
+    int age;
+    std::string address;
+    MSGPACK_DEFINE(name, age, address);
+};
+
+struct proc:boost::static_visitor<void> {
+    void operator()(std::string& v) const {
+        std::cout << "  match std::string& v" << std::endl;
+        std::cout << "    v: " << v << std::endl;
+        std::cout << "    capitalize" << std::endl;
+        for (std::string::iterator it = v.begin(), end = v.end();
+             it != end;
+             ++it) {
+            *it = std::toupper(*it);
+        }
+    }
+    void operator()(std::vector<msgpack::type::variant>& v) const {
+        std::cout << "match vector (msgpack::type::ARRAY)" << std::endl;
+        std::vector<msgpack::type::variant>::iterator it = v.begin();
+        std::vector<msgpack::type::variant>::const_iterator end = v.end();
+        for (; it != end; ++it) {
+            boost::apply_visitor(*this, *it);
+        }
+    }
+    template <typename T>
+    void operator()(T const&) const {
+        std::cout << "  match others" << std::endl;
+    }
+};
+
+void print(std::string const& buf) {
+    for (std::string::const_iterator it = buf.begin(), end = buf.end();
+         it != end;
+         ++it) {
+        std::cout
+            << std::setw(2)
+            << std::hex
+            << std::setfill('0')
+            << (static_cast<int>(*it) & 0xff)
+            << ' ';
+    }
+    std::cout << std::dec << std::endl;
+}
+
+
+int main() {
+    std::stringstream ss1;
+    user u;
+    u.name = "Takatoshi Kondo";
+    u.age = 42;
+    u.address = "Tokyo, JAPAN";
+
+    std::cout << "Packing object." << std::endl;
+    msgpack::pack(ss1, u);
+    print(ss1.str());
+
+    msgpack::unpacked unp1 = msgpack::unpack(ss1.str().data(), ss1.str().size());
+    msgpack::object const& obj1 = unp1.get();
+    std::cout << "Unpacked msgpack object." << std::endl;
+    std::cout << obj1 << std::endl;
+
+    msgpack::type::variant v = obj1.as<msgpack::type::variant>();
+    std::cout << "Applying proc..." << std::endl;
+    boost::apply_visitor(proc(), v);
+
+    std::stringstream ss2;
+    std::cout << "Packing modified object." << std::endl;
+    msgpack::pack(ss2, v);
+    print(ss2.str());
+
+    msgpack::unpacked unp2 = msgpack::unpack(ss2.str().data(), ss2.str().size());
+    msgpack::object const& obj2 = unp2.get();
+    std::cout << "Modified msgpack object." << std::endl;
+    std::cout << obj2 << std::endl;
+}

example/boost/msgpack_variant_mapbased.cpp

@@ -0,0 +1,100 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2015 KONDO Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+
+#include <string>
+#include <sstream>
+#include <iostream>
+
+#include <msgpack.hpp>
+
+struct user {
+    std::string name;
+    int age;
+    std::string address;
+    MSGPACK_DEFINE_MAP(name, age, address);
+};
+
+struct proc:boost::static_visitor<void> {
+    // msgpack::type::MAP is converted to std::multimap, not std::map.
+    void operator()(std::multimap<msgpack::type::variant_ref, msgpack::type::variant_ref>& v) const {
+        std::cout << "match map" << std::endl;
+        std::multimap<msgpack::type::variant_ref, msgpack::type::variant_ref>::iterator it = v.begin();
+        std::multimap<msgpack::type::variant_ref, msgpack::type::variant_ref>::iterator end = v.end();
+        while(it != end) {
+            boost::string_ref const& key = it->first.as_boost_string_ref();
+            if (key == "name") {
+                boost::string_ref const& value = it->second.as_boost_string_ref();
+                if (value == "Takatoshi Kondo") {
+                    // You can add values to msgpack::type::variant_ref.
+                    v.insert(
+                        std::multimap<msgpack::type::variant_ref, msgpack::type::variant_ref>::value_type(
+                            "role",
+                            "msgpack-c committer"
+                        )
+                    );
+                }
+                ++it;
+            }
+            else if (key == "age") {
+                // You can remove key-value pair from msgpack::type::variant_ref
+
+#if defined(MSGPACK_USE_CPP03)
+                v.erase(it++);
+#else  // defined(MSGPACK_USE_CPP03)
+#  if MSGPACK_LIB_STD_CXX
+                it = v.erase(std::multimap<msgpack::type::variant_ref, msgpack::type::variant_ref>::const_iterator(it));
+#  else  // MSGPACK_LIB_STD_CXX
+                it = v.erase(it);
+#  endif // MSGPACK_LIB_STD_CXX
+#endif // defined(MSGPACK_USE_CPP03)
+            }
+            else if (key == "address") {
+                // When you want to append string
+                // "Tokyo" -> "Tokyo, JAPAN"
+                // Use msgpack::type::variant instead of msgpack::type::variant_ref
+                // or do as follows:
+                boost::string_ref const& value = it->second.as_boost_string_ref();
+                it->second = std::string(&value.front(), value.size()) + ", JAPAN";
+                ++it;
+            }
+        }
+    }
+    template <typename T>
+    void operator()(T const&) const {
+        std::cout << "  match others" << std::endl;
+    }
+};
+
+int main() {
+    std::stringstream ss;
+    user u;
+    u.name = "Takatoshi Kondo";
+    u.age = 42;
+    u.address = "Tokyo";
+    msgpack::pack(ss, u);
+
+    msgpack::unpacked unp = msgpack::unpack(ss.str().data(), ss.str().size());
+    msgpack::object const& obj = unp.get();
+    std::cout << "Unpacked msgpack object." << std::endl;
+    std::cout << obj << std::endl;
+    msgpack::type::variant_ref v = obj.as<msgpack::type::variant_ref>();
+    std::cout << "Applying proc..." << std::endl;
+    boost::apply_visitor(proc(), v);
+    msgpack::zone z;
+    std::cout << "Applied msgpack object." << std::endl;
+    std::cout << msgpack::object(v, z) << std::endl;
+}

example/c/CMakeLists.txt

@@ -0,0 +1,32 @@
+INCLUDE_DIRECTORIES (
+    ../include
+)
+
+LIST (APPEND exec_PROGRAMS
+    lib_buffer_unpack.c
+    simple_c.c
+    speed_test_uint32_array.c
+    speed_test_uint64_array.c
+    user_buffer_unpack.c
+)
+
+FOREACH (source_file ${exec_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
+    )
+    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 -Wextra -Werror -Wno-mismatched-tags -g -O3")
+    ENDIF ()
+    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+        IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
+            STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+        ELSE ()
+            SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
+        ENDIF ()
+    ENDIF ()
+ENDFOREACH ()

example/c/lib_buffer_unpack.c

@@ -41,6 +41,20 @@ size_t receiver_recv(receiver *r, char* buf, size_t try_size) {
     return actual_size;
 }
 
+size_t receiver_to_unpacker(receiver* r, size_t request_size,
+        msgpack_unpacker *unpacker)
+{
+    // make sure there's enough room, or expand the unpacker accordingly
+    if (msgpack_unpacker_buffer_capacity(unpacker) < request_size) {
+        msgpack_unpacker_reserve_buffer(unpacker, request_size);
+        assert(msgpack_unpacker_buffer_capacity(unpacker) >= request_size);
+    }
+    size_t recv_len = receiver_recv(r, msgpack_unpacker_buffer(unpacker),
+                                    request_size);
+    msgpack_unpacker_buffer_consumed(unpacker, recv_len);
+    return recv_len;
+}
+
 #define EACH_RECV_SIZE 4
 
 void unpack(receiver* r) {
@@ -48,23 +62,14 @@ void unpack(receiver* r) {
     msgpack_unpacker* unp = msgpack_unpacker_new(100);
     msgpack_unpacked result;
     msgpack_unpack_return ret;
-    char* buf;
     size_t recv_len;
     int recv_count = 0;
     int i = 0;
 
     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);
-
-
-   while (recv_len > 0) {
+    while (true) {
+        recv_len = receiver_to_unpacker(r, EACH_RECV_SIZE, unp);
+        if (recv_len == 0) break; // (reached end of input)
         printf("receive count: %d %zd bytes received.\n", recv_count++, recv_len);
         ret = msgpack_unpacker_next(unp, &result);
         while (ret == MSGPACK_UNPACK_SUCCESS) {
@@ -85,15 +90,9 @@ void unpack(receiver* r) {
             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);
+    msgpack_unpacker_free(unp);
 }
 
 int main(void) {

example/c/simple_c.c

@@ -1,6 +1,14 @@
 #include <msgpack.h>
 #include <stdio.h>
 
+void print(char const* buf, unsigned int len)
+{
+    size_t i = 0;
+    for(; i < len ; ++i)
+        printf("%02x ", 0xff & buf[i]);
+    printf("\n");
+}
+
 int main(void)
 {
     msgpack_sbuffer sbuf;
@@ -20,6 +28,8 @@ int main(void)
     msgpack_pack_str(&pk, 7);
     msgpack_pack_str_body(&pk, "example", 7);
 
+    print(sbuf.data, sbuf.size);
+
     /* deserialize the buffer into msgpack_object instance. */
     /* deserialized object is valid during the msgpack_zone instance alive. */
     msgpack_zone_init(&mempool, 2048);
@@ -35,4 +45,3 @@ int main(void)
 
     return 0;
 }
-

example/c/speed_test_uint32_array.c

@@ -14,7 +14,7 @@ void test()
 
     msgpack_pack_array(pk, size);
     {
-        int idx = 0;
+        size_t idx = 0;
         for (; idx < size; ++idx)
             msgpack_pack_uint32(pk, 1);
     }
@@ -28,7 +28,7 @@ void test()
     msgpack_sbuffer_destroy(&buf);
 }
 
-int main(int argc, char **argv)
+int main(void)
 {
     int i = 0;
     for (; i < 10; ++i) test();

example/c/speed_test_uint64_array.c

@@ -15,7 +15,7 @@ void test()
 
     msgpack_pack_array(pk, size);
     {
-        int idx = 0;
+        size_t idx = 0;
         for (; idx < size; ++idx)
             msgpack_pack_uint64(pk, test_u64);
     }
@@ -29,7 +29,7 @@ void test()
     msgpack_sbuffer_destroy(&buf);
 }
 
-int main(int argc, char **argv)
+int main(void)
 {
     int i = 0;
     for (; i < 10; ++i) test();

example/cpp03/CMakeLists.txt

@@ -0,0 +1,99 @@
+LIST (APPEND exec_PROGRAMS
+    class_intrusive.cpp
+    class_intrusive_map.cpp
+    class_non_intrusive.cpp
+    custom.cpp
+    enum.cpp
+    map_based_versionup.cpp
+    protocol.cpp
+    protocol_new.cpp
+    reuse_zone.cpp
+    simple.cpp
+)
+
+IF (NOT MSVC)
+    LIST (APPEND with_pthread_PROGRAMS
+        stream.cpp
+    )
+ENDIF ()
+
+IF (MSGPACK_BOOST)
+    IF (NOT MSVC)
+        LIST (APPEND with_boost_lib_PROGRAMS
+            speed_test.cpp
+            speed_test_nested_array.cpp
+        )
+    ENDIF ()
+ENDIF ()
+
+FOREACH (source_file ${exec_PROGRAMS})
+    GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
+    ADD_EXECUTABLE (
+        ${source_file_we}
+        ${source_file}
+    )
+    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 -Wextra -Werror -Wno-mismatched-tags -g -O3")
+    ENDIF ()
+    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+        IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
+            STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+        ELSE ()
+            SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
+        ENDIF ()
+    ENDIF ()
+ENDFOREACH ()
+
+FOREACH (source_file ${with_pthread_PROGRAMS})
+    GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
+    ADD_EXECUTABLE (
+        ${source_file_we}
+        ${source_file}
+    )
+    TARGET_LINK_LIBRARIES (${source_file_we}
+        pthread
+    )
+    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 -Wextra -Werror -Wno-mismatched-tags -g -O3 -pthread")
+    ENDIF ()
+    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+        IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
+            STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+        ELSE ()
+            SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
+        ENDIF ()
+    ENDIF ()
+ENDFOREACH ()
+
+FOREACH (source_file ${with_boost_lib_PROGRAMS})
+    INCLUDE_DIRECTORIES (
+        ../include
+        ${Boost_INCLUDE_DIRS}
+    )
+    GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
+    ADD_EXECUTABLE (
+        ${source_file_we}
+        ${source_file}
+    )
+    LINK_DIRECTORIES(${Boost_LIBRARY_DIRS})
+    TARGET_LINK_LIBRARIES (${source_file_we}
+        ${Boost_TIMER_LIBRARY}
+        ${Boost_CHRONO_LIBRARY}
+        ${Boost_SYSTEM_LIBRARY}
+    )
+    IF (NOT MSVC AND NOT APPLE)
+        TARGET_LINK_LIBRARIES (${source_file_we}
+            rt
+        )
+    ENDIF ()
+    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 -Wextra -Werror -Wno-mismatched-tags -g -O3")
+    ENDIF ()
+    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+        IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
+            STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+        ELSE ()
+            SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
+        ENDIF ()
+    ENDIF ()
+ENDFOREACH ()

example/cpp03/class_intrusive.cpp

@@ -21,17 +21,42 @@
 #include <sstream>
 #include <cassert>
 
+// When you want to adapt map instead of array, you can enable these macro definition.
+//
+// #define MSGPACK_USE_DEFINE_MAP
+
+
 #include <msgpack.hpp>
 
+struct my_base1 {
+    int a;
+    MSGPACK_DEFINE(a);
+};
+inline bool operator==(my_base1 const& lhs, my_base1 const& rhs) {
+    return lhs.a == rhs.a;
+}
 
-class my_class {
+struct my_base2 {
+    std::string b;
+    std::string c;
+    MSGPACK_DEFINE(b, c);
+};
+inline bool operator==(my_base2 const& lhs, my_base2 const& rhs) {
+    return lhs.b == rhs.b && lhs.c == rhs.c;
+}
+
+class my_class : public my_base1, private my_base2 {
 public:
     my_class() {} // When you want to convert from msgpack::object to my_class,
                   // my_class should be default constractible.
     my_class(std::string const& name, int age):name_(name), age_(age) {}
-
+    void set_b(std::string const& str) { b = str; }
+    void set_c(std::string const& str) { c = str; }
     friend bool operator==(my_class const& lhs, my_class const& rhs) {
-        return lhs.name_ == rhs.name_ && lhs.age_ == rhs.age_;
+        return
+            static_cast<my_base1 const&>(lhs) == static_cast<my_base1 const&>(rhs) &&
+            static_cast<my_base2 const&>(lhs) == static_cast<my_base2 const&>(rhs) &&
+            lhs.name_ == rhs.name_ && lhs.age_ == rhs.age_;
     }
 
 private:
@@ -39,7 +64,7 @@ private:
     int age_;
 
 public:
-    MSGPACK_DEFINE(name_, age_);
+    MSGPACK_DEFINE(name_, age_, MSGPACK_BASE(my_base1), MSGPACK_BASE(my_base2));
 };
 
 void print(std::string const& buf) {
@@ -59,6 +84,9 @@ void print(std::string const& buf) {
 int main() {
     {   // pack, unpack
         my_class my("John Smith", 42);
+        my.a = 123;
+        my.set_b("ABC");
+        my.set_c("DEF");
         std::stringstream ss;
         msgpack::pack(ss, my);
 
@@ -72,6 +100,9 @@ int main() {
     }
     {   // create object with zone
         my_class my("John Smith", 42);
+        my.a = 123;
+        my.set_b("ABC");
+        my.set_c("DEF");
         msgpack::zone z;
         msgpack::object obj(my, z);
         std::cout << obj << std::endl;

example/cpp03/class_intrusive_map.cpp

@@ -0,0 +1,83 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2015 KONDO Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+
+#include <string>
+#include <iostream>
+#include <iomanip>
+#include <sstream>
+#include <cassert>
+
+#include <msgpack.hpp>
+
+
+class my_class {
+public:
+    my_class() {} // When you want to convert from msgpack::object to my_class,
+                  // my_class should be default constractible.
+                  // If you use C++11, you can adapt non-default constructible
+                  // classes to msgpack::object.
+                  // See https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_adaptor#non-default-constructible-class-support-c11-only
+    my_class(std::string const& name, int age):name_(name), age_(age) {}
+
+    friend bool operator==(my_class const& lhs, my_class const& rhs) {
+        return lhs.name_ == rhs.name_ && lhs.age_ == rhs.age_;
+    }
+
+private:
+    std::string name_;
+    int age_;
+
+public:
+    MSGPACK_DEFINE_MAP(name_, age_);
+};
+
+void print(std::string const& buf) {
+    for (std::string::const_iterator it = buf.begin(), end = buf.end();
+         it != end;
+         ++it) {
+        std::cout
+            << std::setw(2)
+            << std::hex
+            << std::setfill('0')
+            << (static_cast<int>(*it) & 0xff)
+            << ' ';
+    }
+    std::cout << std::dec << std::endl;
+}
+
+int main() {
+    {   // pack, unpack
+        my_class my("John Smith", 42);
+        std::stringstream ss;
+        msgpack::pack(ss, my);
+
+        print(ss.str());
+
+        msgpack::unpacked unp;
+        msgpack::unpack(unp, ss.str().data(), ss.str().size());
+        msgpack::object obj = unp.get();
+        std::cout << obj << std::endl;
+        assert(obj.as<my_class>() == my);
+    }
+    {   // create object with zone
+        my_class my("John Smith", 42);
+        msgpack::zone z;
+        msgpack::object obj(my, z);
+        std::cout << obj << std::endl;
+        assert(obj.as<my_class>() == my);
+    }
+}

example/cpp03/map_based_versionup.cpp

@@ -0,0 +1,119 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2015 KONDO Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+
+#include <string>
+#include <iostream>
+#include <iomanip>
+#include <sstream>
+#include <cassert>
+
+#include <msgpack.hpp>
+
+struct base1 {
+    base1():a("default") {}
+    std::string a;
+    MSGPACK_DEFINE_MAP(a);
+};
+
+struct v1 : base1 {
+    v1():name("default"), age(0) {}
+    std::string name;
+    int age;
+    MSGPACK_DEFINE_MAP(MSGPACK_BASE_MAP(base1), name, age);
+};
+
+struct base2 {
+    base2():a("default") {}
+    std::string a;
+    MSGPACK_DEFINE_MAP(a);
+};
+
+// Removed: base1, name
+// Added  : base2, address
+struct v2 : base2 {
+    v2(): age(0), address("default") {}
+    int age;
+    std::string address;
+    MSGPACK_DEFINE_MAP(MSGPACK_BASE_MAP(base2), age, address);
+};
+
+// The member variable "age" is in common between v1 and v2.
+
+void print(std::string const& buf) {
+    for (std::string::const_iterator it = buf.begin(), end = buf.end();
+         it != end;
+         ++it) {
+        std::cout
+            << std::setw(2)
+            << std::hex
+            << std::setfill('0')
+            << (static_cast<int>(*it) & 0xff)
+            << ' ';
+    }
+    std::cout << std::dec << std::endl;
+}
+
+int main() {
+    { // pack v1, unpack, convert to v2
+        v1 v;
+        v.a = "ABC";
+        v.name = "John Smith";
+        v.age = 35;
+
+        std::stringstream ss;
+        msgpack::pack(ss, v);
+
+        print(ss.str());
+
+        msgpack::unpacked unp = msgpack::unpack(ss.str().data(), ss.str().size());
+
+        msgpack::object obj = unp.get();
+        std::cout << obj << std::endl;
+
+        v2 newv = obj.as<v2>();
+
+        std::cout << "v2::a       " << newv.a << std::endl;
+        std::cout << "v2::age     " << newv.age << std::endl;
+        std::cout << "v2::address " << newv.address << std::endl;
+
+        // "age" is set from v1
+        assert(newv.a == "default");
+        assert(newv.age == 35);
+        assert(newv.address == "default");
+    }
+    { // create v2 object with zone, convert to v1
+        v2 v;
+        v.a = "DEF";
+        v.age = 42;
+        v.address = "Tokyo";
+
+        msgpack::zone z;
+        msgpack::object obj(v, z);
+        std::cout << obj << std::endl;
+
+        v1 newv = obj.as<v1>();
+
+        std::cout << "v1::a       " << newv.a << std::endl;
+        std::cout << "v1::name    " << newv.name << std::endl;
+        std::cout << "v1::age     " << newv.age << std::endl;
+
+        // "age" is set from v2
+        assert(newv.a == "default");
+        assert(newv.name == "default");
+        assert(newv.age == 42);
+    }
+}

example/cpp03/protocol_new.cpp

@@ -0,0 +1,92 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2015 KONDO Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+
+#include <msgpack.hpp>
+#include <string>
+#include <iostream>
+#include <sstream>
+
+// This example uses obsolete APIs
+// See protocol_new.cpp
+namespace myprotocol {
+    struct Get {
+        Get() {}
+        Get(uint32_t f, const std::string& k) : flags(f), key(k) {}
+        uint32_t flags;
+        std::string key;
+        MSGPACK_DEFINE(flags, key);
+    };
+
+    typedef std::vector<Get> MultiGet;
+}
+
+
+int main(void)
+{
+    // send Get request
+    std::stringstream stream;
+    {
+        myprotocol::Get req;
+        req.flags = 0;
+        req.key   = "key0";
+        msgpack::pack(stream, req);
+    }
+
+    stream.seekg(0);
+
+    // receive Get request
+    {
+        std::string buffer(stream.str());
+
+        msgpack::unpacked result;
+        msgpack::unpack(result, buffer.data(), buffer.size());
+        msgpack::object o = result.get();
+
+        myprotocol::Get req;
+        o.convert(req);
+        std::cout << "received: " << o << std::endl;
+    }
+
+
+    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);
+    }
+
+    stream.seekg(0);
+
+    // receive MultiGet request
+    {
+        std::string buffer(stream.str());
+
+        msgpack::unpacked result;
+        msgpack::unpack(result, buffer.data(), buffer.size());
+        msgpack::object o = result.get();
+
+
+        myprotocol::MultiGet req;
+        o.convert(req);
+        std::cout << "received: " << o << std::endl;
+    }
+}

example/cpp03/reuse_zone.cpp

@@ -40,8 +40,11 @@ int main() {
 
     // msgpack array is constructed on z.
     msgpack::object obj = msgpack::unpack(z, ss.str().data(), ss.str().size(), offset);
+    std::cout << obj << std::endl;
     assert(obj.as<std::vector<int> >() == v);
 
     // msgpack str is constructed on z.
-    assert(msgpack::unpack(z, ss.str().data(), ss.str().size(), offset).as<std::string>() == s);
+    std::string const& str = msgpack::unpack(z, ss.str().data(), ss.str().size(), offset).as<std::string>();
+    std::cout << str << std::endl;
+    assert(str == s);
 }

example/cpp03/speed_test_nested_array.cpp

@@ -29,7 +29,7 @@ template <typename T, std::size_t level>
 struct vecvec {
     typedef std::vector<typename vecvec<T, level - 1>::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) {
+        for (std::size_t elem = 0; elem < num_of_elems; ++elem) {
             typename vecvec<T, level - 1>::type child;
             vecvec<T, level - 1>::fill(child, num_of_elems, val);
             v.push_back(child);
@@ -41,7 +41,7 @@ template <typename T>
 struct vecvec<T, 0> {
     typedef std::vector<T> type;
     static void fill(type& v, std::size_t num_of_elems, T const& val) {
-        for (int elem = 0; elem < num_of_elems; ++elem) {
+        for (std::size_t elem = 0; elem < num_of_elems; ++elem) {
             v.push_back(val);
         }
     }
@@ -50,9 +50,9 @@ struct vecvec<T, 0> {
 void test_array_of_array() {
     std::cout << "[TEST][array_of_array]" << std::endl;
     // setup
-    int const depth = 16;
+    int const depth = 4;
     std::cout << "Setting up array data..." << std::endl;
-    typename vecvec<int, depth>::type v1;
+    vecvec<int, depth>::type v1;
     vecvec<int, depth>::fill(v1, 3, 42);
 
     std::cout << "Start packing..." << std::endl;
@@ -77,7 +77,7 @@ void test_array_of_array() {
         std::cout << result << std::endl;
     }
     std::cout << "Unpack finished..." << std::endl;
-    typename vecvec<int, depth>::type v2;
+    vecvec<int, depth>::type v2;
     std::cout << "Start converting..." << std::endl;
     {
         boost::timer::cpu_timer timer;

example/cpp03/stream.cpp

@@ -122,7 +122,7 @@ private:
 int main(void)
 {
     int pair[2];
-    pipe(pair);
+    if (pipe(pair) != 0) return -1;
 
     // run server thread
     Server srv(pair[0]);

example/cpp11/CMakeLists.txt

@@ -0,0 +1,28 @@
+IF (MSGPACK_CXX11)
+    INCLUDE_DIRECTORIES (
+        ../include
+    )
+
+    LIST (APPEND exec_PROGRAMS
+        container.cpp
+        non_def_con_class.cpp
+    )
+
+    FOREACH (source_file ${exec_PROGRAMS})
+        GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
+        ADD_EXECUTABLE (
+            ${source_file_we}
+            ${source_file}
+        )
+        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 -Wextra -Werror -Wno-mismatched-tags -g -O3")
+        ENDIF ()
+        IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+            IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
+                STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+            ELSE ()
+                SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
+            ENDIF ()
+        ENDIF ()
+    ENDFOREACH ()
+ENDIF ()

example/cpp11/container.cpp

@@ -29,15 +29,15 @@
 #include <msgpack.hpp>
 
 void array() {
-    std::array<int, 5> a { 1, 2, 3, 4, 5 };
+    std::array<int, 5> a { { 1, 2, 3, 4, 5 } };
     std::stringstream ss;
     msgpack::pack(ss, a);
 
     msgpack::unpacked und = msgpack::unpack(ss.str().data(), ss.str().size());
     msgpack::object obj = und.get();
-    std::array<int, 5> const& new_a = obj.as<std::array<int, 5>>();
 
-    assert(new_a == a);
+    std::cout << obj << std::endl;
+    assert((obj.as<std::array<int, 5>>()) == a);
 }
 
 void tuple() {
@@ -47,6 +47,8 @@ void tuple() {
 
     auto und = msgpack::unpack(ss.str().data(), ss.str().size());
     auto obj = und.get();
+
+    std::cout << obj << std::endl;
     assert(obj.as<decltype(t)>() == t);
 }
 
@@ -56,7 +58,10 @@ void unordered_map() {
     msgpack::pack(ss, m);
 
     auto und = msgpack::unpack(ss.str().data(), ss.str().size());
-    assert(und.get().as<decltype(m)>() == m);
+    msgpack::object obj = und.get();
+
+    std::cout << obj << std::endl;
+    assert(obj.as<decltype(m)>() == m);
 }
 
 void unordered_set() {
@@ -64,7 +69,11 @@ void unordered_set() {
     std::stringstream ss;
     msgpack::pack(ss, s);
 
-    assert(msgpack::unpack(ss.str().data(), ss.str().size()).get().as<decltype(s)>() == s);
+    auto und = msgpack::unpack(ss.str().data(), ss.str().size());
+    auto obj = und.get();
+
+    std::cout << obj << std::endl;
+    assert(obj.as<decltype(s)>() == s);
 }
 
 void forward_list() {
@@ -73,11 +82,15 @@ void forward_list() {
     std::stringstream ss;
     msgpack::pack(ss, f);
 
-    assert(msgpack::unpack(ss.str().data(), ss.str().size()).get().as<type>() == f);
+    auto und = msgpack::unpack(ss.str().data(), ss.str().size());
+    auto obj = und.get();
+
+    std::cout << obj << std::endl;
+    assert(obj.as<type>() == f);
 }
 
 void combi() {
-    std::array<int, 5>                   a { 1, 2, 3, 4, 5 };
+    std::array<int, 5>                   a { { 1, 2, 3, 4, 5 } };
     std::tuple<bool, std::string, int>   t {true, "ABC", 42};
     std::unordered_map<std::string, int> m { {"ABC", 1}, {"DEF", 3} };
     std::unordered_set<std::string>      s { "ABC", "DEF" };
@@ -91,11 +104,47 @@ void combi() {
     msgpack::pack(ss, f);
 
     std::size_t offset = 0;
-    assert(msgpack::unpack(ss.str().data(), ss.str().size(), offset).get().as<decltype(a)>() == a);
-    assert(msgpack::unpack(ss.str().data(), ss.str().size(), offset).get().as<decltype(t)>() == t);
-    assert(msgpack::unpack(ss.str().data(), ss.str().size(), offset).get().as<decltype(m)>() == m);
-    assert(msgpack::unpack(ss.str().data(), ss.str().size(), offset).get().as<decltype(s)>() == s);
-    assert(msgpack::unpack(ss.str().data(), ss.str().size(), offset).get().as<decltype(f)>() == f);
+    std::cout << "offset: " << offset << std::endl;
+    {
+        auto und = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
+        auto obj = und.get();
+
+        std::cout << obj << std::endl;
+        assert(obj.as<decltype(a)>() == a);
+    }
+    std::cout << "offset: " << offset << std::endl;
+    {
+        auto und = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
+        auto obj = und.get();
+
+        std::cout << obj << std::endl;
+        assert(obj.as<decltype(t)>() == t);
+    }
+    std::cout << "offset: " << offset << std::endl;
+    {
+        auto und = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
+        auto obj = und.get();
+
+        std::cout << obj << std::endl;
+        assert(obj.as<decltype(m)>() == m);
+    }
+    std::cout << "offset: " << offset << std::endl;
+    {
+        auto und = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
+        auto obj = und.get();
+
+        std::cout << obj << std::endl;
+        assert(obj.as<decltype(s)>() == s);
+    }
+    std::cout << "offset: " << offset << std::endl;
+    {
+        auto und = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
+        auto obj = und.get();
+
+        std::cout << obj << std::endl;
+        assert(obj.as<decltype(f)>() == f);
+    }
+    std::cout << "offset: " << offset << std::endl;
 }
 
 int main() {

example/cpp11/non_def_con_class.cpp

@@ -0,0 +1,59 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2015 KONDO Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+
+#include <cassert>
+#include <memory>
+#include <iostream>
+
+#include <msgpack.hpp>
+
+struct my {
+    my() = delete;
+
+    // target class should be either copyable or movable (or both).
+    my(my const&) = delete;
+    my(my&&) = default;
+
+    my(int a):a(a) {}
+    int a;
+    MSGPACK_DEFINE(a);
+};
+
+namespace msgpack {
+MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) {
+namespace adaptor {
+
+template<>
+struct as<my> {
+    my operator()(msgpack::object const& o) const {
+        if (o.type != msgpack::type::ARRAY) throw msgpack::type_error();
+        if (o.via.array.size != 1) throw msgpack::type_error();
+        return my(o.via.array.ptr[0].as<int>());
+    }
+};
+
+} // namespace adaptor
+} // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
+} // namespace msgpack
+
+int main() {
+    my m1(42);
+    msgpack::zone z;
+    msgpack::object obj(m1, z);
+    std::cout << obj << std::endl;
+    assert(m1.a == obj.as<my>().a);
+}

include/msgpack/adaptor/adaptor_base.hpp

@@ -33,23 +33,23 @@ namespace adaptor {
 
 // Adaptor functors
 
-template <typename T>
+template <typename T, typename Enabler = void>
 struct convert {
     msgpack::object const& operator()(msgpack::object const& o, T& v) const;
 };
 
-template <typename T>
+template <typename T, typename Enabler = void>
 struct pack {
     template <typename Stream>
     msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, T const& v) const;
 };
 
-template <typename T>
+template <typename T, typename Enabler = void>
 struct object {
     void operator()(msgpack::object& o, T const& v) const;
 };
 
-template <typename T>
+template <typename T, typename Enabler = void>
 struct object_with_zone {
     void operator()(msgpack::object::with_zone& o, T const& v) const;
 };

include/msgpack/adaptor/array_ref.hpp

@@ -0,0 +1,182 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_TYPE_ARRAY_REF_HPP
+#define MSGPACK_TYPE_ARRAY_REF_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/adaptor/check_container_size.hpp"
+#include <cstring>
+#include <string>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace type {
+
+template <typename T>
+struct array_ref {
+    array_ref() : data(nullptr) {}
+    array_ref(T& t) : data(&t) {}
+
+    T* data;
+
+    template <typename U>
+    bool operator==(array_ref<U> const& t) const {
+        return *data == *t.data;
+    }
+    template <typename U>
+    bool operator!=(array_ref<U> const& t) const {
+        return !(*data == *t.data);
+    }
+    template <typename U>
+    bool operator< (array_ref<U> const& t) const
+    {
+        return *data < *t.data;
+    }
+    template <typename U>
+    bool operator> (array_ref<U> const& t) const
+    {
+        return *t.data < *data;
+    }
+    template <typename U>
+    bool operator<= (array_ref<U> const& t) const
+    {
+        return !(*t.data < *data);
+    }
+    template <typename U>
+    bool operator>= (array_ref<U> const& t) const
+    {
+        return !(*data < *t.data);
+    }
+};
+
+template <typename T>
+inline array_ref<T const> make_array_ref(T const& t) {
+    return array_ref<T const>(t);
+}
+
+template <typename T>
+inline array_ref<T> make_array_ref(T& t) {
+    return array_ref<T>(t);
+}
+
+
+} // namespace type
+
+namespace adaptor {
+
+template <typename T>
+struct convert<msgpack::type::array_ref<T> > {
+    msgpack::object const& operator()(msgpack::object const& o, msgpack::type::array_ref<T>& v) const {
+        if (!v.data) { throw msgpack::type_error(); }
+        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+        if (v.data->size() < o.via.bin.size) { throw msgpack::type_error(); }
+        if (o.via.array.size > 0) {
+            msgpack::object* p = o.via.array.ptr;
+            msgpack::object* const pend = o.via.array.ptr + o.via.array.size;
+            typename T::iterator it = v.data->begin();
+            do {
+                p->convert(*it);
+                ++p;
+                ++it;
+            } while(p < pend);
+        }
+        return o;
+    }
+};
+
+template <typename T>
+struct convert<msgpack::type::array_ref<std::vector<T> > > {
+    msgpack::object const& operator()(msgpack::object const& o, msgpack::type::array_ref<std::vector<T> >& v) const {
+        if (!v.data) { throw msgpack::type_error(); }
+        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+        v.data->resize(o.via.bin.size);
+        if (o.via.array.size > 0) {
+            msgpack::object* p = o.via.array.ptr;
+            msgpack::object* const pend = o.via.array.ptr + o.via.array.size;
+            typename std::vector<T>::iterator it = v.data->begin();
+            do {
+                p->convert(*it);
+                ++p;
+                ++it;
+            } while(p < pend);
+        }
+        return o;
+    }
+};
+
+template <typename T>
+struct pack<msgpack::type::array_ref<T> > {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const msgpack::type::array_ref<T>& v) const {
+        if (!v.data) { throw msgpack::type_error(); }
+        uint32_t size = checked_get_container_size(v.data->size());
+        o.pack_array(size);
+        for (typename T::const_iterator it(v.data->begin()), it_end(v.data->end());
+            it != it_end; ++it) {
+            o.pack(*it);
+        }
+        return o;
+    }
+};
+
+template <typename T>
+struct object_with_zone<msgpack::type::array_ref<T> > {
+    void operator()(msgpack::object::with_zone& o, const msgpack::type::array_ref<T>& v) const {
+        if (!v.data) { throw msgpack::type_error(); }
+        o.type = msgpack::type::ARRAY;
+        if (v.data->empty()) {
+            o.via.array.ptr = nullptr;
+            o.via.array.size = 0;
+        }
+        else {
+            uint32_t size = checked_get_container_size(v.data->size());
+            msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
+            msgpack::object* const pend = p + size;
+            o.via.array.ptr = p;
+            o.via.array.size = size;
+            typename T::const_iterator it(v.data->begin());
+            do {
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+                *p = msgpack::object(*it, o.zone);
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#pragma GCC diagnostic pop
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+                ++p;
+                ++it;
+            } while(p < pend);
+        }
+    }
+};
+
+} // namespace adaptor
+
+/// @cond
+} // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+} // namespace msgpack
+
+#endif // MSGPACK_TYPE_ARRAY_REF_HPP

include/msgpack/adaptor/boost/fusion.hpp

@@ -0,0 +1,168 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2015 KONDO Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_TYPE_BOOST_FUSION_HPP
+#define MSGPACK_TYPE_BOOST_FUSION_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/adaptor/check_container_size.hpp"
+#include "msgpack/meta.hpp"
+
+#if !defined (MSGPACK_USE_CPP03)
+#include "msgpack/adaptor/cpp11/tuple.hpp"
+#endif // #if !defined (MSGPACK_USE_CPP03)
+
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/algorithm/iteration/for_each.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/include/mpl.hpp>
+#include <boost/mpl/size.hpp>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace adaptor {
+
+#if !defined (MSGPACK_USE_CPP03)
+
+template <typename T>
+struct as<
+    T,
+    typename msgpack::enable_if<
+        boost::fusion::traits::is_sequence<T>::value &&
+        boost::mpl::fold<
+            T,
+            boost::mpl::bool_<true>,
+            boost::mpl::if_ <
+                boost::mpl::and_<
+                    boost::mpl::_1,
+                    msgpack::has_as<boost::mpl::_2>
+                >,
+                boost::mpl::bool_<true>,
+                boost::mpl::bool_<false>
+            >
+        >::type::value
+    >::type
+> {
+    T operator()(msgpack::object const& o) const {
+        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+        if (o.via.array.size != checked_get_container_size(boost::mpl::size<T>::value)) {
+            throw msgpack::type_error();
+        }
+        using tuple_t = decltype(to_tuple(std::declval<T>(), gen_seq<boost::mpl::size<T>::value>()));
+        return to_t(
+            o.as<tuple_t>(),
+            msgpack::gen_seq<boost::mpl::size<T>::value>());
+    }
+    template<std::size_t... Is, typename U>
+    static std::tuple<
+        typename std::remove_reference<
+            typename boost::fusion::result_of::at_c<T, Is>::type
+        >::type...>
+    to_tuple(U const& u, seq<Is...>) {
+        return std::make_tuple(boost::fusion::at_c<Is>(u)...);
+    }
+    template<std::size_t... Is, typename U>
+    static T to_t(U const& u, seq<Is...>) {
+        return T(std::get<Is>(u)...);
+    }
+};
+
+#endif // !defined (MSGPACK_USE_CPP03)
+
+template <typename T>
+struct convert<T, typename msgpack::enable_if<boost::fusion::traits::is_sequence<T>::value>::type > {
+    msgpack::object const& operator()(msgpack::object const& o, T& v) const {
+        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+        if (o.via.array.size != checked_get_container_size(boost::fusion::size(v))) {
+            throw msgpack::type_error();
+        }
+        uint32_t index = 0;
+        boost::fusion::for_each(v, convert_imp(o, index));
+        return o;
+    }
+private:
+    struct convert_imp {
+        convert_imp(msgpack::object const& obj, uint32_t& index):obj_(obj), index_(index) {}
+        template <typename U>
+        void operator()(U& v) const {
+            msgpack::adaptor::convert<U>()(obj_.via.array.ptr[index_++], v);
+        }
+    private:
+        msgpack::object const& obj_;
+        uint32_t& index_;
+    };
+};
+
+template <typename T>
+struct pack<T, typename msgpack::enable_if<boost::fusion::traits::is_sequence<T>::value>::type > {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const T& v) const {
+        uint32_t size = checked_get_container_size(boost::fusion::size(v));
+        o.pack_array(size);
+        boost::fusion::for_each(v, pack_imp<Stream>(o));
+        return o;
+    }
+private:
+    template <typename Stream>
+    struct pack_imp {
+        pack_imp(msgpack::packer<Stream>& stream):stream_(stream) {}
+        template <typename U>
+        void operator()(U const& v) const {
+            stream_.pack(v);
+        }
+    private:
+        msgpack::packer<Stream>& stream_;
+    };
+};
+
+template <typename T>
+struct object_with_zone<T, typename msgpack::enable_if<boost::fusion::traits::is_sequence<T>::value>::type > {
+    void operator()(msgpack::object::with_zone& o, const T& v) const {
+        uint32_t size = checked_get_container_size(boost::fusion::size(v));
+        o.type = msgpack::type::ARRAY;
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
+        o.via.array.size = size;
+        uint32_t count = 0;
+        boost::fusion::for_each(v, with_zone_imp(o, count));
+    }
+private:
+    struct with_zone_imp {
+        with_zone_imp(msgpack::object::with_zone const& obj, uint32_t& count):obj_(obj), count_(count) {}
+        template <typename U>
+        void operator()(U const& v) const {
+            obj_.via.array.ptr[count_++] = msgpack::object(v, obj_.zone);
+        }
+        msgpack::object::with_zone const& obj_;
+        uint32_t& count_;
+    };
+};
+
+} // namespace adaptor
+
+/// @cond
+} // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+} // namespace msgpack
+
+#endif // MSGPACK_TYPE_BOOST_FUSION_HPP

include/msgpack/adaptor/boost/msgpack_variant.hpp

@@ -0,0 +1,438 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2015 KONDO Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_HPP
+#define MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_HPP
+
+#if defined(MSGPACK_USE_BOOST)
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/adaptor/check_container_size.hpp"
+#include "msgpack/adaptor/boost/string_ref.hpp"
+
+#include "msgpack/adaptor/nil.hpp"
+#include "msgpack/adaptor/bool.hpp"
+#include "msgpack/adaptor/int.hpp"
+#include "msgpack/adaptor/float.hpp"
+#include "msgpack/adaptor/string.hpp"
+#include "msgpack/adaptor/vector_char.hpp"
+#include "msgpack/adaptor/raw.hpp"
+#include "msgpack/adaptor/ext.hpp"
+#include "msgpack/adaptor/vector.hpp"
+#include "msgpack/adaptor/map.hpp"
+
+#include <boost/variant.hpp>
+#include <boost/operators.hpp>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace type {
+
+
+template <typename STR, typename BIN, typename EXT>
+struct basic_variant :
+    boost::variant<
+        nil,               // NIL
+        bool,              // BOOL
+        int64_t,           // NEGATIVE_INTEGER
+        uint64_t,          // POSITIVE_INTEGER
+        double,            // FLOAT
+        std::string,       // STR
+#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+        boost::string_ref, // STR
+#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+        std::vector<char>, // BIN
+        msgpack::type::raw_ref, // BIN
+        ext,               // EXT
+        ext_ref,           // EXT
+        boost::recursive_wrapper<std::vector<basic_variant<STR, BIN, EXT> > >, // ARRAY
+        boost::recursive_wrapper<std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >, // MAP
+        boost::recursive_wrapper<std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >// MAP
+    >,
+    private boost::totally_ordered<basic_variant<STR, BIN, EXT> > {
+    typedef boost::variant<
+        nil,               // NIL
+        bool,              // BOOL
+        int64_t,           // NEGATIVE_INTEGER
+        uint64_t,          // POSITIVE_INTEGER
+        double,            // FLOAT
+        std::string,       // STR
+#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+        boost::string_ref, // STR
+#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+        std::vector<char>, // BIN
+        msgpack::type::raw_ref, // BIN
+        ext,               // EXT
+        ext_ref,           // EXT
+        boost::recursive_wrapper<std::vector<basic_variant<STR, BIN, EXT> > >, // ARRAY
+        boost::recursive_wrapper<std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >, // MAP
+        boost::recursive_wrapper<std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >// MAP
+    > base;
+    basic_variant() {}
+    template <typename T>
+    basic_variant(T const& t):base(t) {}
+    basic_variant(char const* p):base(std::string(p)) {}
+    basic_variant(char v) {
+        int_init(v);
+    }
+    basic_variant(signed char v) {
+        int_init(v);
+    }
+    basic_variant(unsigned char v):base(uint64_t(v)) {}
+    basic_variant(signed int v) {
+        int_init(v);
+    }
+    basic_variant(unsigned int v):base(uint64_t(v)) {}
+    basic_variant(signed long v) {
+        int_init(v);
+    }
+    basic_variant(unsigned long v):base(uint64_t(v)) {}
+    basic_variant(signed long long v) {
+        int_init(v);
+    }
+    basic_variant(unsigned long long v):base(uint64_t(v)) {}
+
+    bool is_nil() const {
+        return boost::get<nil>(this);
+    }
+    bool is_bool() const {
+        return boost::get<bool>(this);
+    }
+    bool is_int64_t() const {
+        return boost::get<int64_t>(this);
+    }
+    bool is_uint64_t() const {
+        return boost::get<uint64_t>(this);
+    }
+    bool is_double() const {
+        return boost::get<double>(this);
+    }
+    bool is_string() const {
+        return boost::get<std::string>(this);
+    }
+#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+    bool is_boost_string_ref() const {
+        return boost::get<boost::string_ref>(this);
+    }
+#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+    bool is_vector_char() const {
+        return boost::get<std::vector<char> >(this);
+    }
+    bool is_vector_char() {
+        return boost::get<std::vector<char> >(this);
+    }
+    bool is_raw_ref() const {
+        return boost::get<raw_ref>(this);
+    }
+    bool is_ext() const {
+        return boost::get<ext>(this);
+    }
+    bool is_ext_ref() const {
+        return boost::get<ext_ref>(this);
+    }
+    bool is_vector() const {
+        return boost::get<std::vector<basic_variant<STR, BIN, EXT> > >(this);
+    }
+    bool is_map() const {
+        return boost::get<std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >(this);
+    }
+    bool is_multimap() const {
+        return boost::get<std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >(this);
+    }
+
+    bool as_bool() const {
+        return boost::get<bool>(*this);
+    }
+    int64_t as_int64_t() const {
+        return boost::get<int64_t>(*this);
+    }
+    int64_t& as_int64_t() {
+        return boost::get<int64_t>(*this);
+    }
+    uint64_t as_uint64_t() const {
+        return boost::get<uint64_t>(*this);
+    }
+    uint64_t& as_uint64_t() {
+        return boost::get<uint64_t>(*this);
+    }
+    double as_double() const {
+        return boost::get<double>(*this);
+    }
+    double& as_double() {
+        return boost::get<double>(*this);
+    }
+    std::string const& as_string() const {
+        return boost::get<std::string>(*this);
+    }
+    std::string& as_string() {
+        return boost::get<std::string>(*this);
+    }
+#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+    boost::string_ref const& as_boost_string_ref() const {
+        return boost::get<boost::string_ref>(*this);
+    }
+    boost::string_ref& as_boost_string_ref() {
+        return boost::get<boost::string_ref>(*this);
+    }
+#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+    std::vector<char> const& as_vector_char() const {
+        return boost::get<std::vector<char> >(*this);
+    }
+    std::vector<char>& as_vector_char() {
+        return boost::get<std::vector<char> >(*this);
+    }
+    raw_ref const& as_raw_ref() const {
+        return boost::get<raw_ref>(*this);
+    }
+    ext const& as_ext() const {
+        return boost::get<ext>(*this);
+    }
+    ext& as_ext() {
+        return boost::get<ext>(*this);
+    }
+    ext_ref const& as_ext_ref() const {
+        return boost::get<ext_ref>(*this);
+    }
+    std::vector<basic_variant<STR, BIN, EXT> > const& as_vector() const {
+        return boost::get<std::vector<basic_variant<STR, BIN, EXT> > >(*this);
+    }
+    std::vector<basic_variant<STR, BIN, EXT> >& as_vector() {
+        return boost::get<std::vector<basic_variant<STR, BIN, EXT> > >(*this);
+    }
+    std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > const& as_map() const {
+        return boost::get<std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >(*this);
+    }
+    std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> >& as_map() {
+        return boost::get<std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >(*this);
+    }
+    std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > const& as_multimap() const {
+        return boost::get<std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >(*this);
+    }
+    std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> >& as_multimap() {
+        return boost::get<std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >(*this);
+    }
+private:
+    template <typename T>
+    void int_init(T v) {
+        if (v < 0) {
+            static_cast<base&>(*this) = int64_t(v);
+        }
+        else {
+            static_cast<base&>(*this) = uint64_t(v);
+        }
+    }
+};
+
+template <typename STR, typename BIN, typename EXT>
+inline bool operator<(basic_variant<STR, BIN, EXT> const& lhs, basic_variant<STR, BIN, EXT> const& rhs) {
+    return
+        static_cast<typename basic_variant<STR, BIN, EXT>::base const&>(lhs) <
+        static_cast<typename basic_variant<STR, BIN, EXT>::base const&>(rhs);
+}
+
+template <typename STR, typename BIN, typename EXT>
+inline bool operator==(basic_variant<STR, BIN, EXT> const& lhs, basic_variant<STR, BIN, EXT> const& rhs) {
+    return
+        static_cast<typename basic_variant<STR, BIN, EXT>::base const&>(lhs) ==
+        static_cast<typename basic_variant<STR, BIN, EXT>::base const&>(rhs);
+}
+
+typedef basic_variant<std::string, std::vector<char>, ext> variant;
+typedef basic_variant<
+#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+    boost::string_ref,
+#else  // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+    std::string,
+#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+    raw_ref, ext_ref> variant_ref;
+
+} // namespace type
+
+namespace adaptor {
+
+#if !defined (MSGPACK_USE_CPP03)
+
+template <typename STR, typename BIN, typename EXT>
+struct as<msgpack::type::basic_variant<STR, BIN, EXT> > {
+    msgpack::type::basic_variant<STR, BIN, EXT> operator()(msgpack::object const& o) const {
+        switch(o.type) {
+        case type::NIL:
+            return o.as<msgpack::type::nil>();
+        case type::BOOLEAN:
+            return o.as<bool>();
+        case type::POSITIVE_INTEGER:
+            return o.as<uint64_t>();
+        case type::NEGATIVE_INTEGER:
+            return o.as<int64_t>();
+        case type::FLOAT:
+            return o.as<double>();
+        case type::STR:
+            return o.as<STR>();
+        case type::BIN:
+            return o.as<BIN>();
+        case type::EXT:
+            return o.as<EXT>();
+        case type::ARRAY:
+            return o.as<std::vector<msgpack::type::basic_variant<STR, BIN, EXT> > >();
+        case type::MAP:
+            return o.as<std::multimap<msgpack::type::basic_variant<STR, BIN, EXT>, msgpack::type::basic_variant<STR, BIN, EXT> > >();
+        default:
+            break;
+        }
+        return msgpack::type::basic_variant<STR, BIN, EXT>();
+    }
+};
+
+#endif // !defined (MSGPACK_USE_CPP03)
+
+
+template <typename STR, typename BIN, typename EXT>
+struct convert<msgpack::type::basic_variant<STR, BIN, EXT> > {
+    msgpack::object const& operator()(
+        msgpack::object const& o,
+        msgpack::type::basic_variant<STR, BIN, EXT>& v) const {
+        switch(o.type) {
+        case type::NIL:
+            v = o.as<msgpack::type::nil>();
+            break;
+        case type::BOOLEAN:
+            v = o.as<bool>();
+            break;
+        case type::POSITIVE_INTEGER:
+            v = o.as<uint64_t>();
+            break;
+        case type::NEGATIVE_INTEGER:
+            v = o.as<int64_t>();
+            break;
+        case type::FLOAT:
+            v = o.as<double>();
+            break;
+        case type::STR:
+            v = o.as<STR>();
+            break;
+        case type::BIN:
+            v = o.as<BIN>();
+            break;
+        case type::EXT:
+            v = o.as<EXT>();
+            break;
+        case type::ARRAY:
+            v = o.as<std::vector<msgpack::type::basic_variant<STR, BIN, EXT> > >();
+            break;
+        case type::MAP:
+            v = o.as<std::multimap<msgpack::type::basic_variant<STR, BIN, EXT>, msgpack::type::basic_variant<STR, BIN, EXT> > >();
+            break;
+        default:
+            break;
+        }
+        return o;
+    }
+};
+
+namespace detail {
+
+template <typename Stream>
+struct pack_imp : boost::static_visitor<void> {
+    template <typename T>
+    void operator()(T const& value) const {
+        pack<T>()(o_, value);
+    }
+    pack_imp(packer<Stream>& o):o_(o) {}
+    packer<Stream>& o_;
+};
+
+} // namespace detail
+
+template <typename STR, typename BIN, typename EXT>
+struct pack<msgpack::type::basic_variant<STR, BIN, EXT> > {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const msgpack::type::basic_variant<STR, BIN, EXT>& v) const {
+        boost::apply_visitor(detail::pack_imp<Stream>(o), v);
+        return o;
+    }
+};
+
+namespace detail {
+
+struct object_imp : boost::static_visitor<void> {
+    void operator()(msgpack::type::nil const& v) const {
+        object<msgpack::type::nil>()(o_, v);
+    }
+    void operator()(bool const& v) const {
+        object<bool>()(o_, v);
+    }
+    void operator()(uint64_t const& v) const {
+        object<uint64_t>()(o_, v);
+    }
+    void operator()(int64_t const& v) const {
+        object<int64_t>()(o_, v);
+    }
+    void operator()(double const& v) const {
+        object<double>()(o_, v);
+    }
+    template <typename T>
+    void operator()(T const&) const {
+        throw msgpack::type_error();
+    }
+    object_imp(msgpack::object& o):o_(o) {}
+    msgpack::object& o_;
+};
+
+} // namespace detail
+
+template <typename STR, typename BIN, typename EXT>
+struct object<msgpack::type::basic_variant<STR, BIN, EXT> > {
+    void operator()(msgpack::object& o, const msgpack::type::basic_variant<STR, BIN, EXT>& v) const {
+        boost::apply_visitor(detail::object_imp(o), v);
+    }
+};
+
+namespace detail {
+
+struct object_with_zone_imp : boost::static_visitor<void> {
+    template <typename T>
+    void operator()(T const& v) const {
+        object_with_zone<T>()(o_, v);
+    }
+    object_with_zone_imp(msgpack::object::with_zone& o):o_(o) {}
+    msgpack::object::with_zone& o_;
+};
+
+} // namespace detail
+
+template <typename STR, typename BIN, typename EXT>
+struct object_with_zone<msgpack::type::basic_variant<STR, BIN, EXT> > {
+    void operator()(msgpack::object::with_zone& o, const msgpack::type::basic_variant<STR, BIN, EXT>& v) const {
+        boost::apply_visitor(detail::object_with_zone_imp(o), v);
+    }
+};
+
+} // namespace adaptor
+
+/// @cond
+} // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+} // namespace msgpack
+
+#endif // MSGPACK_USE_BOOST
+#endif // MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_HPP

include/msgpack/adaptor/boost/optional.hpp

@@ -0,0 +1,104 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2015 KONDO Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_TYPE_BOOST_OPTIONAL_HPP
+#define MSGPACK_TYPE_BOOST_OPTIONAL_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/adaptor/check_container_size.hpp"
+
+// To suppress warning on Boost.1.58.0
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__)
+
+#include <boost/optional.hpp>
+
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__)
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace adaptor {
+
+#if !defined (MSGPACK_USE_CPP03)
+
+template <typename T>
+struct as<boost::optional<T>, typename std::enable_if<msgpack::has_as<T>::value>::type> {
+    boost::optional<T> operator()(msgpack::object const& o) const {
+        if(o.is_nil()) return boost::none;
+        return o.as<T>();
+    }
+};
+
+#endif // !defined (MSGPACK_USE_CPP03)
+
+template <typename T>
+struct convert<boost::optional<T> > {
+    msgpack::object const& operator()(msgpack::object const& o, boost::optional<T>& v) const {
+        if(o.is_nil()) v = boost::none;
+        else {
+            T t;
+            msgpack::adaptor::convert<T>()(o, t);
+            v = t;
+        }
+        return o;
+    }
+};
+
+template <typename T>
+struct pack<boost::optional<T> > {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const boost::optional<T>& v) const {
+        if (v) o.pack(*v);
+        else o.pack_nil();
+        return o;
+    }
+};
+
+template <typename T>
+struct object<boost::optional<T> > {
+    void operator()(msgpack::object& o, const boost::optional<T>& v) const {
+        if (v) msgpack::adaptor::object<T>()(o, *v);
+        else o.type = msgpack::type::NIL;
+    }
+};
+
+template <typename T>
+struct object_with_zone<boost::optional<T> > {
+    void operator()(msgpack::object::with_zone& o, const boost::optional<T>& v) const {
+        if (v) msgpack::adaptor::object_with_zone<T>()(o, *v);
+        else o.type = msgpack::type::NIL;
+    }
+};
+
+} // namespace adaptor
+
+/// @cond
+} // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+} // namespace msgpack
+
+#endif // MSGPACK_TYPE_BOOST_OPTIONAL_HPP

include/msgpack/adaptor/boost/string_ref.hpp

@@ -0,0 +1,95 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2015 KONDO Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_TYPE_BOOST_STRING_REF_HPP
+#define MSGPACK_TYPE_BOOST_STRING_REF_HPP
+
+#include <boost/version.hpp>
+#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/adaptor/check_container_size.hpp"
+
+#include <boost/utility/string_ref.hpp>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace adaptor {
+
+template <>
+struct convert<boost::string_ref> {
+    msgpack::object const& operator()(msgpack::object const& o, boost::string_ref& v) const {
+        switch (o.type) {
+        case msgpack::type::BIN:
+            v = boost::string_ref(o.via.bin.ptr, o.via.bin.size);
+            break;
+        case msgpack::type::STR:
+            v = boost::string_ref(o.via.str.ptr, o.via.str.size);
+            break;
+        default:
+            throw msgpack::type_error();
+            break;
+        }
+        return o;
+    }
+};
+
+template <>
+struct pack<boost::string_ref> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const boost::string_ref& v) const {
+        uint32_t size = checked_get_container_size(v.size());
+        o.pack_str(size);
+        o.pack_str_body(v.data(), size);
+        return o;
+    }
+};
+
+template <>
+struct object<boost::string_ref> {
+    void operator()(msgpack::object& o, const boost::string_ref& v) const {
+        uint32_t size = checked_get_container_size(v.size());
+        o.type = msgpack::type::STR;
+        o.via.str.ptr = v.data();
+        o.via.str.size = size;
+    }
+};
+
+template <>
+struct object_with_zone<boost::string_ref> {
+    void operator()(msgpack::object::with_zone& o, const boost::string_ref& v) const {
+        static_cast<msgpack::object&>(o) << v;
+    }
+};
+
+
+} // namespace adaptor
+
+/// @cond
+} // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+} // namespace msgpack
+
+#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+
+#endif // MSGPACK_TYPE_BOOST_STRING_REF_HPP

include/msgpack/adaptor/check_container_size.hpp

@@ -44,7 +44,17 @@ inline void check_container_size(std::size_t size) {
 }
 
 template <>
-inline void check_container_size<4>(std::size_t size) {
+inline void check_container_size<4>(std::size_t /*size*/) {
+}
+
+template <std::size_t N>
+inline void check_container_size_for_ext(std::size_t size) {
+    if (size > 0xffffffff) throw container_size_overflow("container size overflow");
+}
+
+template <>
+inline void check_container_size_for_ext<4>(std::size_t size) {
+    if (size > 0xfffffffe) throw container_size_overflow("container size overflow");
 }
 
 } // namespace detail

include/msgpack/adaptor/cpp11/array.hpp

@@ -22,6 +22,7 @@
 #include "msgpack/versioning.hpp"
 #include "msgpack/adaptor/adaptor_base.hpp"
 #include "msgpack/adaptor/check_container_size.hpp"
+#include "msgpack/meta.hpp"
 
 #include <array>
 
@@ -33,6 +34,60 @@ MSGPACK_API_VERSION_NAMESPACE(v1) {
 
 namespace adaptor {
 
+namespace detail {
+
+namespace array {
+
+template<typename T, std::size_t N1, std::size_t... I1, std::size_t N2, std::size_t... I2>
+inline std::array<T, N1+N2> concat(
+    std::array<T, N1>&& a1,
+    std::array<T, N2>&& a2,
+    msgpack::seq<I1...>,
+    msgpack::seq<I2...>) {
+    return {{ std::move(a1[I1])..., std::move(a2[I2])... }};
+}
+
+template<typename T, std::size_t N1, std::size_t N2>
+inline std::array<T, N1+N2> concat(std::array<T, N1>&& a1, std::array<T, N2>&& a2) {
+    return concat(std::move(a1), std::move(a2), msgpack::gen_seq<N1>(), msgpack::gen_seq<N2>());
+}
+
+template <typename T, std::size_t N>
+struct as_impl {
+    static std::array<T, N> as(msgpack::object const& o) {
+        msgpack::object* p = o.via.array.ptr + N - 1;
+        return concat(as_impl<T, N-1>::as(o), std::array<T, 1>{{p->as<T>()}});
+    }
+};
+
+template <typename T>
+struct as_impl<T, 1> {
+    static std::array<T, 1> as(msgpack::object const& o) {
+        msgpack::object* p = o.via.array.ptr;
+        return std::array<T, 1>{{p->as<T>()}};
+    }
+};
+
+template <typename T>
+struct as_impl<T, 0> {
+    static std::array<T, 0> as(msgpack::object const&) {
+        return std::array<T, 0>();
+    }
+};
+
+} // namespace array
+
+} // namespace detail
+
+template <typename T, std::size_t N>
+struct as<std::array<T, N>, typename std::enable_if<msgpack::has_as<T>::value>::type> {
+    std::array<T, N> operator()(msgpack::object const& o) const {
+        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+        if(o.via.array.size != N) { throw msgpack::type_error(); }
+        return detail::array::as_impl<T, N>::as(o);
+    }
+};
+
 template <typename T, std::size_t N>
 struct convert<std::array<T, N>> {
     msgpack::object const& operator()(msgpack::object const& o, std::array<T, N>& v) const {

include/msgpack/adaptor/cpp11/array_unsigned_char.hpp

@@ -0,0 +1,97 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2014-2015 KONDO Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_TYPE_ARRAY_UNSIGNED_CHAR_HPP
+#define MSGPACK_TYPE_ARRAY_UNSIGNED_CHAR_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/adaptor/check_container_size.hpp"
+
+#include <array>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace adaptor {
+
+template <std::size_t N>
+struct convert<std::array<unsigned char, N>> {
+    msgpack::object const& operator()(msgpack::object const& o, std::array<unsigned char, N>& v) const {
+        switch (o.type) {
+        case msgpack::type::BIN:
+            if(o.via.bin.size != N) { throw msgpack::type_error(); }
+            std::memcpy(v.data(), o.via.bin.ptr, o.via.bin.size);
+            break;
+        case msgpack::type::STR:
+            if(o.via.str.size != N) { throw msgpack::type_error(); }
+            std::memcpy(v.data(), o.via.str.ptr, N);
+            break;
+        default:
+            throw msgpack::type_error();
+            break;
+        }
+        return o;
+    }
+};
+
+template <std::size_t N>
+struct pack<std::array<unsigned char, N>> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::array<unsigned char, N>& v) const {
+        uint32_t size = checked_get_container_size(v.size());
+        o.pack_bin(size);
+        o.pack_bin_body(reinterpret_cast<char const*>(v.data()), size);
+
+        return o;
+    }
+};
+
+template <std::size_t N>
+struct object<std::array<unsigned char, N>> {
+    void operator()(msgpack::object& o, const std::array<unsigned char, N>& v) const {
+        uint32_t size = checked_get_container_size(v.size());
+        o.type = msgpack::type::BIN;
+        o.via.bin.ptr = reinterpret_cast<char const*>(v.data());
+        o.via.bin.size = size;
+    }
+};
+
+template <std::size_t N>
+struct object_with_zone<std::array<unsigned char, N>> {
+    void operator()(msgpack::object::with_zone& o, const std::array<unsigned char, N>& v) const {
+        uint32_t size = checked_get_container_size(v.size());
+        o.type = msgpack::type::BIN;
+        char* ptr = static_cast<char*>(o.zone.allocate_align(size));
+        o.via.bin.ptr = ptr;
+        o.via.bin.size = size;
+        std::memcpy(ptr, v.data(), size);
+    }
+};
+
+} // namespace adaptor
+
+/// @cond
+} // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+} // namespace msgpack
+
+#endif // MSGPACK_TYPE_ARRAY_UNSIGNED_CHAR_HPP

include/msgpack/adaptor/cpp11/forward_list.hpp

@@ -33,9 +33,24 @@ MSGPACK_API_VERSION_NAMESPACE(v1) {
 
 namespace adaptor {
 
-template <typename T>
-struct convert<std::forward_list<T>> {
-    msgpack::object const& operator()(msgpack::object const& o, std::forward_list<T>& v) const {
+template <typename T, typename Alloc>
+    struct as<std::forward_list<T, Alloc>, typename std::enable_if<msgpack::has_as<T>::value>::type> {
+    std::forward_list<T, Alloc> operator()(msgpack::object const& o) const {
+        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+        std::forward_list<T, Alloc> v;
+        msgpack::object* p = o.via.array.ptr + o.via.array.size;
+        msgpack::object* const pend = o.via.array.ptr;
+        while (p != pend) {
+            --p;
+            v.push_front(p->as<T>());
+        }
+        return v;
+    }
+};
+
+template <typename T, typename Alloc>
+struct convert<std::forward_list<T, Alloc>> {
+    msgpack::object const& operator()(msgpack::object const& o, std::forward_list<T, Alloc>& v) const {
         if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
         v.resize(o.via.array.size);
         msgpack::object* p = o.via.array.ptr;
@@ -47,10 +62,10 @@ struct convert<std::forward_list<T>> {
     }
 };
 
-template <typename T>
-struct pack<std::forward_list<T>> {
+template <typename T, typename Alloc>
+struct pack<std::forward_list<T, Alloc>> {
     template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::forward_list<T>& v) const {
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::forward_list<T, Alloc>& v) const {
         uint32_t size = checked_get_container_size(std::distance(v.begin(), v.end()));
         o.pack_array(size);
         for(auto const& e : v) o.pack(e);
@@ -58,9 +73,9 @@ struct pack<std::forward_list<T>> {
     }
 };
 
-template <typename T>
-struct object_with_zone<std::forward_list<T>> {
-    void operator()(msgpack::object::with_zone& o, const std::forward_list<T>& v) const {
+template <typename T, typename Alloc>
+struct object_with_zone<std::forward_list<T, Alloc>> {
+    void operator()(msgpack::object::with_zone& o, const std::forward_list<T, Alloc>& v) const {
         o.type = msgpack::type::ARRAY;
         if(v.empty()) {
             o.via.array.ptr = nullptr;

include/msgpack/adaptor/cpp11/reference_wrapper.hpp

@@ -0,0 +1,76 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2015 KONDO Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+
+#ifndef MSGPACK_CPP11_REFERENCE_WRAPPER_HPP
+#define MSGPACK_CPP11_REFERENCE_WRAPPER_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/adaptor/check_container_size.hpp"
+
+#include <memory>
+#include <type_traits>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace adaptor {
+
+template <typename T>
+struct convert<std::reference_wrapper<T>> {
+    msgpack::object const& operator()(msgpack::object const& o, std::reference_wrapper<T>& v) const {
+        msgpack::adaptor::convert<T>()(o, v.get());
+        return o;
+    }
+};
+
+template <typename T>
+struct pack<std::reference_wrapper<T>> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::reference_wrapper<T>& v) const {
+        o.pack(v.get());
+        return o;
+    }
+};
+
+template <typename T>
+struct object<std::reference_wrapper<T> > {
+    void operator()(msgpack::object& o, const std::reference_wrapper<T>& v) const {
+        msgpack::adaptor::object<typename std::remove_const<T>::type>()(o, v.get());
+    }
+};
+
+template <typename T>
+struct object_with_zone<std::reference_wrapper<T>> {
+    void operator()(msgpack::object::with_zone& o, const std::reference_wrapper<T>& v) const {
+        msgpack::adaptor::object_with_zone<typename std::remove_const<T>::type>()(o, v.get());
+    }
+};
+
+} // namespace adaptor
+
+/// @cond
+} // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+} // namespace msgpack
+
+#endif // MSGPACK_CPP11_REFERENCE_WRAPPER_HPP

include/msgpack/adaptor/cpp11/shared_ptr.hpp

@@ -0,0 +1,90 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2015 KONDO Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+
+#ifndef MSGPACK_CPP11_SHARED_PTR_HPP
+#define MSGPACK_CPP11_SHARED_PTR_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/adaptor/check_container_size.hpp"
+
+#include <memory>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace adaptor {
+
+template <typename T>
+struct as<std::shared_ptr<T>, typename std::enable_if<msgpack::has_as<T>::value>::type> {
+    std::shared_ptr<T> operator()(msgpack::object const& o) const {
+        if(o.is_nil()) return nullptr;
+        return std::make_shared<T>(o.as<T>());
+    }
+};
+
+template <typename T>
+struct convert<std::shared_ptr<T>> {
+    msgpack::object const& operator()(msgpack::object const& o, std::shared_ptr<T>& v) const {
+        if(o.is_nil()) v.reset();
+        else {
+            v = std::make_shared<T>();
+            msgpack::adaptor::convert<T>()(o, *v);
+        }
+        return o;
+    }
+};
+
+template <typename T>
+struct pack<std::shared_ptr<T>> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::shared_ptr<T>& v) const {
+        if (v) o.pack(*v);
+        else o.pack_nil();
+        return o;
+    }
+};
+
+template <typename T>
+struct object<std::shared_ptr<T> > {
+    void operator()(msgpack::object& o, const std::shared_ptr<T>& v) const {
+        if (v) msgpack::adaptor::object<T>()(o, *v);
+        else o.type = msgpack::type::NIL;
+    }
+};
+
+template <typename T>
+struct object_with_zone<std::shared_ptr<T>> {
+    void operator()(msgpack::object::with_zone& o, const std::shared_ptr<T>& v) const {
+        if (v) msgpack::adaptor::object_with_zone<T>()(o, *v);
+        else o.type = msgpack::type::NIL;
+    }
+};
+
+} // namespace adaptor
+
+/// @cond
+} // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+} // namespace msgpack
+
+#endif // MSGPACK_CPP11_SHARED_PTR_HPP

include/msgpack/adaptor/cpp11/tuple.hpp

@@ -21,6 +21,7 @@
 #include "msgpack/versioning.hpp"
 #include "msgpack/adaptor/adaptor_base.hpp"
 #include "msgpack/adaptor/check_container_size.hpp"
+#include "msgpack/meta.hpp"
 
 #include <tuple>
 
@@ -41,15 +42,6 @@ struct StdTuplePacker {
     }
 };
 
-template <typename Stream, typename Tuple>
-struct StdTuplePacker<Stream, Tuple, 1> {
-    static void pack (
-        msgpack::packer<Stream>& o,
-        const Tuple& v) {
-        o.pack(std::get<0>(v));
-    }
-};
-
 template <typename Stream, typename Tuple>
 struct StdTuplePacker<Stream, Tuple, 0> {
     static void pack (
@@ -77,6 +69,32 @@ struct pack<std::tuple<Args...>> {
 
 // --- Convert from tuple to object ---
 
+template <typename... Args>
+struct StdTupleAs;
+
+template <typename T, typename... Args>
+struct StdTupleAsImpl {
+    static std::tuple<T, Args...> as(msgpack::object const& o) {
+        return std::tuple_cat(
+            std::make_tuple(o.via.array.ptr[o.via.array.size - sizeof...(Args) - 1].as<T>()),
+            StdTupleAs<Args...>::as(o));
+    }
+};
+
+template <typename... Args>
+struct StdTupleAs {
+    static std::tuple<Args...> as(msgpack::object const& o) {
+        return StdTupleAsImpl<Args...>::as(o);
+    }
+};
+
+template <>
+struct StdTupleAs<> {
+    static std::tuple<> as (msgpack::object const&) {
+        return std::tuple<>();
+    }
+};
+
 template <typename Tuple, std::size_t N>
 struct StdTupleConverter {
     static void convert(
@@ -87,15 +105,6 @@ struct StdTupleConverter {
     }
 };
 
-template <typename Tuple>
-struct StdTupleConverter<Tuple, 1> {
-    static void convert (
-        msgpack::object const& o,
-        Tuple& v) {
-        o.via.array.ptr[0].convert<typename std::remove_reference<decltype(std::get<0>(v))>::type>(std::get<0>(v));
-    }
-};
-
 template <typename Tuple>
 struct StdTupleConverter<Tuple, 0> {
     static void convert (
@@ -106,6 +115,16 @@ struct StdTupleConverter<Tuple, 0> {
 
 namespace adaptor {
 
+template <typename... Args>
+struct as<std::tuple<Args...>, typename std::enable_if<msgpack::all_of<msgpack::has_as, Args...>::value>::type>  {
+    std::tuple<Args...> operator()(
+        msgpack::object const& o) const {
+        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+        if (o.via.array.size < sizeof...(Args)) { throw msgpack::type_error(); }
+        return StdTupleAs<Args...>::as(o);
+    }
+};
+
 template <typename... Args>
 struct convert<std::tuple<Args...>> {
     msgpack::object const& operator()(
@@ -131,15 +150,6 @@ struct StdTupleToObjectWithZone {
     }
 };
 
-template <typename Tuple>
-struct StdTupleToObjectWithZone<Tuple, 1> {
-    static void convert (
-        msgpack::object::with_zone& o,
-        const Tuple& v) {
-        o.via.array.ptr[0] = msgpack::object(std::get<0>(v), o.zone);
-    }
-};
-
 template <typename Tuple>
 struct StdTupleToObjectWithZone<Tuple, 0> {
     static void convert (

include/msgpack/adaptor/cpp11/unique_ptr.hpp

@@ -0,0 +1,90 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2015 KONDO Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+
+#ifndef MSGPACK_CPP11_UNIQUE_PTR_HPP
+#define MSGPACK_CPP11_UNIQUE_PTR_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/adaptor/check_container_size.hpp"
+
+#include <memory>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace adaptor {
+
+template <typename T>
+struct as<std::unique_ptr<T>, typename std::enable_if<msgpack::has_as<T>::value>::type> {
+    std::unique_ptr<T> operator()(msgpack::object const& o) const {
+        if(o.is_nil()) return nullptr;
+        return std::unique_ptr<T>(new T(o.as<T>()));
+    }
+};
+
+template <typename T>
+struct convert<std::unique_ptr<T>> {
+    msgpack::object const& operator()(msgpack::object const& o, std::unique_ptr<T>& v) const {
+        if(o.is_nil()) v.reset();
+        else {
+            v.reset(new T);
+            msgpack::adaptor::convert<T>()(o, *v);
+        }
+        return o;
+    }
+};
+
+template <typename T>
+struct pack<std::unique_ptr<T>> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::unique_ptr<T>& v) const {
+        if (v) o.pack(*v);
+        else o.pack_nil();
+        return o;
+    }
+};
+
+template <typename T>
+struct object<std::unique_ptr<T> > {
+    void operator()(msgpack::object& o, const std::unique_ptr<T>& v) const {
+        if (v) msgpack::adaptor::object<T>()(o, *v);
+        else o.type = msgpack::type::NIL;
+    }
+};
+
+template <typename T>
+struct object_with_zone<std::unique_ptr<T>> {
+    void operator()(msgpack::object::with_zone& o, const std::unique_ptr<T>& v) const {
+        if (v) msgpack::adaptor::object_with_zone<T>()(o, *v);
+        else o.type = msgpack::type::NIL;
+    }
+};
+
+} // namespace adaptor
+
+/// @cond
+} // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+} // namespace msgpack
+
+#endif // MSGPACK_CPP11_UNIQUE_PTR_HPP

include/msgpack/adaptor/cpp11/unordered_map.hpp

@@ -32,30 +32,46 @@ MSGPACK_API_VERSION_NAMESPACE(v1) {
 
 namespace adaptor {
 
-template <typename K, typename V>
-struct convert<std::unordered_map<K, V>> {
-    msgpack::object const& operator()(msgpack::object const& o, std::unordered_map<K, V>& v) const {
+template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
+struct as<
+    std::unordered_map<K, V, Hash, Compare, Alloc>,
+    typename std::enable_if<msgpack::has_as<K>::value && msgpack::has_as<V>::value>::type> {
+    std::unordered_map<K, V, Hash, Compare, Alloc> operator()(msgpack::object const& o) const {
         if (o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
         msgpack::object_kv* p(o.via.map.ptr);
         msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
-        std::unordered_map<K, V> tmp;
+        std::unordered_map<K, V, Hash, Compare, Alloc> v;
+        for (; p != pend; ++p) {
+            v.emplace(p->key.as<K>(), p->val.as<V>());
+        }
+        return v;
+    }
+};
+
+template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
+struct convert<std::unordered_map<K, V, Hash, Compare, Alloc>> {
+    msgpack::object const& operator()(msgpack::object const& o, std::unordered_map<K, V, Hash, Compare, Alloc>& v) const {
+        if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
+        msgpack::object_kv* p(o.via.map.ptr);
+        msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
+        std::unordered_map<K, V, Hash, Compare, Alloc> tmp;
         for(; p != pend; ++p) {
             K key;
             p->key.convert(key);
-            p->val.convert(tmp[key]);
+            p->val.convert(tmp[std::move(key)]);
         }
-        tmp.swap(v);
+        v = std::move(tmp);
         return o;
     }
 };
 
-template <typename K, typename V>
-struct pack<std::unordered_map<K, V>> {
+template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
+struct pack<std::unordered_map<K, V, Hash, Compare, Alloc>> {
     template <typename Stream>
-        msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::unordered_map<K,V>& v) const {
+        msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::unordered_map<K, V, Hash, Compare, Alloc>& v) const {
         uint32_t size = checked_get_container_size(v.size());
         o.pack_map(size);
-        for(typename std::unordered_map<K,V>::const_iterator it(v.begin()), it_end(v.end());
+        for(typename std::unordered_map<K, V, Hash, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
             it != it_end; ++it) {
             o.pack(it->first);
             o.pack(it->second);
@@ -64,9 +80,9 @@ struct pack<std::unordered_map<K, V>> {
     }
 };
 
-template <typename K, typename V>
-struct object_with_zone<std::unordered_map<K, V>> {
-    void operator()(msgpack::object::with_zone& o, const std::unordered_map<K,V>& v) const {
+template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
+struct object_with_zone<std::unordered_map<K, V, Hash, Compare, Alloc>> {
+    void operator()(msgpack::object::with_zone& o, const std::unordered_map<K, V, Hash, Compare, Alloc>& v) const {
         o.type = msgpack::type::MAP;
         if(v.empty()) {
             o.via.map.ptr  = nullptr;
@@ -77,7 +93,7 @@ struct object_with_zone<std::unordered_map<K, V>> {
             msgpack::object_kv* const pend = p + size;
             o.via.map.ptr  = p;
             o.via.map.size = size;
-            typename std::unordered_map<K,V>::const_iterator it(v.begin());
+            typename std::unordered_map<K, V, Hash, Compare, Alloc>::const_iterator it(v.begin());
             do {
                 p->key = msgpack::object(it->first, o.zone);
                 p->val = msgpack::object(it->second, o.zone);
@@ -89,31 +105,47 @@ struct object_with_zone<std::unordered_map<K, V>> {
 };
 
 
-template <typename K, typename V>
-struct convert<std::unordered_multimap<K, V>> {
-    msgpack::object const& operator()(msgpack::object const& o, std::unordered_multimap<K, V>& v) const {
+template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
+struct as<
+    std::unordered_multimap<K, V, Hash, Compare, Alloc>,
+    typename std::enable_if<msgpack::has_as<K>::value && msgpack::has_as<V>::value>::type> {
+    std::unordered_multimap<K, V, Hash, Compare, Alloc> operator()(msgpack::object const& o) const {
         if (o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
         msgpack::object_kv* p(o.via.map.ptr);
         msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
-        std::unordered_multimap<K, V> tmp;
+        std::unordered_multimap<K, V, Hash, Compare, Alloc> v;
+        for (; p != pend; ++p) {
+            v.emplace(p->key.as<K>(), p->val.as<V>());
+        }
+        return v;
+    }
+};
+
+template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
+struct convert<std::unordered_multimap<K, V, Hash, Compare, Alloc>> {
+    msgpack::object const& operator()(msgpack::object const& o, std::unordered_multimap<K, V, Hash, Compare, Alloc>& v) const {
+        if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
+        msgpack::object_kv* p(o.via.map.ptr);
+        msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
+        std::unordered_multimap<K, V, Hash, Compare, Alloc> tmp;
         for(; p != pend; ++p) {
             std::pair<K, V> value;
             p->key.convert(value.first);
             p->val.convert(value.second);
-            tmp.insert(value);
+            tmp.insert(std::move(value));
         }
-        tmp.swap(v);
+        v = std::move(tmp);
         return o;
     }
 };
 
-template <typename K, typename V>
-struct pack<std::unordered_multimap<K, V>> {
+template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
+struct pack<std::unordered_multimap<K, V, Hash, Compare, Alloc>> {
     template <typename Stream>
-        msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::unordered_multimap<K,V>& v) const {
+        msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::unordered_multimap<K, V, Hash, Compare, Alloc>& v) const {
         uint32_t size = checked_get_container_size(v.size());
         o.pack_map(size);
-        for(typename std::unordered_multimap<K,V>::const_iterator it(v.begin()), it_end(v.end());
+        for(typename std::unordered_multimap<K, V, Hash, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
             it != it_end; ++it) {
             o.pack(it->first);
             o.pack(it->second);
@@ -122,9 +154,9 @@ struct pack<std::unordered_multimap<K, V>> {
     }
 };
 
-template <typename K, typename V>
-struct object_with_zone<std::unordered_multimap<K, V>> {
-    void operator()(msgpack::object::with_zone& o, const std::unordered_multimap<K,V>& v) const {
+template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
+struct object_with_zone<std::unordered_multimap<K, V, Hash, Compare, Alloc>> {
+    void operator()(msgpack::object::with_zone& o, const std::unordered_multimap<K, V, Hash, Compare, Alloc>& v) const {
         o.type = msgpack::type::MAP;
         if(v.empty()) {
             o.via.map.ptr  = nullptr;
@@ -135,7 +167,7 @@ struct object_with_zone<std::unordered_multimap<K, V>> {
             msgpack::object_kv* const pend = p + size;
             o.via.map.ptr  = p;
             o.via.map.size = size;
-            typename std::unordered_multimap<K,V>::const_iterator it(v.begin());
+            typename std::unordered_multimap<K, V, Hash, Compare, Alloc>::const_iterator it(v.begin());
             do {
                 p->key = msgpack::object(it->first, o.zone);
                 p->val = msgpack::object(it->second, o.zone);

include/msgpack/adaptor/cpp11/unordered_set.hpp

@@ -32,29 +32,44 @@ MSGPACK_API_VERSION_NAMESPACE(v1) {
 
 namespace adaptor {
 
-template <typename T>
-struct convert<std::unordered_set<T>> {
-    msgpack::object const& operator()(msgpack::object const& o, std::unordered_set<T>& v) const {
+template <typename Key, typename Hash, typename Compare, typename Alloc>
+struct as<std::unordered_set<Key, Hash, Compare, Alloc>, typename std::enable_if<msgpack::has_as<Key>::value>::type> {
+    std::unordered_set<Key, Hash, Compare, Alloc> operator()(msgpack::object const& o) const {
         if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
         msgpack::object* p = o.via.array.ptr + o.via.array.size;
         msgpack::object* const pbegin = o.via.array.ptr;
-        std::unordered_set<T> tmp;
+        std::unordered_set<Key, Hash, Compare, Alloc> v;
         while (p > pbegin) {
             --p;
-            tmp.insert(p->as<T>());
+            v.insert(p->as<Key>());
         }
-        tmp.swap(v);
+        return v;
+    }
+};
+
+template <typename Key, typename Hash, typename Compare, typename Alloc>
+struct convert<std::unordered_set<Key, Hash, Compare, Alloc>> {
+    msgpack::object const& operator()(msgpack::object const& o, std::unordered_set<Key, Hash, Compare, Alloc>& v) const {
+        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+        msgpack::object* p = o.via.array.ptr + o.via.array.size;
+        msgpack::object* const pbegin = o.via.array.ptr;
+        std::unordered_set<Key, Hash, Compare, Alloc> tmp;
+        while(p > pbegin) {
+            --p;
+            tmp.insert(p->as<Key>());
+        }
+        v = std::move(tmp);
         return o;
     }
 };
 
-template <typename T>
-struct pack<std::unordered_set<T>> {
+template <typename Key, typename Hash, typename Compare, typename Alloc>
+struct pack<std::unordered_set<Key, Hash, Compare, Alloc>> {
     template <typename Stream>
-        msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::unordered_set<T>& v) const {
+        msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::unordered_set<Key, Hash, Compare, Alloc>& v) const {
         uint32_t size = checked_get_container_size(v.size());
         o.pack_array(size);
-        for(typename std::unordered_set<T>::const_iterator it(v.begin()), it_end(v.end());
+        for(typename std::unordered_set<Key, Hash, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
             it != it_end; ++it) {
             o.pack(*it);
         }
@@ -62,9 +77,9 @@ struct pack<std::unordered_set<T>> {
     }
 };
 
-template <typename T>
-struct object_with_zone<std::unordered_set<T>> {
-    void operator()(msgpack::object::with_zone& o, const std::unordered_set<T>& v) const {
+template <typename Key, typename Hash, typename Compare, typename Alloc>
+struct object_with_zone<std::unordered_set<Key, Hash, Compare, Alloc>> {
+    void operator()(msgpack::object::with_zone& o, const std::unordered_set<Key, Hash, Compare, Alloc>& v) const {
         o.type = msgpack::type::ARRAY;
         if(v.empty()) {
             o.via.array.ptr = nullptr;
@@ -75,7 +90,7 @@ struct object_with_zone<std::unordered_set<T>> {
             msgpack::object* const pend = p + size;
             o.via.array.ptr = p;
             o.via.array.size = size;
-            typename std::unordered_set<T>::const_iterator it(v.begin());
+            typename std::unordered_set<Key, Hash, Compare, Alloc>::const_iterator it(v.begin());
             do {
                 *p = msgpack::object(*it, o.zone);
                 ++p;
@@ -86,29 +101,44 @@ struct object_with_zone<std::unordered_set<T>> {
 };
 
 
-template <typename T>
-struct convert<std::unordered_multiset<T>> {
-    msgpack::object const& operator()(msgpack::object const& o, std::unordered_multiset<T>& v) const {
+template <typename Key, typename Hash, typename Compare, typename Alloc>
+struct as<std::unordered_multiset<Key, Hash, Compare, Alloc>, typename std::enable_if<msgpack::has_as<Key>::value>::type> {
+    std::unordered_multiset<Key, Hash, Compare, Alloc> operator()(msgpack::object const& o) const {
         if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
         msgpack::object* p = o.via.array.ptr + o.via.array.size;
         msgpack::object* const pbegin = o.via.array.ptr;
-        std::unordered_multiset<T> tmp;
+        std::unordered_multiset<Key, Hash, Compare, Alloc> v;
         while (p > pbegin) {
             --p;
-            tmp.insert(p->as<T>());
+            v.insert(p->as<Key>());
         }
-        tmp.swap(v);
+        return v;
+    }
+};
+
+template <typename Key, typename Hash, typename Compare, typename Alloc>
+struct convert<std::unordered_multiset<Key, Hash, Compare, Alloc>> {
+    msgpack::object const& operator()(msgpack::object const& o, std::unordered_multiset<Key, Hash, Compare, Alloc>& v) const {
+        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+        msgpack::object* p = o.via.array.ptr + o.via.array.size;
+        msgpack::object* const pbegin = o.via.array.ptr;
+        std::unordered_multiset<Key, Hash, Compare, Alloc> tmp;
+        while(p > pbegin) {
+            --p;
+            tmp.insert(p->as<Key>());
+        }
+        v = std::move(tmp);
         return o;
     }
 };
 
-template <typename T>
-struct pack<std::unordered_multiset<T>> {
+template <typename Key, typename Hash, typename Compare, typename Alloc>
+struct pack<std::unordered_multiset<Key, Hash, Compare, Alloc>> {
     template <typename Stream>
-        msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::unordered_multiset<T>& v) const {
+        msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::unordered_multiset<Key, Hash, Compare, Alloc>& v) const {
         uint32_t size = checked_get_container_size(v.size());
         o.pack_array(size);
-        for(typename std::unordered_multiset<T>::const_iterator it(v.begin()), it_end(v.end());
+        for(typename std::unordered_multiset<Key, Hash, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
             it != it_end; ++it) {
             o.pack(*it);
         }
@@ -116,9 +146,9 @@ struct pack<std::unordered_multiset<T>> {
     }
 };
 
-template <typename T>
-struct object_with_zone<std::unordered_multiset<T>> {
-    void operator()(msgpack::object::with_zone& o, const std::unordered_multiset<T>& v) const {
+template <typename Key, typename Hash, typename Compare, typename Alloc>
+struct object_with_zone<std::unordered_multiset<Key, Hash, Compare, Alloc>> {
+    void operator()(msgpack::object::with_zone& o, const std::unordered_multiset<Key, Hash, Compare, Alloc>& v) const {
         o.type = msgpack::type::ARRAY;
         if(v.empty()) {
             o.via.array.ptr = nullptr;
@@ -129,7 +159,7 @@ struct object_with_zone<std::unordered_multiset<T>> {
             msgpack::object* const pend = p + size;
             o.via.array.ptr = p;
             o.via.array.size = size;
-            typename std::unordered_multiset<T>::const_iterator it(v.begin());
+            typename std::unordered_multiset<Key, Hash, Compare, Alloc>::const_iterator it(v.begin());
             do {
                 *p = msgpack::object(*it, o.zone);
                 ++p;

include/msgpack/adaptor/define.hpp

@@ -21,9 +21,19 @@
 #include "msgpack/cpp_config.hpp"
 
 #if defined(MSGPACK_USE_CPP03)
-#include "detail/cpp03_define.hpp"
+#include "detail/cpp03_define_array.hpp"
+#include "detail/cpp03_define_map.hpp"
 #else  // MSGPACK_USE_CPP03
-#include "detail/cpp11_define.hpp"
+#include "detail/cpp11_define_array.hpp"
+#include "detail/cpp11_define_map.hpp"
 #endif // MSGPACK_USE_CPP03
 
+#if defined(MSGPACK_USE_DEFINE_MAP)
+#define MSGPACK_DEFINE MSGPACK_DEFINE_MAP
+#define MSGPACK_BASE MSGPACK_BASE_MAP
+#else  // defined(MSGPACK_USE_DEFINE_MAP)
+#define MSGPACK_DEFINE MSGPACK_DEFINE_ARRAY
+#define MSGPACK_BASE MSGPACK_BASE_ARRAY
+#endif // defined(MSGPACK_USE_DEFINE_MAP)
+
 #endif // MSGPACK_DEFINE_HPP

include/msgpack/adaptor/deque.hpp

@@ -32,14 +32,35 @@ MSGPACK_API_VERSION_NAMESPACE(v1) {
 
 namespace adaptor {
 
-template <typename T>
-struct convert<std::deque<T> > {
-    msgpack::object const& operator()(msgpack::object const& o, std::deque<T>& v) const {
+#if !defined(MSGPACK_USE_CPP03)
+
+template <typename T, typename Alloc>
+struct as<std::deque<T, Alloc>, typename std::enable_if<msgpack::has_as<T>::value>::type> {
+    std::deque<T, Alloc> operator()(const msgpack::object& o) const {
+        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+        std::deque<T, Alloc> v;
+        if (o.via.array.size > 0) {
+            msgpack::object* p = o.via.array.ptr;
+            msgpack::object* const pend = o.via.array.ptr + o.via.array.size;
+            do {
+                v.push_back(p->as<T>());
+                ++p;
+            } while (p < pend);
+        }
+        return v;
+    }
+};
+
+#endif // !defined(MSGPACK_USE_CPP03)
+
+template <typename T, typename Alloc>
+struct convert<std::deque<T, Alloc> > {
+    msgpack::object const& operator()(msgpack::object const& o, std::deque<T, Alloc>& v) const {
         if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
         v.resize(o.via.array.size);
         msgpack::object* p = o.via.array.ptr;
         msgpack::object* const pend = o.via.array.ptr + o.via.array.size;
-        typename std::deque<T>::iterator it = v.begin();
+        typename std::deque<T, Alloc>::iterator it = v.begin();
         for(; p < pend; ++p, ++it) {
             p->convert(*it);
         }
@@ -47,13 +68,13 @@ struct convert<std::deque<T> > {
     }
 };
 
-template <typename T>
-struct pack<std::deque<T> > {
+template <typename T, typename Alloc>
+struct pack<std::deque<T, Alloc> > {
     template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::deque<T>& v) const {
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::deque<T, Alloc>& v) const {
         uint32_t size = checked_get_container_size(v.size());
         o.pack_array(size);
-        for(typename std::deque<T>::const_iterator it(v.begin()), it_end(v.end());
+        for(typename std::deque<T, Alloc>::const_iterator it(v.begin()), it_end(v.end());
             it != it_end; ++it) {
             o.pack(*it);
         }
@@ -61,9 +82,9 @@ struct pack<std::deque<T> > {
     }
 };
 
-template <typename T>
-struct object_with_zone<std::deque<T> > {
-    void operator()(msgpack::object::with_zone& o, const std::deque<T>& v) const {
+template <typename T, typename Alloc>
+struct object_with_zone<std::deque<T, Alloc> > {
+    void operator()(msgpack::object::with_zone& o, const std::deque<T, Alloc>& v) const {
         o.type = msgpack::type::ARRAY;
         if(v.empty()) {
             o.via.array.ptr = nullptr;
@@ -74,7 +95,7 @@ struct object_with_zone<std::deque<T> > {
             msgpack::object* const pend = p + size;
             o.via.array.ptr = p;
             o.via.array.size = size;
-            typename std::deque<T>::const_iterator it(v.begin());
+            typename std::deque<T, Alloc>::const_iterator it(v.begin());
             do {
                 *p = msgpack::object(*it, o.zone);
                 ++p;

include/msgpack/adaptor/detail/cpp03_define_array.hpp

@@ -15,30 +15,32 @@
 //    See the License for the specific language governing permissions and
 //    limitations under the License.
 //
-#ifndef MSGPACK_CPP03_DEFINE_HPP
-#define MSGPACK_CPP03_DEFINE_HPP
+#ifndef MSGPACK_CPP03_DEFINE_ARRAY_HPP
+#define MSGPACK_CPP03_DEFINE_ARRAY_HPP
 
 #include "msgpack/versioning.hpp"
 #include "msgpack/adaptor/msgpack_tuple.hpp"
 #include "msgpack/adaptor/adaptor_base.hpp"
 #include "msgpack/object_fwd.hpp"
 
-#define MSGPACK_DEFINE(...) \
+#define MSGPACK_DEFINE_ARRAY(...) \
     template <typename Packer> \
     void msgpack_pack(Packer& pk) const \
     { \
-        msgpack::type::make_define(__VA_ARGS__).msgpack_pack(pk); \
+        msgpack::type::make_define_array(__VA_ARGS__).msgpack_pack(pk); \
     } \
     void msgpack_unpack(msgpack::object const& o) \
     { \
-        msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \
+        msgpack::type::make_define_array(__VA_ARGS__).msgpack_unpack(o); \
     }\
     template <typename MSGPACK_OBJECT> \
     void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone& z) const \
     { \
-        msgpack::type::make_define(__VA_ARGS__).msgpack_object(o, z); \
+        msgpack::type::make_define_array(__VA_ARGS__).msgpack_object(o, z); \
     }
 
+#define MSGPACK_BASE_ARRAY(base) (*const_cast<base *>(static_cast<base const*>(this)))
+
 // MSGPACK_ADD_ENUM must be used in the global namespace.
 #define MSGPACK_ADD_ENUM(enum_name) \
   namespace msgpack { \
@@ -89,12 +91,12 @@ namespace type {
 /// @cond
 
 template <typename A0 = void, typename A1 = void, typename A2 = void, typename A3 = void, typename A4 = void, typename A5 = void, typename A6 = void, typename A7 = void, typename A8 = void, typename A9 = void, typename A10 = void, typename A11 = void, typename A12 = void, typename A13 = void, typename A14 = void, typename A15 = void, typename A16 = void, typename A17 = void, typename A18 = void, typename A19 = void, typename A20 = void, typename A21 = void, typename A22 = void, typename A23 = void, typename A24 = void, typename A25 = void, typename A26 = void, typename A27 = void, typename A28 = void, typename A29 = void, typename A30 = void, typename A31 = void, typename A32 = void>
-struct define;
+struct define_array;
 /// @endcond
 
 template <>
-struct define<> {
-    typedef define<> value_type;
+struct define_array<> {
+    typedef define_array<> value_type;
     typedef tuple<> tuple_type;
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -116,10 +118,10 @@ struct define<> {
 /// @cond
 
 template <typename A0>
-struct define<A0> {
-    typedef define<A0> value_type;
+struct define_array<A0> {
+    typedef define_array<A0> value_type;
     typedef tuple<A0> tuple_type;
-    define(A0& _a0) :
+    define_array(A0& _a0) :
         a0(_a0) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -153,10 +155,10 @@ struct define<A0> {
 };
 
 template <typename A0, typename A1>
-struct define<A0, A1> {
-    typedef define<A0, A1> value_type;
+struct define_array<A0, A1> {
+    typedef define_array<A0, A1> value_type;
     typedef tuple<A0, A1> tuple_type;
-    define(A0& _a0, A1& _a1) :
+    define_array(A0& _a0, A1& _a1) :
         a0(_a0), a1(_a1) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -194,10 +196,10 @@ struct define<A0, A1> {
 };
 
 template <typename A0, typename A1, typename A2>
-struct define<A0, A1, A2> {
-    typedef define<A0, A1, A2> value_type;
+struct define_array<A0, A1, A2> {
+    typedef define_array<A0, A1, A2> value_type;
     typedef tuple<A0, A1, A2> tuple_type;
-    define(A0& _a0, A1& _a1, A2& _a2) :
+    define_array(A0& _a0, A1& _a1, A2& _a2) :
         a0(_a0), a1(_a1), a2(_a2) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -239,10 +241,10 @@ struct define<A0, A1, A2> {
 };
 
 template <typename A0, typename A1, typename A2, typename A3>
-struct define<A0, A1, A2, A3> {
-    typedef define<A0, A1, A2, A3> value_type;
+struct define_array<A0, A1, A2, A3> {
+    typedef define_array<A0, A1, A2, A3> value_type;
     typedef tuple<A0, A1, A2, A3> tuple_type;
-    define(A0& _a0, A1& _a1, A2& _a2, A3& _a3) :
+    define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3) :
         a0(_a0), a1(_a1), a2(_a2), a3(_a3) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -288,10 +290,10 @@ struct define<A0, A1, A2, A3> {
 };
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4>
-struct define<A0, A1, A2, A3, A4> {
-    typedef define<A0, A1, A2, A3, A4> value_type;
+struct define_array<A0, A1, A2, A3, A4> {
+    typedef define_array<A0, A1, A2, A3, A4> value_type;
     typedef tuple<A0, A1, A2, A3, A4> tuple_type;
-    define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4) :
+    define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4) :
         a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -341,10 +343,10 @@ struct define<A0, A1, A2, A3, A4> {
 };
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
-struct define<A0, A1, A2, A3, A4, A5> {
-    typedef define<A0, A1, A2, A3, A4, A5> value_type;
+struct define_array<A0, A1, A2, A3, A4, A5> {
+    typedef define_array<A0, A1, A2, A3, A4, A5> value_type;
     typedef tuple<A0, A1, A2, A3, A4, A5> tuple_type;
-    define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5) :
+    define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5) :
         a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -398,10 +400,10 @@ struct define<A0, A1, A2, A3, A4, A5> {
 };
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
-struct define<A0, A1, A2, A3, A4, A5, A6> {
-    typedef define<A0, A1, A2, A3, A4, A5, A6> value_type;
+struct define_array<A0, A1, A2, A3, A4, A5, A6> {
+    typedef define_array<A0, A1, A2, A3, A4, A5, A6> value_type;
     typedef tuple<A0, A1, A2, A3, A4, A5, A6> tuple_type;
-    define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6) :
+    define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6) :
         a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -459,10 +461,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6> {
 };
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
-struct define<A0, A1, A2, A3, A4, A5, A6, A7> {
-    typedef define<A0, A1, A2, A3, A4, A5, A6, A7> value_type;
+struct define_array<A0, A1, A2, A3, A4, A5, A6, A7> {
+    typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7> value_type;
     typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7> tuple_type;
-    define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7) :
+    define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7) :
         a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -524,10 +526,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7> {
 };
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
-struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8> {
-    typedef define<A0, A1, A2, A3, A4, A5, A6, A7, A8> value_type;
+struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8> {
+    typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8> value_type;
     typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8> tuple_type;
-    define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8) :
+    define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8) :
         a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -593,10 +595,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8> {
 };
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
-struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
-    typedef define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> value_type;
+struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
+    typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> value_type;
     typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> tuple_type;
-    define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9) :
+    define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9) :
         a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -666,10 +668,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
 };
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10>
-struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
-    typedef define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> value_type;
+struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
+    typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> value_type;
     typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> tuple_type;
-    define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10) :
+    define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10) :
         a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -743,10 +745,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
 };
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11>
-struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
-    typedef define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> value_type;
+struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
+    typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> value_type;
     typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> tuple_type;
-    define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11) :
+    define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11) :
         a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -824,10 +826,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
 };
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12>
-struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
-    typedef define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> value_type;
+struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
+    typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> value_type;
     typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> tuple_type;
-    define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12) :
+    define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12) :
         a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -909,10 +911,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
 };
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13>
-struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
-    typedef define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> value_type;
+struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
+    typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> value_type;
     typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> tuple_type;
-    define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13) :
+    define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13) :
         a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -998,10 +1000,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
 };
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14>
-struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
-    typedef define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> value_type;
+struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
+    typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> value_type;
     typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> tuple_type;
-    define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14) :
+    define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14) :
         a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -1091,10 +1093,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
 };
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15>
-struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
-    typedef define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> value_type;
+struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
+    typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> value_type;
     typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> tuple_type;
-    define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15) :
+    define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15) :
         a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -1188,10 +1190,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
 };
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16>
-struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> {
-    typedef define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> value_type;
+struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> {
+    typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> value_type;
     typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> tuple_type;
-    define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16) :
+    define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16) :
         a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -1289,10 +1291,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
 };
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17>
-struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> {
-    typedef define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> value_type;
+struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> {
+    typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> value_type;
     typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> tuple_type;
-    define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17) :
+    define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17) :
         a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -1394,10 +1396,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
 };
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18>
-struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> {
-    typedef define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> value_type;
+struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> {
+    typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> value_type;
     typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> tuple_type;
-    define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18) :
+    define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18) :
         a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -1503,10 +1505,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
 };
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19>
-struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> {
-    typedef define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> value_type;
+struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> {
+    typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> value_type;
     typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> tuple_type;
-    define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19) :
+    define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19) :
         a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -1616,10 +1618,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
 };
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20>
-struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20> {
-    typedef define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20> value_type;
+struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20> {
+    typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20> value_type;
     typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20> tuple_type;
-    define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20) :
+    define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20) :
         a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -1733,10 +1735,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
 };
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21>
-struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> {
-    typedef define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> value_type;
+struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> {
+    typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> value_type;
     typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> tuple_type;
-    define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21) :
+    define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21) :
         a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -1854,10 +1856,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
 };
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22>
-struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22> {
-    typedef define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22> value_type;
+struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22> {
+    typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22> value_type;
     typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22> tuple_type;
-    define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22) :
+    define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22) :
         a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -1979,10 +1981,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
 };
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23>
-struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23> {
-    typedef define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23> value_type;
+struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23> {
+    typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23> value_type;
     typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23> tuple_type;
-    define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23) :
+    define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23) :
         a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -2108,10 +2110,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
 };
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24>
-struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24> {
-    typedef define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24> value_type;
+struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24> {
+    typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24> value_type;
     typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24> tuple_type;
-    define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24) :
+    define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24) :
         a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -2241,10 +2243,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
 };
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25>
-struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25> {
-    typedef define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25> value_type;
+struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25> {
+    typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25> value_type;
     typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25> tuple_type;
-    define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25) :
+    define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25) :
         a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -2378,10 +2380,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
 };
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26>
-struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26> {
-    typedef define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26> value_type;
+struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26> {
+    typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26> value_type;
     typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26> tuple_type;
-    define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26) :
+    define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26) :
         a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -2519,10 +2521,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
 };
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27>
-struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27> {
-    typedef define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27> value_type;
+struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27> {
+    typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27> value_type;
     typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27> tuple_type;
-    define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, 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) :
+    define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27) :
         a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -2664,10 +2666,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
 };
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28>
-struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28> {
-    typedef define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28> value_type;
+struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28> {
+    typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28> value_type;
     typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28> tuple_type;
-    define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, 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) :
+    define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27, A28& _a28) :
         a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -2813,10 +2815,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
 };
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29>
-struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29> {
-    typedef define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29> value_type;
+struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29> {
+    typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29> value_type;
     typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29> tuple_type;
-    define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, 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) :
+    define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27, A28& _a28, A29& _a29) :
         a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28), a29(_a29) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -2966,10 +2968,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
 };
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30>
-struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30> {
-    typedef define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30> value_type;
+struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30> {
+    typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30> value_type;
     typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30> tuple_type;
-    define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, 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) :
+    define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27, A28& _a28, A29& _a29, A30& _a30) :
         a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28), a29(_a29), a30(_a30) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -3123,10 +3125,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
 };
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31>
-struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31> {
-    typedef define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31> value_type;
+struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31> {
+    typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31> value_type;
     typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31> tuple_type;
-    define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, 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) :
+    define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27, A28& _a28, A29& _a29, A30& _a30, A31& _a31) :
         a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28), a29(_a29), a30(_a30), a31(_a31) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -3285,203 +3287,203 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
 
 /// @endcond
 
-inline define<> make_define()
+inline define_array<> make_define_array()
 {
-    return define<>();
+    return define_array<>();
 }
 
 /// @cond
 
 template <typename A0>
-define<A0> make_define(A0& a0)
+inline define_array<A0> make_define_array(A0& a0)
 {
-    return define<A0>(a0);
+    return define_array<A0>(a0);
 }
 
 template <typename A0, typename A1>
-define<A0, A1> make_define(A0& a0, A1& a1)
+inline define_array<A0, A1> make_define_array(A0& a0, A1& a1)
 {
-    return define<A0, A1>(a0, a1);
+    return define_array<A0, A1>(a0, a1);
 }
 
 template <typename A0, typename A1, typename A2>
-define<A0, A1, A2> make_define(A0& a0, A1& a1, A2& a2)
+inline define_array<A0, A1, A2> make_define_array(A0& a0, A1& a1, A2& a2)
 {
-    return define<A0, A1, A2>(a0, a1, a2);
+    return define_array<A0, A1, A2>(a0, a1, a2);
 }
 
 template <typename A0, typename A1, typename A2, typename A3>
-define<A0, A1, A2, A3> make_define(A0& a0, A1& a1, A2& a2, A3& a3)
+inline define_array<A0, A1, A2, A3> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3)
 {
-    return define<A0, A1, A2, A3>(a0, a1, a2, a3);
+    return define_array<A0, A1, A2, A3>(a0, a1, a2, a3);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4>
-define<A0, A1, A2, A3, A4> make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4)
+inline define_array<A0, A1, A2, A3, A4> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4)
 {
-    return define<A0, A1, A2, A3, A4>(a0, a1, a2, a3, a4);
+    return define_array<A0, A1, A2, A3, A4>(a0, a1, a2, a3, a4);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
-define<A0, A1, A2, A3, A4, A5> make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5)
+inline define_array<A0, A1, A2, A3, A4, A5> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5)
 {
-    return define<A0, A1, A2, A3, A4, A5>(a0, a1, a2, a3, a4, a5);
+    return define_array<A0, A1, A2, A3, A4, A5>(a0, a1, a2, a3, a4, a5);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
-define<A0, A1, A2, A3, A4, A5, A6> make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6)
+inline define_array<A0, A1, A2, A3, A4, A5, A6> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6)
 {
-    return define<A0, A1, A2, A3, A4, A5, A6>(a0, a1, a2, a3, a4, a5, a6);
+    return define_array<A0, A1, A2, A3, A4, A5, A6>(a0, a1, a2, a3, a4, a5, a6);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
-define<A0, A1, A2, A3, A4, A5, A6, A7> make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7)
+inline define_array<A0, A1, A2, A3, A4, A5, A6, A7> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7)
 {
-    return define<A0, A1, A2, A3, A4, A5, A6, A7>(a0, a1, a2, a3, a4, a5, a6, a7);
+    return define_array<A0, A1, A2, A3, A4, A5, A6, A7>(a0, a1, a2, a3, a4, a5, a6, a7);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
-define<A0, A1, A2, A3, A4, A5, A6, A7, A8> make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8)
+inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8)
 {
-    return define<A0, A1, A2, A3, A4, A5, A6, A7, A8>(a0, a1, a2, a3, a4, a5, a6, a7, a8);
+    return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8>(a0, a1, a2, a3, a4, a5, a6, a7, a8);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
-define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9)
+inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9)
 {
-    return define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+    return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10>
-define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10)
+inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10)
 {
-    return define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
+    return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11>
-define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> 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)
+inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11)
 {
-    return define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
+    return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12>
-define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> 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)
+inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12)
 {
-    return define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
+    return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13>
-define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> 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)
+inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13)
 {
-    return define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
+    return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14>
-define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> 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)
+inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14)
 {
-    return define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
+    return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15>
-define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> 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)
+inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15)
 {
-    return define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
+    return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16>
-define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> 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)
+inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16)
 {
-    return define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16);
+    return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17>
-define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> 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)
+inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17)
 {
-    return define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17);
+    return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18>
-define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> 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)
+inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18)
 {
-    return define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18);
+    return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19>
-define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> 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)
+inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19)
 {
-    return define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19);
+    return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20>
-define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20> 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)
+inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20)
 {
-    return define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
+    return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21>
-define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> 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)
+inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21)
 {
-    return define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21);
+    return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22>
-define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22> make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22)
+inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22)
 {
-    return define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22);
+    return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23>
-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> 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)
+inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23)
 {
-    return define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23);
+    return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24>
-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> 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)
+inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24)
 {
-    return define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24);
+    return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25>
-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> 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)
+inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25)
 {
-    return define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25);
+    return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26>
-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> 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)
+inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26)
 {
-    return define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26);
+    return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27>
-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> 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)
+inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27)
 {
-    return define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27);
+    return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28>
-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> 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)
+inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28)
 {
-    return define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28);
+    return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29>
-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> 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)
+inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28, A29& a29)
 {
-    return define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29);
+    return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30>
-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> 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)
+inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28, A29& a29, A30& a30)
 {
-    return define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30);
+    return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31>
-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> 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)
+inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28, A29& a29, A30& a30, A31& a31)
 {
-    return define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31);
+    return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31);
 }
 
 /// @endcond
@@ -3493,4 +3495,4 @@ define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16
 }  // namespace msgpack
 
 
-#endif // MSGPACK_CPP03_DEFINE_HPP
+#endif // MSGPACK_CPP03_DEFINE_ARRAY_HPP

include/msgpack/adaptor/detail/cpp11_define_array.hpp

@@ -15,8 +15,8 @@
 //    See the License for the specific language governing permissions and
 //    limitations under the License.
 //
-#ifndef MSGPACK_CPP11_DEFINE_HPP
-#define MSGPACK_CPP11_DEFINE_HPP
+#ifndef MSGPACK_CPP11_DEFINE_ARRAY_HPP
+#define MSGPACK_CPP11_DEFINE_ARRAY_HPP
 
 #include "msgpack/versioning.hpp"
 #include "msgpack/adaptor/adaptor_base.hpp"
@@ -27,22 +27,24 @@
 #include <type_traits>
 #include <tuple>
 
-#define MSGPACK_DEFINE(...) \
+#define MSGPACK_DEFINE_ARRAY(...) \
     template <typename Packer> \
     void msgpack_pack(Packer& pk) const \
     { \
-        msgpack::type::make_define(__VA_ARGS__).msgpack_pack(pk); \
+        msgpack::type::make_define_array(__VA_ARGS__).msgpack_pack(pk); \
     } \
     void msgpack_unpack(msgpack::object const& o) \
     { \
-        msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \
+        msgpack::type::make_define_array(__VA_ARGS__).msgpack_unpack(o); \
     }\
     template <typename MSGPACK_OBJECT> \
     void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone& z) const \
     { \
-        msgpack::type::make_define(__VA_ARGS__).msgpack_object(o, z); \
+        msgpack::type::make_define_array(__VA_ARGS__).msgpack_object(o, z); \
     }
 
+#define MSGPACK_BASE_ARRAY(base) (*const_cast<base *>(static_cast<base const*>(this)))
+
 // MSGPACK_ADD_ENUM must be used in the global namespace.
 #define MSGPACK_ADD_ENUM(enum_name) \
   namespace msgpack { \
@@ -93,26 +95,26 @@ MSGPACK_API_VERSION_NAMESPACE(v1) {
 namespace type {
 
 template <typename Tuple, std::size_t N>
-struct define_imp {
+struct define_array_imp {
     template <typename Packer>
     static void pack(Packer& pk, Tuple const& t) {
-        define_imp<Tuple, N-1>::pack(pk, t);
+        define_array_imp<Tuple, N-1>::pack(pk, t);
         pk.pack(std::get<N-1>(t));
     }
     static void unpack(msgpack::object const& o, Tuple& t) {
-        define_imp<Tuple, N-1>::unpack(o, t);
+        define_array_imp<Tuple, N-1>::unpack(o, t);
         const size_t size = o.via.array.size;
         if(size <= N-1) { return; }
         o.via.array.ptr[N-1].convert(std::get<N-1>(t));
     }
     static void object(msgpack::object* o, msgpack::zone& z, Tuple const& t) {
-        define_imp<Tuple, N-1>::object(o, z, t);
+        define_array_imp<Tuple, N-1>::object(o, z, t);
         o->via.array.ptr[N-1] = msgpack::object(std::get<N-1>(t), z);
     }
 };
 
 template <typename Tuple>
-struct define_imp<Tuple, 1> {
+struct define_array_imp<Tuple, 1> {
     template <typename Packer>
     static void pack(Packer& pk, Tuple const& t) {
         pk.pack(std::get<0>(t));
@@ -128,23 +130,23 @@ struct define_imp<Tuple, 1> {
 };
 
 template <typename... Args>
-struct define {
-    typedef define<Args...> value_type;
+struct define_array {
+    typedef define_array<Args...> value_type;
     typedef std::tuple<Args...> tuple_type;
-    define(Args&... args) :
+    define_array(Args&... args) :
         a(args...) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
     {
         pk.pack_array(sizeof...(Args));
 
-        define_imp<std::tuple<Args&...>, sizeof...(Args)>::pack(pk, a);
+        define_array_imp<std::tuple<Args&...>, sizeof...(Args)>::pack(pk, a);
     }
     void msgpack_unpack(msgpack::object const& o)
     {
         if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
 
-        define_imp<std::tuple<Args&...>, sizeof...(Args)>::unpack(o, a);
+        define_array_imp<std::tuple<Args&...>, sizeof...(Args)>::unpack(o, a);
     }
     void msgpack_object(msgpack::object* o, msgpack::zone& z) const
     {
@@ -152,15 +154,15 @@ struct define {
         o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*sizeof...(Args)));
         o->via.array.size = sizeof...(Args);
 
-        define_imp<std::tuple<Args&...>, sizeof...(Args)>::object(o, z, a);
+        define_array_imp<std::tuple<Args&...>, sizeof...(Args)>::object(o, z, a);
     }
 
     std::tuple<Args&...> a;
 };
 
 template <>
-struct define<> {
-    typedef define<> value_type;
+struct define_array<> {
+    typedef define_array<> value_type;
     typedef std::tuple<> tuple_type;
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -179,15 +181,15 @@ struct define<> {
     }
 };
 
-inline define<> make_define()
+inline define_array<> make_define_array()
 {
-    return define<>();
+    return define_array<>();
 }
 
 template <typename... Args>
-define<Args...> make_define(Args&... args)
+inline define_array<Args...> make_define_array(Args&... args)
 {
-    return define<Args...>(args...);
+    return define_array<Args...>(args...);
 }
 
 }  // namespace type
@@ -196,4 +198,4 @@ define<Args...> make_define(Args&... args)
 /// @endcond
 }  // namespace msgpack
 
-#endif // MSGPACK_CPP11_DEFINE_HPP
+#endif // MSGPACK_CPP11_DEFINE_ARRAY_HPP

include/msgpack/adaptor/detail/cpp11_define_map.hpp

@@ -0,0 +1,171 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_CPP11_DEFINE_MAP_HPP
+#define MSGPACK_CPP11_DEFINE_MAP_HPP
+
+// BOOST_PP_VARIADICS is defined in boost/preprocessor/config/config.hpp
+// http://www.boost.org/libs/preprocessor/doc/ref/variadics.html
+// However, supporting compiler detection is not complete. msgpack-c requires
+// variadic macro arguments support. So BOOST_PP_VARIADICS is defined here explicitly.
+#if !defined(MSGPACK_PP_VARIADICS)
+#define MSGPACK_PP_VARIADICS
+#endif
+
+#include <msgpack/preprocessor.hpp>
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+
+// for MSGPACK_ADD_ENUM
+#include "msgpack/adaptor/int.hpp"
+
+#include <type_traits>
+#include <tuple>
+
+#define MSGPACK_DEFINE_MAP_EACH_PROC(r, data, elem) \
+    MSGPACK_PP_IF( \
+        MSGPACK_PP_IS_BEGIN_PARENS(elem), \
+        elem, \
+        (MSGPACK_PP_STRINGIZE(elem))(elem) \
+    )
+
+#define MSGPACK_DEFINE_MAP_IMPL(...) \
+    MSGPACK_PP_SEQ_TO_TUPLE( \
+        MSGPACK_PP_SEQ_FOR_EACH( \
+            MSGPACK_DEFINE_MAP_EACH_PROC, \
+            0, \
+            MSGPACK_PP_VARIADIC_TO_SEQ(__VA_ARGS__) \
+        ) \
+    )
+
+#define MSGPACK_DEFINE_MAP(...) \
+    template <typename Packer> \
+    void msgpack_pack(Packer& pk) const \
+    { \
+        msgpack::type::make_define_map \
+            MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \
+            .msgpack_pack(pk); \
+    } \
+    void msgpack_unpack(msgpack::object const& o) \
+    { \
+        msgpack::type::make_define_map \
+            MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \
+            .msgpack_unpack(o); \
+    }\
+    template <typename MSGPACK_OBJECT> \
+    void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone& z) const \
+    { \
+        msgpack::type::make_define_map \
+            MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \
+            .msgpack_object(o, z); \
+    }
+
+#define MSGPACK_BASE_MAP(base) \
+    (MSGPACK_PP_STRINGIZE(base))(*const_cast<base *>(static_cast<base const*>(this)))
+
+namespace msgpack {
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+namespace type {
+
+template <typename Tuple, std::size_t N>
+struct define_map_imp {
+    template <typename Packer>
+    static void pack(Packer& pk, Tuple const& t) {
+        define_map_imp<Tuple, N-1>::pack(pk, t);
+        pk.pack(std::get<N-1>(t));
+    }
+    static void unpack(
+        msgpack::object const& o, Tuple const& t,
+        std::map<std::string, msgpack::object const*> const& kvmap) {
+        define_map_imp<Tuple, N-2>::unpack(o, t, kvmap);
+        auto it = kvmap.find(std::get<N-2>(t));
+        if (it != kvmap.end()) {
+            it->second->convert(std::get<N-1>(t));
+        }
+    }
+    static void object(msgpack::object* o, msgpack::zone& z, Tuple const& t) {
+        define_map_imp<Tuple, N-2>::object(o, z, t);
+        o->via.map.ptr[(N-1)/2].key = msgpack::object(std::get<N-2>(t), z);
+        o->via.map.ptr[(N-1)/2].val = msgpack::object(std::get<N-1>(t), z);
+    }
+};
+
+template <typename Tuple>
+struct define_map_imp<Tuple, 0> {
+    template <typename Packer>
+    static void pack(Packer&, Tuple const&) {}
+    static void unpack(
+        msgpack::object const&, Tuple const&,
+        std::map<std::string, msgpack::object const*> const&) {}
+    static void object(msgpack::object*, msgpack::zone&, Tuple const&) {}
+};
+
+template <typename... Args>
+struct define_map {
+    define_map(Args&... args) :
+        a(args...) {}
+    template <typename Packer>
+    void msgpack_pack(Packer& pk) const
+    {
+        static_assert(sizeof...(Args) % 2 == 0, "");
+        pk.pack_map(sizeof...(Args) / 2);
+
+        define_map_imp<std::tuple<Args&...>, sizeof...(Args)>::pack(pk, a);
+    }
+    void msgpack_unpack(msgpack::object const& o) const
+    {
+        if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
+        std::map<std::string, msgpack::object const*> kvmap;
+        for (uint32_t i = 0; i < o.via.map.size; ++i) {
+            kvmap.emplace(
+                std::string(
+                    o.via.map.ptr[i].key.via.str.ptr,
+                    o.via.map.ptr[i].key.via.str.size),
+                &o.via.map.ptr[i].val);
+        }
+        define_map_imp<std::tuple<Args&...>, sizeof...(Args)>::unpack(o, a, kvmap);
+    }
+    void msgpack_object(msgpack::object* o, msgpack::zone& z) const
+    {
+        static_assert(sizeof...(Args) % 2 == 0, "");
+        o->type = msgpack::type::MAP;
+        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*sizeof...(Args)/2));
+        o->via.map.size = sizeof...(Args) / 2;
+
+        define_map_imp<std::tuple<Args&...>, sizeof...(Args)>::object(o, z, a);
+    }
+
+    std::tuple<Args&...> a;
+};
+
+
+template <typename... Args>
+define_map<Args...> make_define_map(Args&... args)
+{
+    return define_map<Args...>(args...);
+}
+
+}  // namespace type
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+}  // namespace msgpack
+
+#endif // MSGPACK_CPP11_DEFINE_MAP_HPP

include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp

@@ -1,7 +1,7 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi
+// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi
 //
 //    Licensed under the Apache License, Version 2.0 (the "License");
 //    you may not use this file except in compliance with the License.
@@ -20,6 +20,7 @@
 
 #include "msgpack/versioning.hpp"
 #include "msgpack/object_fwd.hpp"
+#include "msgpack/meta.hpp"
 
 #include <tuple>
 
@@ -36,9 +37,6 @@ namespace type {
     using std::tuple_element;
     using std::uses_allocator;
     using std::ignore;
-    using std::make_tuple;
-    using std::tie;
-    using std::forward_as_tuple;
     using std::swap;
 
     template< class... Types >
@@ -73,24 +71,38 @@ namespace type {
 
         template< std::size_t I>
         typename tuple_element<I, base >::type&
-        get() { return std::get<I>(*this); }
+        get() & { return std::get<I>(*this); }
 
         template< std::size_t I>
         typename tuple_element<I, base >::type const&
-        get() const { return std::get<I>(*this); }
+        get() const& { return std::get<I>(*this); }
 
         template< std::size_t I>
         typename tuple_element<I, base >::type&&
         get() && { return std::get<I>(*this); }
     };
 
+    template <class... Args>
+    inline tuple<Args...> make_tuple(Args&&... args) {
+        return tuple<Args...>(args...);
+    }
+
+    template<class... Args>
+    inline tuple<Args&&...> forward_as_tuple (Args&&... args) noexcept {
+        return tuple<Args&&...>(std::forward<Args>(args)...);
+    }
+
     template <class... Tuples>
-    auto tuple_cat(Tuples&&... args) ->
+    inline auto tuple_cat(Tuples&&... args) ->
         decltype(
             std::tuple_cat(std::forward<typename std::remove_reference<Tuples>::type::base>(args)...)
         ) {
         return std::tuple_cat(std::forward<typename std::remove_reference<Tuples>::type::base>(args)...);
     }
+    template <class... Args>
+    inline tuple<Args&...> tie(Args&... args) {
+        return tuple<Args&...>(args...);
+    }
 } // namespace type
 
 // --- Pack from tuple to packer stream ---
@@ -124,11 +136,11 @@ struct MsgpackTuplePacker<Stream, Tuple, 0> {
 namespace adaptor {
 
 template <typename... Args>
-struct pack<type::tuple<Args...>> {
+struct pack<msgpack::type::tuple<Args...>> {
     template <typename Stream>
     msgpack::packer<Stream>& operator()(
         msgpack::packer<Stream>& o,
-        const type::tuple<Args...>& v) const {
+        const msgpack::type::tuple<Args...>& v) const {
         o.pack_array(sizeof...(Args));
         MsgpackTuplePacker<Stream, decltype(v), sizeof...(Args)>::pack(o, v);
         return o;
@@ -139,6 +151,32 @@ struct pack<type::tuple<Args...>> {
 
 // --- Convert from tuple to object ---
 
+template <typename... Args>
+struct MsgpackTupleAs;
+
+template <typename T, typename... Args>
+struct MsgpackTupleAsImpl {
+    static msgpack::type::tuple<T, Args...> as(msgpack::object const& o) {
+        return msgpack::type::tuple_cat(
+            msgpack::type::make_tuple(o.via.array.ptr[o.via.array.size - sizeof...(Args) - 1].as<T>()),
+            MsgpackTupleAs<Args...>::as(o));
+    }
+};
+
+template <typename... Args>
+struct MsgpackTupleAs {
+    static msgpack::type::tuple<Args...> as(msgpack::object const& o) {
+        return MsgpackTupleAsImpl<Args...>::as(o);
+    }
+};
+
+template <>
+struct MsgpackTupleAs<> {
+    static msgpack::type::tuple<> as (msgpack::object const&) {
+        return msgpack::type::tuple<>();
+    }
+};
+
 template <typename Tuple, std::size_t N>
 struct MsgpackTupleConverter {
     static void convert(
@@ -169,10 +207,20 @@ struct MsgpackTupleConverter<Tuple, 0> {
 namespace adaptor {
 
 template <typename... Args>
-struct convert<type::tuple<Args...>> {
+struct as<msgpack::type::tuple<Args...>, typename std::enable_if<msgpack::all_of<msgpack::has_as, Args...>::value>::type>  {
+    msgpack::type::tuple<Args...> operator()(
+        msgpack::object const& o) const {
+        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+        if (o.via.array.size < sizeof...(Args)) { throw msgpack::type_error(); }
+        return MsgpackTupleAs<Args...>::as(o);
+    }
+};
+
+template <typename... Args>
+struct convert<msgpack::type::tuple<Args...>> {
     msgpack::object const& operator()(
         msgpack::object const& o,
-        type::tuple<Args...>& v) const {
+        msgpack::type::tuple<Args...>& v) const {
         if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
         if(o.via.array.size < sizeof...(Args)) { throw msgpack::type_error(); }
         MsgpackTupleConverter<decltype(v), sizeof...(Args)>::convert(o, v);
@@ -213,10 +261,10 @@ struct MsgpackTupleToObjectWithZone<Tuple, 0> {
 namespace adaptor {
 
 template <typename... Args>
-    struct object_with_zone<type::tuple<Args...>> {
+    struct object_with_zone<msgpack::type::tuple<Args...>> {
     void operator()(
         msgpack::object::with_zone& o,
-        type::tuple<Args...> const& v) const {
+        msgpack::type::tuple<Args...> const& v) const {
         o.type = msgpack::type::ARRAY;
         o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*sizeof...(Args)));
         o.via.array.size = sizeof...(Args);

include/msgpack/adaptor/ext.hpp

@@ -0,0 +1,245 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2015 KONDO Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_TYPE_EXT_HPP
+#define MSGPACK_TYPE_EXT_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include <cstring>
+#include <string>
+#include <cassert>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace type {
+class ext_ref;
+
+class ext {
+public:
+    ext() : m_data(1, 0) {}
+    ext(int8_t t, const char* p, uint32_t s) {
+        detail::check_container_size_for_ext<sizeof(std::size_t)>(s);
+        m_data.reserve(static_cast<std::size_t>(s) + 1);
+        m_data.push_back(static_cast<char>(t));
+        m_data.insert(m_data.end(), p, p + s);
+    }
+    ext(int8_t t, uint32_t s) {
+        detail::check_container_size_for_ext<sizeof(std::size_t)>(s);
+        m_data.resize(static_cast<std::size_t>(s) + 1);
+        m_data[0] = static_cast<char>(t);
+    }
+    ext(ext_ref const&);
+    int8_t type() const {
+        return static_cast<int8_t>(m_data[0]);
+    }
+    const char* data() const {
+        return &m_data[1];
+    }
+    char* data() {
+        return &m_data[1];
+    }
+    uint32_t size() const {
+        return static_cast<uint32_t>(m_data.size()) - 1;
+    }
+    bool operator== (const ext& x) const {
+        return m_data == x.m_data;
+    }
+
+    bool operator!= (const ext& x) const {
+        return !(*this == x);
+    }
+
+    bool operator< (const ext& x) const {
+        return m_data < x.m_data;
+    }
+
+    bool operator> (const ext& x) const {
+        return m_data > x.m_data;
+    }
+private:
+    std::vector<char> m_data;
+    friend class ext_ref;
+};
+
+} // namespace type
+
+namespace adaptor {
+
+template <>
+struct convert<msgpack::type::ext> {
+    msgpack::object const& operator()(msgpack::object const& o, msgpack::type::ext& v) const {
+        if(o.type != msgpack::type::EXT) {
+            throw msgpack::type_error();
+        }
+        v = msgpack::type::ext(o.via.ext.type(), o.via.ext.data(), o.via.ext.size);
+        return o;
+    }
+};
+
+template <>
+struct pack<msgpack::type::ext> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const msgpack::type::ext& v) const {
+        // size limit has already been checked at ext's constructor
+        uint32_t size = v.size();
+        o.pack_ext(size, v.type());
+        o.pack_ext_body(v.data(), size);
+        return o;
+    }
+};
+
+template <>
+struct object_with_zone<msgpack::type::ext> {
+    void operator()(msgpack::object::with_zone& o, const msgpack::type::ext& v) const {
+        // size limit has already been checked at ext's constructor
+        uint32_t size = v.size();
+        o.type = msgpack::type::EXT;
+        char* ptr = static_cast<char*>(o.zone.allocate_align(size + 1));
+        o.via.ext.ptr = ptr;
+        o.via.ext.size = size;
+        ptr[0] = static_cast<char>(v.type());
+        std::memcpy(ptr + 1, v.data(), size);
+    }
+};
+
+} // namespace adaptor
+
+namespace type {
+
+class ext_ref {
+public:
+    // ext_ref should be default constructible to support 'convert'.
+    // A default constructed ext_ref object::m_ptr doesn't have the buffer to point to.
+    // In order to avoid nullptr checking branches, m_ptr points to m_size.
+    // So type() returns unspecified but valid value. It might be a zero because m_size
+    // is initialized as zero, but shouldn't assume that.
+    ext_ref() : m_ptr(static_cast<char*>(static_cast<void*>(&m_size))), m_size(0) {}
+    ext_ref(const char* p, uint32_t s) :
+        m_ptr(s == 0 ? static_cast<char*>(static_cast<void*>(&m_size)) : p),
+        m_size(s == 0 ? 0 : s - 1) {
+        detail::check_container_size_for_ext<sizeof(std::size_t)>(s);
+    }
+
+    // size limit has already been checked at ext's constructor
+    ext_ref(ext const& x) : m_ptr(&x.m_data[0]), m_size(x.size()) {}
+
+    const char* data() const {
+        return m_ptr + 1;
+    }
+
+    uint32_t size() const {
+        return m_size;
+    }
+
+    int8_t type() const {
+        return static_cast<int8_t>(m_ptr[0]);
+    }
+
+    std::string str() const {
+        return std::string(m_ptr + 1, m_size);
+    }
+
+    bool operator== (const ext_ref& x) const {
+        return m_size == x.m_size && std::memcmp(m_ptr, x.m_ptr, m_size) == 0;
+    }
+
+    bool operator!= (const ext_ref& x) const {
+        return !(*this == x);
+    }
+
+    bool operator< (const ext_ref& x) const {
+        if (m_size < x.m_size) return true;
+        if (m_size > x.m_size) return false;
+        return std::memcmp(m_ptr, x.m_ptr, m_size) < 0;
+    }
+
+    bool operator> (const ext_ref& x) const {
+        if (m_size > x.m_size) return true;
+        if (m_size < x.m_size) return false;
+        return std::memcmp(m_ptr, x.m_ptr, m_size) > 0;
+    }
+private:
+    const char* m_ptr;
+    uint32_t m_size;
+    friend struct msgpack::adaptor::object<msgpack::type::ext_ref>;
+};
+
+inline ext::ext(ext_ref const& x) {
+    // size limit has already been checked at ext_ref's constructor
+    m_data.reserve(x.size() + 1);
+
+    m_data.push_back(x.type());
+    m_data.insert(m_data.end(), x.data(), x.data() + x.size());
+}
+
+} // namespace type
+
+namespace adaptor {
+
+template <>
+struct convert<msgpack::type::ext_ref> {
+    msgpack::object const& operator()(msgpack::object const& o, msgpack::type::ext_ref& v) const {
+        if(o.type != msgpack::type::EXT) { throw msgpack::type_error(); }
+        v = msgpack::type::ext_ref(o.via.ext.ptr, o.via.ext.size + 1);
+        return o;
+    }
+};
+
+template <>
+struct pack<msgpack::type::ext_ref> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const msgpack::type::ext_ref& v) const {
+        // size limit has already been checked at ext_ref's constructor
+        uint32_t size = v.size();
+        o.pack_ext(size, v.type());
+        o.pack_ext_body(v.data(), size);
+        return o;
+    }
+};
+
+template <>
+struct object<msgpack::type::ext_ref> {
+    void operator()(msgpack::object& o, const msgpack::type::ext_ref& v) const {
+        // size limit has already been checked at ext_ref's constructor
+        uint32_t size = v.size();
+        o.type = msgpack::type::EXT;
+        o.via.ext.ptr = v.m_ptr;
+        o.via.ext.size = size;
+    }
+};
+
+template <>
+struct object_with_zone<msgpack::type::ext_ref> {
+    void operator()(msgpack::object::with_zone& o, const msgpack::type::ext_ref& v) const {
+        static_cast<msgpack::object&>(o) << v;
+    }
+};
+
+} // namespace adaptor
+
+/// @cond
+} // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+} // namespace msgpack
+
+#endif // MSGPACK_TYPE_EXT_HPP

include/msgpack/adaptor/list.hpp

@@ -32,14 +32,32 @@ MSGPACK_API_VERSION_NAMESPACE(v1) {
 
 namespace adaptor {
 
-template <typename T>
-struct convert<std::list<T> > {
-    msgpack::object const& operator()(msgpack::object const& o, std::list<T>& v) const {
+#if !defined(MSGPACK_USE_CPP03)
+
+template <typename T, typename Alloc>
+struct as<std::list<T, Alloc>, typename std::enable_if<msgpack::has_as<T>::value>::type> {
+    std::list<T, Alloc> operator()(msgpack::object const& o) const {
+        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+        std::list<T, Alloc> v;
+        msgpack::object* p = o.via.array.ptr;
+        msgpack::object* const pend = o.via.array.ptr + o.via.array.size;
+        for (; p < pend; ++p) {
+            v.push_back(p->as<T>());
+        }
+        return v;
+    }
+};
+
+#endif // !defined(MSGPACK_USE_CPP03)
+
+template <typename T, typename Alloc>
+struct convert<std::list<T, Alloc> > {
+    msgpack::object const& operator()(msgpack::object const& o, std::list<T, Alloc>& v) const {
         if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
         v.resize(o.via.array.size);
         msgpack::object* p = o.via.array.ptr;
         msgpack::object* const pend = o.via.array.ptr + o.via.array.size;
-        typename std::list<T>::iterator it = v.begin();
+        typename std::list<T, Alloc>::iterator it = v.begin();
         for (; p < pend; ++p, ++it) {
             p->convert(*it);
         }
@@ -47,13 +65,13 @@ struct convert<std::list<T> > {
     }
 };
 
-template <typename T>
-struct pack<std::list<T> > {
+template <typename T, typename Alloc>
+struct pack<std::list<T, Alloc> > {
     template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::list<T>& v) const {
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::list<T, Alloc>& v) const {
         uint32_t size = checked_get_container_size(v.size());
         o.pack_array(size);
-        for(typename std::list<T>::const_iterator it(v.begin()), it_end(v.end());
+        for (typename std::list<T, Alloc>::const_iterator it(v.begin()), it_end(v.end());
             it != it_end; ++it) {
             o.pack(*it);
         }
@@ -61,20 +79,21 @@ struct pack<std::list<T> > {
     }
 };
 
-template <typename T>
-struct object_with_zone<std::list<T> > {
-    void operator()(msgpack::object::with_zone& o, const std::list<T>& v) const {
+template <typename T, typename Alloc>
+struct object_with_zone<std::list<T, Alloc> > {
+    void operator()(msgpack::object::with_zone& o, const std::list<T, Alloc>& v) const {
         o.type = msgpack::type::ARRAY;
         if (v.empty()) {
             o.via.array.ptr = nullptr;
             o.via.array.size = 0;
-        } else {
+        }
+        else {
             uint32_t size = checked_get_container_size(v.size());
             msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
             msgpack::object* const pend = p + size;
             o.via.array.ptr = p;
             o.via.array.size = size;
-            typename std::list<T>::const_iterator it(v.begin());
+            typename std::list<T, Alloc>::const_iterator it(v.begin());
             do {
                 *p = msgpack::object(*it, o.zone);
                 ++p;

include/msgpack/adaptor/map.hpp

@@ -34,14 +34,18 @@ MSGPACK_API_VERSION_NAMESPACE(v1) {
 
 namespace type {
 
-template <typename K, typename V>
-class assoc_vector : public std::vector< std::pair<K, V> > {};
+template <typename K, typename V, typename Compare = std::less<K>, typename Alloc = std::allocator<std::pair<K, V> > >
+class assoc_vector : public std::vector< std::pair<K, V>, Alloc > {
+#if !defined(MSGPACK_USE_CPP03)
+    using std::vector<std::pair<K, V>, Alloc>::vector;
+#endif // !defined(MSGPACK_USE_CPP03)
+};
 
 namespace detail {
-    template <typename K, typename V>
+    template <typename K, typename V, typename Compare, typename Alloc>
     struct pair_first_less {
         bool operator() (const std::pair<K, V>& x, const std::pair<K, V>& y) const
-            { return x.first < y.first; }
+            { return Compare()(x.first, y.first); }
     };
 }
 
@@ -49,9 +53,31 @@ namespace detail {
 
 namespace adaptor {
 
-template <typename K, typename V>
-struct convert<type::assoc_vector<K, V> > {
-    msgpack::object const& operator()(msgpack::object const& o, type::assoc_vector<K,V>& v) const {
+#if !defined(MSGPACK_USE_CPP03)
+
+template <typename K, typename V, typename Compare, typename Alloc>
+struct as<
+    type::assoc_vector<K, V, Compare, Alloc>,
+    typename std::enable_if<msgpack::has_as<K>::value && msgpack::has_as<V>::value>::type> {
+    type::assoc_vector<K, V, Compare, Alloc> operator()(msgpack::object const& o) const {
+        if (o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
+        type::assoc_vector<K, V, Compare, Alloc> v;
+        v.reserve(o.via.map.size);
+        msgpack::object_kv* p = o.via.map.ptr;
+        msgpack::object_kv* const pend = o.via.map.ptr + o.via.map.size;
+        for (; p < pend; ++p) {
+            v.emplace_back(p->key.as<K>(), p->val.as<V>());
+        }
+        std::sort(v.begin(), v.end(), type::detail::pair_first_less<K, V, Compare, Alloc>());
+        return v;
+    }
+};
+
+#endif // !defined(MSGPACK_USE_CPP03)
+
+template <typename K, typename V, typename Compare, typename Alloc>
+struct convert<type::assoc_vector<K, V, Compare, Alloc> > {
+    msgpack::object const& operator()(msgpack::object const& o, type::assoc_vector<K, V, Compare, Alloc>& v) const {
         if (o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
         v.resize(o.via.map.size);
         msgpack::object_kv* p = o.via.map.ptr;
@@ -61,18 +87,18 @@ struct convert<type::assoc_vector<K, V> > {
             p->key.convert(it->first);
             p->val.convert(it->second);
         }
-        std::sort(v.begin(), v.end(), type::detail::pair_first_less<K,V>());
+        std::sort(v.begin(), v.end(), type::detail::pair_first_less<K, V, Compare, Alloc>());
         return o;
     }
 };
 
-template <typename K, typename V>
-struct pack<type::assoc_vector<K, V> > {
+template <typename K, typename V, typename Compare, typename Alloc>
+struct pack<type::assoc_vector<K, V, Compare, Alloc> > {
     template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const type::assoc_vector<K,V>& v) const {
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const type::assoc_vector<K, V, Compare, Alloc>& v) const {
         uint32_t size = checked_get_container_size(v.size());
         o.pack_map(size);
-        for(typename type::assoc_vector<K,V>::const_iterator it(v.begin()), it_end(v.end());
+        for (typename type::assoc_vector<K, V, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
             it != it_end; ++it) {
             o.pack(it->first);
             o.pack(it->second);
@@ -81,20 +107,21 @@ struct pack<type::assoc_vector<K, V> > {
     }
 };
 
-template <typename K, typename V>
-struct object_with_zone<type::assoc_vector<K, V> > {
-    void operator()(msgpack::object::with_zone& o, const type::assoc_vector<K,V>& v) const {
+template <typename K, typename V, typename Compare, typename Alloc>
+struct object_with_zone<type::assoc_vector<K, V, Compare, Alloc> > {
+    void operator()(msgpack::object::with_zone& o, const type::assoc_vector<K, V, Compare, Alloc>& v) const {
         o.type = msgpack::type::MAP;
         if (v.empty()) {
             o.via.map.ptr  = nullptr;
             o.via.map.size = 0;
-        } else {
+        }
+        else {
             uint32_t size = checked_get_container_size(v.size());
             msgpack::object_kv* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size));
             msgpack::object_kv* const pend = p + size;
             o.via.map.ptr  = p;
             o.via.map.size = size;
-            typename type::assoc_vector<K,V>::const_iterator it(v.begin());
+            typename type::assoc_vector<K, V, Compare, Alloc>::const_iterator it(v.begin());
             do {
                 p->key = msgpack::object(it->first, o.zone);
                 p->val = msgpack::object(it->second, o.zone);
@@ -105,37 +132,58 @@ struct object_with_zone<type::assoc_vector<K, V> > {
     }
 };
 
-template <typename K, typename V>
-struct convert<std::map<K, V> > {
-    msgpack::object const& operator()(msgpack::object const& o, std::map<K, V>& v) const {
+#if !defined(MSGPACK_USE_CPP03)
+
+template <typename K, typename V, typename Compare, typename Alloc>
+struct as<
+    std::map<K, V, Compare, Alloc>,
+    typename std::enable_if<msgpack::has_as<K>::value && msgpack::has_as<V>::value>::type> {
+    std::map<K, V, Compare, Alloc> operator()(msgpack::object const& o) const {
         if (o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
         msgpack::object_kv* p(o.via.map.ptr);
         msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
-        std::map<K, V> tmp;
+        std::map<K, V, Compare, Alloc> v;
+        for (; p != pend; ++p) {
+            v.emplace(p->key.as<K>(), p->val.as<V>());
+        }
+        return v;
+    }
+};
+
+#endif // !defined(MSGPACK_USE_CPP03)
+
+template <typename K, typename V, typename Compare, typename Alloc>
+struct convert<std::map<K, V, Compare, Alloc> > {
+    msgpack::object const& operator()(msgpack::object const& o, std::map<K, V, Compare, Alloc>& v) const {
+        if (o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
+        msgpack::object_kv* p(o.via.map.ptr);
+        msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
+        std::map<K, V, Compare, Alloc> tmp;
         for (; p != pend; ++p) {
             K key;
             p->key.convert(key);
-            typename std::map<K,V>::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<K,V>(key, val));
-            }
+#if __cplusplus >= 201103L
+            p->val.convert(tmp[std::move(key)]);
+#else
+            p->val.convert(tmp[key]);
+#endif
         }
+#if __cplusplus >= 201103L
+        v = std::move(tmp);
+#else
         tmp.swap(v);
+#endif
         return o;
     }
 };
 
-template <typename K, typename V>
-struct pack<std::map<K, V> > {
+template <typename K, typename V, typename Compare, typename Alloc>
+struct pack<std::map<K, V, Compare, Alloc> > {
     template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::map<K,V>& v) const {
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::map<K, V, Compare, Alloc>& v) const {
         uint32_t size = checked_get_container_size(v.size());
         o.pack_map(size);
-        for(typename std::map<K,V>::const_iterator it(v.begin()), it_end(v.end());
+        for (typename std::map<K, V, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
             it != it_end; ++it) {
             o.pack(it->first);
             o.pack(it->second);
@@ -144,20 +192,21 @@ struct pack<std::map<K, V> > {
     }
 };
 
-template <typename K, typename V>
-struct object_with_zone<std::map<K, V> > {
-    void operator()(msgpack::object::with_zone& o, const std::map<K,V>& v) const {
+template <typename K, typename V, typename Compare, typename Alloc>
+struct object_with_zone<std::map<K, V, Compare, Alloc> > {
+    void operator()(msgpack::object::with_zone& o, const std::map<K, V, Compare, Alloc>& v) const {
         o.type = msgpack::type::MAP;
         if (v.empty()) {
             o.via.map.ptr  = nullptr;
             o.via.map.size = 0;
-        } else {
+        }
+        else {
             uint32_t size = checked_get_container_size(v.size());
             msgpack::object_kv* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size));
             msgpack::object_kv* const pend = p + size;
             o.via.map.ptr  = p;
             o.via.map.size = size;
-            typename std::map<K,V>::const_iterator it(v.begin());
+            typename std::map<K, V, Compare, Alloc>::const_iterator it(v.begin());
             do {
                 p->key = msgpack::object(it->first, o.zone);
                 p->val = msgpack::object(it->second, o.zone);
@@ -168,32 +217,59 @@ struct object_with_zone<std::map<K, V> > {
     }
 };
 
+#if !defined(MSGPACK_USE_CPP03)
 
-template <typename K, typename V>
-struct convert<std::multimap<K, V> > {
-    msgpack::object const& operator()(msgpack::object const& o, std::multimap<K, V>& v) const {
+template <typename K, typename V, typename Compare, typename Alloc>
+struct as<
+    std::multimap<K, V, Compare, Alloc>,
+    typename std::enable_if<msgpack::has_as<K>::value && msgpack::has_as<V>::value>::type> {
+    std::multimap<K, V, Compare, Alloc> operator()(msgpack::object const& o) const {
         if (o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
         msgpack::object_kv* p(o.via.map.ptr);
         msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
-        std::multimap<K, V> tmp;
+        std::multimap<K, V, Compare, Alloc> v;
+        for (; p != pend; ++p) {
+            v.emplace(p->key.as<K>(), p->val.as<V>());
+        }
+        return v;
+    }
+};
+
+#endif // !defined(MSGPACK_USE_CPP03)
+
+template <typename K, typename V, typename Compare, typename Alloc>
+struct convert<std::multimap<K, V, Compare, Alloc> > {
+    msgpack::object const& operator()(msgpack::object const& o, std::multimap<K, V, Compare, Alloc>& v) const {
+        if (o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
+        msgpack::object_kv* p(o.via.map.ptr);
+        msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
+        std::multimap<K, V, Compare, Alloc> tmp;
         for (; p != pend; ++p) {
             std::pair<K, V> value;
             p->key.convert(value.first);
             p->val.convert(value.second);
+#if __cplusplus >= 201103L
+            tmp.insert(std::move(value));
+#else
             tmp.insert(value);
+#endif
         }
+#if __cplusplus >= 201103L
+        v = std::move(tmp);
+#else
         tmp.swap(v);
+#endif
         return o;
     }
 };
 
-template <typename K, typename V>
-struct pack<std::multimap<K, V> > {
+template <typename K, typename V, typename Compare, typename Alloc>
+struct pack<std::multimap<K, V, Compare, Alloc> > {
     template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::multimap<K,V>& v) const {
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::multimap<K, V, Compare, Alloc>& v) const {
         uint32_t size = checked_get_container_size(v.size());
         o.pack_map(size);
-        for(typename std::multimap<K,V>::const_iterator it(v.begin()), it_end(v.end());
+        for (typename std::multimap<K, V, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
             it != it_end; ++it) {
             o.pack(it->first);
             o.pack(it->second);
@@ -202,20 +278,21 @@ struct pack<std::multimap<K, V> > {
     }
 };
 
-template <typename K, typename V>
-struct object_with_zone<std::multimap<K, V> > {
-    void operator()(msgpack::object::with_zone& o, const std::multimap<K,V>& v) const {
+template <typename K, typename V, typename Compare, typename Alloc>
+struct object_with_zone<std::multimap<K, V, Compare, Alloc> > {
+    void operator()(msgpack::object::with_zone& o, const std::multimap<K, V, Compare, Alloc>& v) const {
         o.type = msgpack::type::MAP;
         if (v.empty()) {
             o.via.map.ptr  = nullptr;
             o.via.map.size = 0;
-        } else {
+        }
+        else {
             uint32_t size = checked_get_container_size(v.size());
             msgpack::object_kv* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size));
             msgpack::object_kv* const pend = p + size;
             o.via.map.ptr  = p;
             o.via.map.size = size;
-            typename std::multimap<K,V>::const_iterator it(v.begin());
+            typename std::multimap<K, V, Compare, Alloc>::const_iterator it(v.begin());
             do {
                 p->key = msgpack::object(it->first, o.zone);
                 p->val = msgpack::object(it->second, o.zone);

include/msgpack/adaptor/nil.hpp

@@ -31,6 +31,14 @@ namespace type {
 
 struct nil { };
 
+inline bool operator<(nil const& lhs, nil const& rhs) {
+    return &lhs < &rhs;
+}
+
+inline bool operator==(nil const& lhs, nil const& rhs) {
+    return &lhs == &rhs;
+}
+
 }  // namespace type
 
 namespace adaptor {
@@ -66,7 +74,7 @@ struct object_with_zone<type::nil> {
     }
 };
 
-} // namespace adaptror
+} // namespace adaptor
 
 template <>
 inline void msgpack::object::as<void>() const

include/msgpack/adaptor/pair.hpp

@@ -20,6 +20,8 @@
 
 #include "msgpack/versioning.hpp"
 #include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/meta.hpp"
+
 #include <utility>
 
 namespace msgpack {
@@ -30,6 +32,20 @@ MSGPACK_API_VERSION_NAMESPACE(v1) {
 
 namespace adaptor {
 
+#if !defined(MSGPACK_USE_CPP03)
+
+template <typename T1, typename T2>
+struct as<std::pair<T1, T2>,
+          typename std::enable_if<msgpack::all_of<msgpack::has_as, T1, T2>::value>::type> {
+    std::pair<T1, T2> operator()(msgpack::object const& o) const {
+        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+        if (o.via.array.size != 2) { throw msgpack::type_error(); }
+        return std::make_pair(o.via.array.ptr[0].as<T1>(), o.via.array.ptr[1].as<T2>());
+    }
+};
+
+#endif // !defined(MSGPACK_USE_CPP03)
+
 template <typename T1, typename T2>
 struct convert<std::pair<T1, T2> > {
     msgpack::object const& operator()(msgpack::object const& o, std::pair<T1, T2>& v) const {

include/msgpack/adaptor/raw.hpp

@@ -47,7 +47,7 @@ struct raw_ref {
 
     bool operator!= (const raw_ref& x) const
     {
-        return !(*this != x);
+        return !(*this == x);
     }
 
     bool operator< (const raw_ref& x) const

include/msgpack/adaptor/set.hpp

@@ -32,29 +32,52 @@ MSGPACK_API_VERSION_NAMESPACE(v1) {
 
 namespace adaptor {
 
-template <typename T>
-struct convert<std::set<T> > {
-    msgpack::object const& operator()(msgpack::object const& o, std::set<T>& v) const {
+#if !defined(MSGPACK_USE_CPP03)
+
+template <typename T, typename Compare, typename Alloc>
+struct as<std::set<T, Compare, Alloc>, typename std::enable_if<msgpack::has_as<T>::value>::type> {
+    std::set<T, Compare, Alloc> operator()(msgpack::object const& o) const {
         if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
         msgpack::object* p = o.via.array.ptr + o.via.array.size;
         msgpack::object* const pbegin = o.via.array.ptr;
-        std::set<T> tmp;
+        std::set<T, Compare, Alloc> v;
+        while (p > pbegin) {
+            --p;
+            v.insert(p->as<T>());
+        }
+        return v;
+    }
+};
+
+#endif // !defined(MSGPACK_USE_CPP03)
+
+template <typename T, typename Compare, typename Alloc>
+struct convert<std::set<T, Compare, Alloc> > {
+    msgpack::object const& operator()(msgpack::object const& o, std::set<T, Compare, Alloc>& v) const {
+        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+        msgpack::object* p = o.via.array.ptr + o.via.array.size;
+        msgpack::object* const pbegin = o.via.array.ptr;
+        std::set<T, Compare, Alloc> tmp;
         while (p > pbegin) {
             --p;
             tmp.insert(p->as<T>());
         }
+#if __cplusplus >= 201103L
+        v = std::move(tmp);
+#else
         tmp.swap(v);
+#endif
         return o;
     }
 };
 
-template <typename T>
-struct pack<std::set<T> > {
+template <typename T, typename Compare, typename Alloc>
+struct pack<std::set<T, Compare, Alloc> > {
     template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::set<T>& v) const {
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::set<T, Compare, Alloc>& v) const {
         uint32_t size = checked_get_container_size(v.size());
         o.pack_array(size);
-        for(typename std::set<T>::const_iterator it(v.begin()), it_end(v.end());
+        for (typename std::set<T, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
             it != it_end; ++it) {
             o.pack(*it);
         }
@@ -62,20 +85,21 @@ struct pack<std::set<T> > {
     }
 };
 
-template <typename T>
-struct object_with_zone<std::set<T> > {
-    void operator()(msgpack::object::with_zone& o, const std::set<T>& v) const {
+template <typename T, typename Compare, typename Alloc>
+struct object_with_zone<std::set<T, Compare, Alloc> > {
+    void operator()(msgpack::object::with_zone& o, const std::set<T, Compare, Alloc>& v) const {
         o.type = msgpack::type::ARRAY;
         if (v.empty()) {
             o.via.array.ptr = nullptr;
             o.via.array.size = 0;
-        } else {
+        }
+        else {
             uint32_t size = checked_get_container_size(v.size());
             msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
             msgpack::object* const pend = p + size;
             o.via.array.ptr = p;
             o.via.array.size = size;
-            typename std::set<T>::const_iterator it(v.begin());
+            typename std::set<T, Compare, Alloc>::const_iterator it(v.begin());
             do {
                 *p = msgpack::object(*it, o.zone);
                 ++p;
@@ -85,29 +109,52 @@ struct object_with_zone<std::set<T> > {
     }
 };
 
-template <typename T>
-struct convert<std::multiset<T> > {
-    msgpack::object const& operator()(msgpack::object const& o, std::multiset<T>& v) const {
+#if !defined(MSGPACK_USE_CPP03)
+
+template <typename T, typename Compare, typename Alloc>
+struct as<std::multiset<T, Compare, Alloc>, typename std::enable_if<msgpack::has_as<T>::value>::type> {
+    std::multiset<T, Compare, Alloc> operator()(msgpack::object const& o) const {
         if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
         msgpack::object* p = o.via.array.ptr + o.via.array.size;
         msgpack::object* const pbegin = o.via.array.ptr;
-        std::multiset<T> tmp;
+        std::multiset<T, Compare, Alloc> v;
+        while (p > pbegin) {
+            --p;
+            v.insert(p->as<T>());
+        }
+        return v;
+    }
+};
+
+#endif // !defined(MSGPACK_USE_CPP03)
+
+template <typename T, typename Compare, typename Alloc>
+struct convert<std::multiset<T, Compare, Alloc> > {
+    msgpack::object const& operator()(msgpack::object const& o, std::multiset<T, Compare, Alloc>& v) const {
+        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+        msgpack::object* p = o.via.array.ptr + o.via.array.size;
+        msgpack::object* const pbegin = o.via.array.ptr;
+        std::multiset<T, Compare, Alloc> tmp;
         while (p > pbegin) {
             --p;
             tmp.insert(p->as<T>());
         }
+#if __cplusplus >= 201103L
+        v = std::move(tmp);
+#else
         tmp.swap(v);
+#endif
         return o;
     }
 };
 
-template <typename T>
-struct pack<std::multiset<T> > {
+template <typename T, typename Compare, typename Alloc>
+struct pack<std::multiset<T, Compare, Alloc> > {
     template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::multiset<T>& v) const {
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::multiset<T, Compare, Alloc>& v) const {
         uint32_t size = checked_get_container_size(v.size());
         o.pack_array(size);
-        for(typename std::multiset<T>::const_iterator it(v.begin()), it_end(v.end());
+        for (typename std::multiset<T, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
             it != it_end; ++it) {
             o.pack(*it);
         }
@@ -115,9 +162,9 @@ struct pack<std::multiset<T> > {
     }
 };
 
-template <typename T>
-struct object_with_zone<std::multiset<T> > {
-    void operator()(msgpack::object::with_zone& o, const std::multiset<T>& v) const {
+template <typename T, typename Compare, typename Alloc>
+struct object_with_zone<std::multiset<T, Compare, Alloc> > {
+    void operator()(msgpack::object::with_zone& o, const std::multiset<T, Compare, Alloc>& v) const {
         o.type = msgpack::type::ARRAY;
         if (v.empty()) {
             o.via.array.ptr = nullptr;
@@ -128,7 +175,7 @@ struct object_with_zone<std::multiset<T> > {
             msgpack::object* const pend = p + size;
             o.via.array.ptr = p;
             o.via.array.size = size;
-            typename std::multiset<T>::const_iterator it(v.begin());
+            typename std::multiset<T, Compare, Alloc>::const_iterator it(v.begin());
             do {
                 *p = msgpack::object(*it, o.zone);
                 ++p;

include/msgpack/adaptor/tr1/unordered_map.hpp

@@ -51,13 +51,13 @@ MSGPACK_API_VERSION_NAMESPACE(v1) {
 
 namespace adaptor {
 
-template <typename K, typename V>
-struct convert<MSGPACK_STD_TR1::unordered_map<K, V> > {
-    msgpack::object const& operator()(msgpack::object const& o, MSGPACK_STD_TR1::unordered_map<K, V>& v) const {
+template <typename K, typename V, typename Hash, typename Pred, typename Alloc>
+struct convert<MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc> > {
+    msgpack::object const& operator()(msgpack::object const& o, MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc>& v) const {
         if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
         msgpack::object_kv* p(o.via.map.ptr);
         msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
-        MSGPACK_STD_TR1::unordered_map<K, V> tmp;
+        MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc> tmp;
         for(; p != pend; ++p) {
             K key;
             p->key.convert(key);
@@ -68,13 +68,13 @@ struct convert<MSGPACK_STD_TR1::unordered_map<K, V> > {
     }
 };
 
-template <typename K, typename V>
-struct pack<MSGPACK_STD_TR1::unordered_map<K, V> > {
+template <typename K, typename V, typename Hash, typename Pred, typename Alloc>
+struct pack<MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc> > {
     template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const MSGPACK_STD_TR1::unordered_map<K,V>& v) const {
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc>& v) const {
         uint32_t size = checked_get_container_size(v.size());
         o.pack_map(size);
-        for(typename MSGPACK_STD_TR1::unordered_map<K,V>::const_iterator it(v.begin()), it_end(v.end());
+        for(typename MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc>::const_iterator it(v.begin()), it_end(v.end());
             it != it_end; ++it) {
             o.pack(it->first);
             o.pack(it->second);
@@ -83,9 +83,9 @@ struct pack<MSGPACK_STD_TR1::unordered_map<K, V> > {
     }
 };
 
-template <typename K, typename V>
-struct object_with_zone<MSGPACK_STD_TR1::unordered_map<K, V> > {
-    void operator()(msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_map<K,V>& v) const {
+template <typename K, typename V, typename Hash, typename Pred, typename Alloc>
+struct object_with_zone<MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc> > {
+    void operator()(msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc>& v) const {
         o.type = msgpack::type::MAP;
         if(v.empty()) {
             o.via.map.ptr  = nullptr;
@@ -96,7 +96,7 @@ struct object_with_zone<MSGPACK_STD_TR1::unordered_map<K, V> > {
             msgpack::object_kv* const pend = p + size;
             o.via.map.ptr  = p;
             o.via.map.size = size;
-            typename MSGPACK_STD_TR1::unordered_map<K,V>::const_iterator it(v.begin());
+            typename MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc>::const_iterator it(v.begin());
             do {
                 p->key = msgpack::object(it->first, o.zone);
                 p->val = msgpack::object(it->second, o.zone);
@@ -107,13 +107,13 @@ struct object_with_zone<MSGPACK_STD_TR1::unordered_map<K, V> > {
     }
 };
 
-template <typename K, typename V>
-struct convert<MSGPACK_STD_TR1::unordered_multimap<K, V> > {
-    msgpack::object const& operator()(msgpack::object const& o, MSGPACK_STD_TR1::unordered_multimap<K, V>& v) const {
+template <typename K, typename V, typename Hash, typename Pred, typename Alloc>
+struct convert<MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Alloc> > {
+    msgpack::object const& operator()(msgpack::object const& o, MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Alloc>& v) const {
         if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
         msgpack::object_kv* p(o.via.map.ptr);
         msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
-        MSGPACK_STD_TR1::unordered_multimap<K, V> tmp;
+        MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Alloc> tmp;
         for(; p != pend; ++p) {
             std::pair<K, V> value;
             p->key.convert(value.first);
@@ -125,13 +125,13 @@ struct convert<MSGPACK_STD_TR1::unordered_multimap<K, V> > {
     }
 };
 
-template <typename K, typename V>
-struct pack<MSGPACK_STD_TR1::unordered_multimap<K, V> > {
+template <typename K, typename V, typename Hash, typename Pred, typename Alloc>
+struct pack<MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Alloc> > {
     template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const MSGPACK_STD_TR1::unordered_multimap<K,V>& v) const {
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Alloc>& v) const {
         uint32_t size = checked_get_container_size(v.size());
         o.pack_map(size);
-        for(typename MSGPACK_STD_TR1::unordered_multimap<K,V>::const_iterator it(v.begin()), it_end(v.end());
+        for(typename MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Alloc>::const_iterator it(v.begin()), it_end(v.end());
             it != it_end; ++it) {
             o.pack(it->first);
             o.pack(it->second);
@@ -140,9 +140,9 @@ struct pack<MSGPACK_STD_TR1::unordered_multimap<K, V> > {
     }
 };
 
-template <typename K, typename V>
-struct object_with_zone<MSGPACK_STD_TR1::unordered_multimap<K, V> > {
-    void operator()(msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_multimap<K,V>& v) const {
+template <typename K, typename V, typename Hash, typename Pred, typename Alloc>
+struct object_with_zone<MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Alloc> > {
+    void operator()(msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Alloc>& v) const {
         o.type = msgpack::type::MAP;
         if(v.empty()) {
             o.via.map.ptr  = nullptr;
@@ -153,7 +153,7 @@ struct object_with_zone<MSGPACK_STD_TR1::unordered_multimap<K, V> > {
             msgpack::object_kv* const pend = p + size;
             o.via.map.ptr  = p;
             o.via.map.size = size;
-            typename MSGPACK_STD_TR1::unordered_multimap<K,V>::const_iterator it(v.begin());
+            typename MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Alloc>::const_iterator it(v.begin());
             do {
                 p->key = msgpack::object(it->first, o.zone);
                 p->val = msgpack::object(it->second, o.zone);

include/msgpack/adaptor/tr1/unordered_set.hpp

@@ -51,13 +51,13 @@ MSGPACK_API_VERSION_NAMESPACE(v1) {
 
 namespace adaptor {
 
-template <typename T>
-struct convert<MSGPACK_STD_TR1::unordered_set<T> > {
-    msgpack::object const& operator()(msgpack::object const& o, MSGPACK_STD_TR1::unordered_set<T>& v) const {
+template <typename T, typename Hash, typename Compare, typename Alloc>
+struct convert<MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc> > {
+    msgpack::object const& operator()(msgpack::object const& o, MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc>& v) const {
         if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
         msgpack::object* p = o.via.array.ptr + o.via.array.size;
         msgpack::object* const pbegin = o.via.array.ptr;
-        MSGPACK_STD_TR1::unordered_set<T> tmp;
+        MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc> tmp;
         while(p > pbegin) {
             --p;
             tmp.insert(p->as<T>());
@@ -67,13 +67,13 @@ struct convert<MSGPACK_STD_TR1::unordered_set<T> > {
     }
 };
 
-template <typename T>
-struct pack<MSGPACK_STD_TR1::unordered_set<T> > {
+template <typename T, typename Hash, typename Compare, typename Alloc>
+struct pack<MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc> > {
     template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const MSGPACK_STD_TR1::unordered_set<T>& v) const {
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc>& v) const {
         uint32_t size = checked_get_container_size(v.size());
         o.pack_array(size);
-        for(typename MSGPACK_STD_TR1::unordered_set<T>::const_iterator it(v.begin()), it_end(v.end());
+        for(typename MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
             it != it_end; ++it) {
             o.pack(*it);
         }
@@ -81,9 +81,9 @@ struct pack<MSGPACK_STD_TR1::unordered_set<T> > {
     }
 };
 
-template <typename T>
-struct object_with_zone<MSGPACK_STD_TR1::unordered_set<T> > {
-    void operator()(msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_set<T>& v) const {
+template <typename T, typename Hash, typename Compare, typename Alloc>
+struct object_with_zone<MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc> > {
+    void operator()(msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc>& v) const {
         o.type = msgpack::type::ARRAY;
         if(v.empty()) {
             o.via.array.ptr = nullptr;
@@ -94,7 +94,7 @@ struct object_with_zone<MSGPACK_STD_TR1::unordered_set<T> > {
             msgpack::object* const pend = p + size;
             o.via.array.ptr = p;
             o.via.array.size = size;
-            typename MSGPACK_STD_TR1::unordered_set<T>::const_iterator it(v.begin());
+            typename MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc>::const_iterator it(v.begin());
             do {
                 *p = msgpack::object(*it, o.zone);
                 ++p;
@@ -105,13 +105,13 @@ struct object_with_zone<MSGPACK_STD_TR1::unordered_set<T> > {
 };
 
 
-template <typename T>
-struct convert<MSGPACK_STD_TR1::unordered_multiset<T> > {
-    msgpack::object const& operator()(msgpack::object const& o, MSGPACK_STD_TR1::unordered_multiset<T>& v) const {
+template <typename T, typename Hash, typename Compare, typename Alloc>
+struct convert<MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Alloc> > {
+    msgpack::object const& operator()(msgpack::object const& o, MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Alloc>& v) const {
         if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
         msgpack::object* p = o.via.array.ptr + o.via.array.size;
         msgpack::object* const pbegin = o.via.array.ptr;
-        MSGPACK_STD_TR1::unordered_multiset<T> tmp;
+        MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Alloc> tmp;
         while(p > pbegin) {
             --p;
             tmp.insert(p->as<T>());
@@ -121,13 +121,13 @@ struct convert<MSGPACK_STD_TR1::unordered_multiset<T> > {
     }
 };
 
-template <typename T>
-struct pack<MSGPACK_STD_TR1::unordered_multiset<T> > {
+template <typename T, typename Hash, typename Compare, typename Alloc>
+struct pack<MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Alloc> > {
     template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const MSGPACK_STD_TR1::unordered_multiset<T>& v) const {
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Alloc>& v) const {
         uint32_t size = checked_get_container_size(v.size());
         o.pack_array(size);
-        for(typename MSGPACK_STD_TR1::unordered_multiset<T>::const_iterator it(v.begin()), it_end(v.end());
+        for(typename MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
             it != it_end; ++it) {
             o.pack(*it);
         }
@@ -135,9 +135,9 @@ struct pack<MSGPACK_STD_TR1::unordered_multiset<T> > {
     }
 };
 
-template <typename T>
-struct object_with_zone<MSGPACK_STD_TR1::unordered_multiset<T> > {
-    void operator()(msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_multiset<T>& v) const {
+template <typename T, typename Hash, typename Compare, typename Alloc>
+struct object_with_zone<MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Alloc> > {
+    void operator()(msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Alloc>& v) const {
         o.type = msgpack::type::ARRAY;
         if(v.empty()) {
             o.via.array.ptr = nullptr;
@@ -148,7 +148,7 @@ struct object_with_zone<MSGPACK_STD_TR1::unordered_multiset<T> > {
             msgpack::object* const pend = p + size;
             o.via.array.ptr = p;
             o.via.array.size = size;
-            typename MSGPACK_STD_TR1::unordered_multiset<T>::const_iterator it(v.begin());
+            typename MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Alloc>::const_iterator it(v.begin());
             do {
                 *p = msgpack::object(*it, o.zone);
                 ++p;

include/msgpack/adaptor/v4raw.hpp

@@ -0,0 +1,114 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_TYPE_V4RAW_HPP
+#define MSGPACK_TYPE_V4RAW_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include <cstring>
+#include <string>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace type {
+
+struct v4raw_ref {
+    v4raw_ref() : size(0), ptr(nullptr) {}
+    v4raw_ref(const char* p, uint32_t s) : size(s), ptr(p) {}
+
+    uint32_t size;
+    const char* ptr;
+
+    std::string str() const { return std::string(ptr, size); }
+
+    bool operator== (const v4raw_ref& x) const
+    {
+        return size == x.size && std::memcmp(ptr, x.ptr, size) == 0;
+    }
+
+    bool operator!= (const v4raw_ref& x) const
+    {
+        return !(*this == x);
+    }
+
+    bool operator< (const v4raw_ref& x) const
+    {
+        if(size == x.size) { return std::memcmp(ptr, x.ptr, size) < 0; }
+        else { return size < x.size; }
+    }
+
+    bool operator> (const v4raw_ref& x) const
+    {
+        if(size == x.size) { return std::memcmp(ptr, x.ptr, size) > 0; }
+        else { return size > x.size; }
+    }
+};
+
+} // namespace type
+
+namespace adaptor {
+
+template <>
+struct convert<msgpack::type::v4raw_ref> {
+    msgpack::object const& operator()(msgpack::object const& o, msgpack::type::v4raw_ref& v) const {
+        if(o.type != msgpack::type::STR) { throw msgpack::type_error(); }
+        v.ptr  = o.via.str.ptr;
+        v.size = o.via.str.size;
+        return o;
+    }
+};
+
+template <>
+struct pack<msgpack::type::v4raw_ref> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const msgpack::type::v4raw_ref& v) const {
+        o.pack_v4raw(v.size);
+        o.pack_v4raw_body(v.ptr, v.size);
+        return o;
+    }
+};
+
+template <>
+struct object<msgpack::type::v4raw_ref> {
+    void operator()(msgpack::object& o, const msgpack::type::v4raw_ref& v) const {
+        o.type = msgpack::type::STR;
+        o.via.str.ptr = v.ptr;
+        o.via.str.size = v.size;
+    }
+};
+
+template <>
+struct object_with_zone<msgpack::type::v4raw_ref> {
+    void operator()(msgpack::object::with_zone& o, const msgpack::type::v4raw_ref& v) const {
+        static_cast<msgpack::object&>(o) << v;
+    }
+};
+
+} // namespace adaptor
+
+/// @cond
+} // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+} // namespace msgpack
+
+#endif // MSGPACK_TYPE_V4RAW_HPP

include/msgpack/adaptor/vector.hpp

@@ -1,7 +1,7 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi
 //
 //    Licensed under the Apache License, Version 2.0 (the "License");
 //    you may not use this file except in compliance with the License.
@@ -32,15 +32,37 @@ MSGPACK_API_VERSION_NAMESPACE(v1) {
 
 namespace adaptor {
 
-template <typename T>
-struct convert<std::vector<T> > {
-    msgpack::object const& operator()(msgpack::object const& o, std::vector<T>& v) const {
+#if !defined(MSGPACK_USE_CPP03)
+
+template <typename T, typename Alloc>
+struct as<std::vector<T, Alloc>, typename std::enable_if<msgpack::has_as<T>::value>::type> {
+    std::vector<T, Alloc> operator()(const msgpack::object& o) const {
+        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+        std::vector<T, Alloc> v;
+        v.reserve(o.via.array.size);
+        if (o.via.array.size > 0) {
+            msgpack::object* p = o.via.array.ptr;
+            msgpack::object* const pend = o.via.array.ptr + o.via.array.size;
+            do {
+                v.push_back(p->as<T>());
+                ++p;
+            } while (p < pend);
+        }
+        return v;
+    }
+};
+
+#endif // !defined(MSGPACK_USE_CPP03)
+
+template <typename T, typename Alloc>
+struct convert<std::vector<T, Alloc> > {
+    msgpack::object const& operator()(msgpack::object const& o, std::vector<T, Alloc>& v) const {
         if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
         v.resize(o.via.array.size);
         if (o.via.array.size > 0) {
             msgpack::object* p = o.via.array.ptr;
             msgpack::object* const pend = o.via.array.ptr + o.via.array.size;
-            typename std::vector<T>::iterator it = v.begin();
+            typename std::vector<T, Alloc>::iterator it = v.begin();
             do {
                 p->convert(*it);
                 ++p;
@@ -51,13 +73,13 @@ struct convert<std::vector<T> > {
     }
 };
 
-template <typename T>
-struct pack<std::vector<T> > {
+template <typename T, typename Alloc>
+struct pack<std::vector<T, Alloc> > {
     template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::vector<T>& v) const {
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::vector<T, Alloc>& v) const {
         uint32_t size = checked_get_container_size(v.size());
         o.pack_array(size);
-        for(typename std::vector<T>::const_iterator it(v.begin()), it_end(v.end());
+        for (typename std::vector<T, Alloc>::const_iterator it(v.begin()), it_end(v.end());
             it != it_end; ++it) {
             o.pack(*it);
         }
@@ -65,22 +87,30 @@ struct pack<std::vector<T> > {
     }
 };
 
-template <typename T>
-struct object_with_zone<std::vector<T> > {
-    void operator()(msgpack::object::with_zone& o, const std::vector<T>& v) const {
+template <typename T, typename Alloc>
+struct object_with_zone<std::vector<T, Alloc> > {
+    void operator()(msgpack::object::with_zone& o, const std::vector<T, Alloc>& v) const {
         o.type = msgpack::type::ARRAY;
         if (v.empty()) {
             o.via.array.ptr = nullptr;
             o.via.array.size = 0;
-        } else {
+        }
+        else {
             uint32_t size = checked_get_container_size(v.size());
             msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
             msgpack::object* const pend = p + size;
             o.via.array.ptr = p;
             o.via.array.size = size;
-            typename std::vector<T>::const_iterator it(v.begin());
+            typename std::vector<T, Alloc>::const_iterator it(v.begin());
             do {
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
                 *p = msgpack::object(*it, o.zone);
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#pragma GCC diagnostic pop
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
                 ++p;
                 ++it;
             } while(p < pend);

include/msgpack/adaptor/vector_bool.hpp

@@ -30,14 +30,14 @@ MSGPACK_API_VERSION_NAMESPACE(v1) {
 
 namespace adaptor {
 
-template <>
-struct convert<std::vector<bool> > {
-    msgpack::object const& operator()(msgpack::object const& o, std::vector<bool>& v) const {
+template <typename Alloc>
+struct convert<std::vector<bool, Alloc> > {
+    msgpack::object const& operator()(msgpack::object const& o, std::vector<bool, Alloc>& v) const {
         if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
         if (o.via.array.size > 0) {
             v.resize(o.via.array.size);
             msgpack::object* p = o.via.array.ptr;
-            for (std::vector<bool>::iterator it = v.begin(), end = v.end();
+            for (typename std::vector<bool, Alloc>::iterator it = v.begin(), end = v.end();
                  it != end;
                  ++it) {
                 *it = p->as<bool>();
@@ -48,13 +48,13 @@ struct convert<std::vector<bool> > {
     }
 };
 
-template <>
-struct pack<std::vector<bool> > {
+template <typename Alloc>
+struct pack<std::vector<bool, Alloc> > {
     template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::vector<bool>& v) const {
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::vector<bool, Alloc>& v) const {
         uint32_t size = checked_get_container_size(v.size());
         o.pack_array(size);
-        for(std::vector<bool>::const_iterator it(v.begin()), it_end(v.end());
+        for(typename std::vector<bool, Alloc>::const_iterator it(v.begin()), it_end(v.end());
             it != it_end; ++it) {
             o.pack(static_cast<bool>(*it));
         }
@@ -62,9 +62,9 @@ struct pack<std::vector<bool> > {
     }
 };
 
-template <>
-struct object_with_zone<std::vector<bool> > {
-    void operator()(msgpack::object::with_zone& o, const std::vector<bool>& v) const {
+template <typename Alloc>
+struct object_with_zone<std::vector<bool, Alloc> > {
+    void operator()(msgpack::object::with_zone& o, const std::vector<bool, Alloc>& v) const {
         o.type = msgpack::type::ARRAY;
         if(v.empty()) {
             o.via.array.ptr = nullptr;
@@ -75,7 +75,7 @@ struct object_with_zone<std::vector<bool> > {
             msgpack::object* const pend = p + size;
             o.via.array.ptr = p;
             o.via.array.size = size;
-            std::vector<bool>::const_iterator it(v.begin());
+            typename std::vector<bool, Alloc>::const_iterator it(v.begin());
             do {
                 *p = msgpack::object(static_cast<bool>(*it), o.zone);
                 ++p;

include/msgpack/adaptor/vector_char.hpp

@@ -32,9 +32,9 @@ MSGPACK_API_VERSION_NAMESPACE(v1) {
 
 namespace adaptor {
 
-template <>
-struct convert<std::vector<char> > {
-    msgpack::object const& operator()(msgpack::object const& o, std::vector<char>& v) const {
+template <typename Alloc>
+struct convert<std::vector<char, Alloc> > {
+    msgpack::object const& operator()(msgpack::object const& o, std::vector<char, Alloc>& v) const {
         switch (o.type) {
         case msgpack::type::BIN:
             v.resize(o.via.bin.size);
@@ -52,10 +52,10 @@ struct convert<std::vector<char> > {
     }
 };
 
-template <>
-struct pack<std::vector<char> > {
+template <typename Alloc>
+struct pack<std::vector<char, Alloc> > {
     template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::vector<char>& v) const {
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::vector<char, Alloc>& v) const {
         uint32_t size = checked_get_container_size(v.size());
         o.pack_bin(size);
         o.pack_bin_body(&v.front(), size);
@@ -64,9 +64,9 @@ struct pack<std::vector<char> > {
     }
 };
 
-template <>
-struct object<std::vector<char> > {
-    void operator()(msgpack::object& o, const std::vector<char>& v) const {
+template <typename Alloc>
+struct object<std::vector<char, Alloc> > {
+    void operator()(msgpack::object& o, const std::vector<char, Alloc>& v) const {
         uint32_t size = checked_get_container_size(v.size());
         o.type = msgpack::type::BIN;
         o.via.bin.ptr = &v.front();
@@ -74,9 +74,9 @@ struct object<std::vector<char> > {
     }
 };
 
-template <>
-struct object_with_zone<std::vector<char> > {
-    void operator()(msgpack::object::with_zone& o, const std::vector<char>& v) const {
+template <typename Alloc>
+struct object_with_zone<std::vector<char, Alloc> > {
+    void operator()(msgpack::object::with_zone& o, const std::vector<char, Alloc>& v) const {
         uint32_t size = checked_get_container_size(v.size());
         o.type = msgpack::type::BIN;
         char* ptr = static_cast<char*>(o.zone.allocate_align(size));

include/msgpack/adaptor/vector_unsigned_char.hpp

@@ -0,0 +1,97 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2014-2015 KONDO Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_TYPE_VECTOR_UNSIGNED_CHAR_HPP
+#define MSGPACK_TYPE_VECTOR_UNSIGNED_CHAR_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/adaptor/check_container_size.hpp"
+
+#include <vector>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace adaptor {
+
+template <typename Alloc>
+struct convert<std::vector<unsigned char, Alloc> > {
+    msgpack::object const& operator()(msgpack::object const& o, std::vector<unsigned char, Alloc>& v) const {
+        switch (o.type) {
+        case msgpack::type::BIN:
+            v.resize(o.via.bin.size);
+            std::memcpy(&v.front(), o.via.bin.ptr, o.via.bin.size);
+            break;
+        case msgpack::type::STR:
+            v.resize(o.via.str.size);
+            std::memcpy(&v.front(), o.via.str.ptr, o.via.str.size);
+            break;
+        default:
+            throw msgpack::type_error();
+            break;
+        }
+        return o;
+    }
+};
+
+template <typename Alloc>
+struct pack<std::vector<unsigned char, Alloc> > {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::vector<unsigned char, Alloc>& v) const {
+        uint32_t size = checked_get_container_size(v.size());
+        o.pack_bin(size);
+        o.pack_bin_body(reinterpret_cast<char const*>(&v.front()), size);
+
+        return o;
+    }
+};
+
+template <typename Alloc>
+struct object<std::vector<unsigned char, Alloc> > {
+    void operator()(msgpack::object& o, const std::vector<unsigned char, Alloc>& v) const {
+        uint32_t size = checked_get_container_size(v.size());
+        o.type = msgpack::type::BIN;
+        o.via.bin.ptr = reinterpret_cast<char const*>(&v.front());
+        o.via.bin.size = size;
+    }
+};
+
+template <typename Alloc>
+struct object_with_zone<std::vector<unsigned char, Alloc> > {
+    void operator()(msgpack::object::with_zone& o, const std::vector<unsigned char, Alloc>& v) const {
+        uint32_t size = checked_get_container_size(v.size());
+        o.type = msgpack::type::BIN;
+        char* ptr = static_cast<char*>(o.zone.allocate_align(size));
+        o.via.bin.ptr = ptr;
+        o.via.bin.size = size;
+        std::memcpy(ptr, &v.front(), size);
+    }
+};
+
+} // namespace adaptor
+
+/// @cond
+} // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+} // namespace msgpack
+
+#endif // MSGPACK_TYPE_VECTOR_UNSIGNED_CHAR_HPP

include/msgpack/cpp_config.hpp

@@ -21,18 +21,18 @@
 #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)
+# if defined(_MSC_VER)
+#  if _MSC_VER < 1900
+#    define MSGPACK_USE_CPP03
+#  endif
+# elif (__cplusplus < 201103L)
 #  define MSGPACK_USE_CPP03
 # endif
 #endif // MSGPACK_USE_CPP03
 
 
 
-#if defined __cplusplus
-#if __cplusplus < 201103
+#if defined(MSGPACK_USE_CPP03)
 
 #if !defined(nullptr)
 #  if _MSC_VER < 1600
@@ -77,6 +77,22 @@ template <typename T>
 struct enable_if<false, T> {
 };
 
+template<typename T, T val>
+struct integral_constant {
+    static T const value = val;
+    typedef T value_type;
+    typedef integral_constant<T, val> type;
+};
+
+typedef integral_constant<bool, true> true_type;
+typedef integral_constant<bool, false> false_type;
+
+template<class T, class U>
+struct is_same : false_type {};
+
+template<class T>
+struct is_same<T, T> : true_type {};
+
 /// @cond
 }  // MSGPACK_API_VERSION_NAMESPACE(v1)
 /// @endcond
@@ -84,7 +100,7 @@ struct enable_if<false, T> {
 }  // namespace msgpack
 
 
-#else  // __cplusplus < 201103
+#else  // MSGPACK_USE_CPP03
 
 #include <memory>
 #include <tuple>
@@ -103,6 +119,7 @@ MSGPACK_API_VERSION_NAMESPACE(v1) {
     using std::move;
     using std::swap;
     using std::enable_if;
+    using std::is_same;
 
 /// @cond
 }  // MSGPACK_API_VERSION_NAMESPACE(v1)
@@ -110,8 +127,6 @@ MSGPACK_API_VERSION_NAMESPACE(v1) {
 }  // namespace msgpack
 
 
-#endif // __cplusplus < 201103
-
-#endif // __cplusplus
+#endif // MSGPACK_USE_CPP03
 
 #endif /* msgpack/cpp_config.hpp */

include/msgpack/detail/cpp03_zone.hpp

@@ -353,6 +353,12 @@ inline void zone::undo_allocate(size_t size)
     m_chunk_list.m_free += size;
 }
 
+inline std::size_t aligned_size(
+    std::size_t size,
+    std::size_t align = MSGPACK_ZONE_ALIGN) {
+    return (size + align - 1) / align * align;
+}
+
 /// @cond
 
 template <typename T>

include/msgpack/detail/cpp11_zone.hpp

@@ -97,7 +97,6 @@ private:
 
             ++m_tail;
         }
-#if !defined(MSGPACK_USE_CPP03)
         finalizer_array(finalizer_array&& other) noexcept
             :m_tail(other.m_tail), m_end(other.m_end), m_array(other.m_array)
         {
@@ -111,7 +110,7 @@ private:
             new (this) finalizer_array(std::move(other));
             return *this;
         }
-#endif
+
         finalizer* m_tail;
         finalizer* m_end;
         finalizer* m_array;
@@ -162,7 +161,6 @@ private:
             m_free = chunk_size;
             m_ptr  = reinterpret_cast<char*>(m_head) + sizeof(chunk);
         }
-#if !defined(MSGPACK_USE_CPP03)
         chunk_list(chunk_list&& other) noexcept
             :m_free(other.m_free), m_ptr(other.m_ptr), m_head(other.m_head)
         {
@@ -174,7 +172,7 @@ private:
             new (this) chunk_list(std::move(other));
             return *this;
         }
-#endif
+
         size_t m_free;
         char* m_ptr;
         chunk* m_head;
@@ -203,21 +201,21 @@ public:
     void swap(zone& o);
 
 
-    static void* operator new(std::size_t size) throw(std::bad_alloc)
+    static void* operator new(std::size_t size)
     {
         void* p = ::malloc(size);
         if (!p) throw std::bad_alloc();
         return p;
     }
-    static void operator delete(void *p) throw()
+    static void operator delete(void *p) noexcept
     {
         ::free(p);
     }
-    static void* operator new(std::size_t /*size*/, void* mem) throw()
+    static void* operator new(std::size_t /*size*/, void* mem) noexcept
     {
         return mem;
     }
-    static void operator delete(void * /*p*/, void* /*mem*/) throw()
+    static void operator delete(void * /*p*/, void* /*mem*/) noexcept
     {
     }
 
@@ -363,6 +361,12 @@ T* zone::allocate(Args... args)
     }
 }
 
+inline std::size_t aligned_size(
+    std::size_t size,
+    std::size_t align = MSGPACK_ZONE_ALIGN) {
+    return (size + align - 1) / align * align;
+}
+
 /// @cond
 }  // MSGPACK_API_VERSION_NAMESPACE(v1)
 /// @endcond

include/msgpack/meta.hpp

@@ -0,0 +1,59 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2015 KONDO Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+
+#ifndef MSGPACK_META_HPP
+#define MSGPACK_META_HPP
+
+#if !defined(MSGPACK_USE_CPP03)
+
+#include <type_traits>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace detail {
+template<bool...> struct bool_pack;
+
+template<bool...values> struct all_of_imp
+    : std::is_same<bool_pack<values..., true>, bool_pack<true, values...>>{};
+
+} // namespace detail
+
+template<template <class> class T, class... U>
+using all_of = detail::all_of_imp<T<U>::value...>;
+
+template<std::size_t... Is> struct seq {};
+
+template<std::size_t N, std::size_t... Is>
+struct gen_seq : gen_seq<N-1, N-1, Is...> {};
+
+template<std::size_t... Is>
+struct gen_seq<0, Is...> : seq<Is...> {};
+
+/// @cond
+} // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+} // namespace msgpack
+
+#endif // !defined(MSGPACK_USE_CPP03)
+
+#endif // MSGPACK_META_HPP

include/msgpack/object.hpp

@@ -29,6 +29,7 @@
 #include <limits>
 #include <ostream>
 #include <typeinfo>
+#include <iomanip>
 
 namespace msgpack {
 
@@ -36,6 +37,117 @@ namespace msgpack {
 MSGPACK_API_VERSION_NAMESPACE(v1) {
 /// @endcond
 
+class object_handle {
+public:
+    object_handle() {}
+
+    object_handle(msgpack::object const& obj, msgpack::unique_ptr<msgpack::zone> z) :
+        m_obj(obj), m_zone(msgpack::move(z)) { }
+
+    // obsolete
+    void set(msgpack::object const& obj)
+        { m_obj = obj; }
+
+    const msgpack::object& get() const
+        { return m_obj; }
+
+    msgpack::unique_ptr<msgpack::zone>& zone()
+        { return m_zone; }
+
+    const msgpack::unique_ptr<msgpack::zone>& zone() const
+        { return m_zone; }
+
+#if defined(MSGPACK_USE_CPP03)
+    struct object_handle_ref {
+        object_handle_ref(object_handle* oh):m_oh(oh) {}
+        object_handle* m_oh;
+    };
+
+    object_handle(object_handle& other):
+        m_obj(other.m_obj),
+        m_zone(msgpack::move(other.m_zone)) {
+    }
+
+    object_handle(object_handle_ref ref):
+        m_obj(ref.m_oh->m_obj),
+        m_zone(msgpack::move(ref.m_oh->m_zone)) {
+    }
+
+    object_handle& operator=(object_handle& other) {
+        m_obj = other.m_obj;
+        m_zone = msgpack::move(other.m_zone);
+        return *this;
+    }
+
+    object_handle& operator=(object_handle_ref ref) {
+        m_obj = ref.m_oh->m_obj;
+        m_zone = msgpack::move(ref.m_oh->m_zone);
+        return *this;
+    }
+
+    operator object_handle_ref() {
+        return object_handle_ref(this);
+    }
+#endif // defined(MSGPACK_USE_CPP03)
+
+private:
+    msgpack::object m_obj;
+    msgpack::unique_ptr<msgpack::zone> m_zone;
+};
+
+namespace detail {
+
+template <std::size_t N>
+inline std::size_t add_ext_type_size(std::size_t size) {
+    return size + 1;
+}
+
+template <>
+inline std::size_t add_ext_type_size<4>(std::size_t size) {
+    return size == 0xffffffff ? size : size + 1;
+}
+
+} // namespace detail
+
+inline std::size_t aligned_zone_size(msgpack::object const& obj) {
+    std::size_t s = 0;
+    switch (obj.type) {
+    case msgpack::type::ARRAY:
+        s += sizeof(msgpack::object) * obj.via.array.size;
+        for (uint32_t i = 0; i < obj.via.array.size; ++i) {
+            s += msgpack::aligned_zone_size(obj.via.array.ptr[i]);
+        }
+        break;
+    case msgpack::type::MAP:
+        s += sizeof(msgpack::object_kv) * obj.via.map.size;
+        for (uint32_t i = 0; i < obj.via.map.size; ++i) {
+            s += msgpack::aligned_zone_size(obj.via.map.ptr[i].key);
+            s += msgpack::aligned_zone_size(obj.via.map.ptr[i].val);
+        }
+        break;
+    case msgpack::type::EXT:
+        s += msgpack::aligned_size(
+            detail::add_ext_type_size<sizeof(std::size_t)>(obj.via.ext.size));
+        break;
+    case msgpack::type::STR:
+        s += msgpack::aligned_size(obj.via.str.size);
+        break;
+    case msgpack::type::BIN:
+        s += msgpack::aligned_size(obj.via.bin.size);
+        break;
+    default:
+        break;
+    }
+    return s;
+}
+
+inline object_handle clone(msgpack::object const& obj) {
+    std::size_t size = msgpack::aligned_zone_size(obj);
+    msgpack::unique_ptr<msgpack::zone> z(size == 0 ? nullptr : new msgpack::zone(size));
+    msgpack::object newobj = z.get() ? msgpack::object(obj, *z) : obj;
+    return object_handle(newobj, msgpack::move(z));
+}
+
 struct object::implicit_type {
     implicit_type(object const& o) : obj(o) { }
     ~implicit_type() { }
@@ -58,26 +170,26 @@ struct packer_serializer {
 } // namespace detail
 
 // Adaptor functors' member functions definitions.
-template <typename T>
+template <typename T, typename Enabler>
 inline
 msgpack::object const&
-msgpack::adaptor::convert<T>::operator()(msgpack::object const& o, T& v) const {
+msgpack::adaptor::convert<T, Enabler>::operator()(msgpack::object const& o, T& v) const {
     v.msgpack_unpack(o.convert());
     return o;
 }
 
-template <typename T>
+template <typename T, typename Enabler>
 template <typename Stream>
 inline
 msgpack::packer<Stream>&
-msgpack::adaptor::pack<T>::operator()(msgpack::packer<Stream>& o, T const& v) const {
-    return detail::packer_serializer<Stream, T>::pack(o, v);
+msgpack::adaptor::pack<T, Enabler>::operator()(msgpack::packer<Stream>& o, T const& v) const {
+    return msgpack::detail::packer_serializer<Stream, T>::pack(o, v);
 }
 
-template <typename T>
+template <typename T, typename Enabler>
 inline
 void
-msgpack::adaptor::object_with_zone<T>::operator()(msgpack::object::with_zone& o, T const& v) const {
+msgpack::adaptor::object_with_zone<T, Enabler>::operator()(msgpack::object::with_zone& o, T const& v) const {
     v.msgpack_object(static_cast<msgpack::object*>(&o), o.zone);
 }
 
@@ -368,7 +480,7 @@ inline bool operator!=(const msgpack::object& x, const msgpack::object& y)
 { return !(x == y); }
 
 template <typename T>
-inline bool operator==(const T& y, const msgpack::object x)
+inline bool operator==(const T& y, const msgpack::object& x)
 { return x == y; }
 
 template <typename T>
@@ -386,17 +498,31 @@ inline msgpack::object::implicit_type object::convert() const
 }
 
 template <typename T>
-inline void object::convert(T& v) const
+inline T& object::convert(T& v) const
 {
     msgpack::operator>>(*this, v);
+    return v;
 }
 
 template <typename T>
-inline void object::convert(T* v) const
+inline T* object::convert(T* v) const
 {
     convert(*v);
+    return v;
 }
 
+template <typename T>
+inline bool object::convert_if_not_nil(T& v) const
+{
+    if (is_nil()) {
+        return false;
+    }
+    convert(v);
+    return true;
+}
+
+#if defined(MSGPACK_USE_CPP03)
+
 template <typename T>
 inline T object::as() const
 {
@@ -405,6 +531,21 @@ inline T object::as() const
     return v;
 }
 
+#else  // defined(MSGPACK_USE_CPP03)
+
+template <typename T>
+inline typename std::enable_if<msgpack::has_as<T>::value, T>::type object::as() const {
+    return msgpack::adaptor::as<T>()(*this);
+}
+
+template <typename T>
+inline typename std::enable_if<!msgpack::has_as<T>::value, T>::type object::as() const {
+    T v;
+    convert(v);
+    return v;
+}
+
+#endif // defined(MSGPACK_USE_CPP03)
 
 inline object::object()
 {
@@ -583,7 +724,46 @@ inline std::ostream& operator<< (std::ostream& s, const msgpack::object& o)
         break;
 
     case msgpack::type::STR:
-        (s << '"').write(o.via.str.ptr, o.via.str.size) << '"';
+        s << '"';
+        for (uint32_t i = 0; i < o.via.str.size; ++i) {
+            char c = o.via.str.ptr[i];
+            switch (c) {
+            case '\\':
+                s << "\\\\";
+                break;
+            case '"':
+                s << "\\\"";
+                break;
+            case '/':
+                s << "\\/";
+                break;
+            case '\b':
+                s << "\\b";
+                break;
+            case '\f':
+                s << "\\f";
+                break;
+            case '\n':
+                s << "\\n";
+                break;
+            case '\r':
+                s << "\\r";
+                break;
+            case '\t':
+                s << "\\t";
+                break;
+            default: {
+                unsigned int code = static_cast<unsigned int>(c);
+                if (code < 0x20 || code == 0x7f) {
+                    s << "\\u" << std::hex << std::setw(4) << std::setfill('0') << (code & 0xff);
+                }
+                else {
+                    s << c;
+                }
+            } break;
+            }
+        }
+        s << '"';
         break;
 
     case msgpack::type::BIN:
@@ -612,11 +792,11 @@ inline std::ostream& operator<< (std::ostream& s, const msgpack::object& o)
         s << "{";
         if(o.via.map.size != 0) {
             msgpack::object_kv* p(o.via.map.ptr);
-            s << p->key << "=>" << p->val;
+            s << p->key << ':' << p->val;
             ++p;
             for(msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
                     p < pend; ++p) {
-                s << ", " << p->key << "=>" << p->val;
+                s << ", " << p->key << ':' << p->val;
             }
         }
         s << "}";

include/msgpack/object_fwd.hpp

@@ -81,6 +81,33 @@ struct object_ext {
     const char* ptr;
 };
 
+
+#if !defined(MSGPACK_USE_CPP03)
+struct object;
+
+namespace adaptor {
+template <typename T, typename Enabler = void>
+struct as;
+} // namespace adaptor
+
+template <typename T>
+struct has_as {
+private:
+    template <typename U>
+    static auto check(U*) ->
+        typename std::is_same<
+            decltype(msgpack::adaptor::as<U>()(std::declval<msgpack::object>())),
+            T>::type;
+    template <typename>
+    static std::false_type check(...);
+public:
+    using type = decltype(check<T>(nullptr));
+    static constexpr bool value = type::value;
+};
+
+#endif // !defined(MSGPACK_USE_CPP03)
+
+
 struct object {
     union union_type {
         bool boolean;
@@ -102,13 +129,28 @@ struct object {
 
     bool is_nil() const { return type == msgpack::type::NIL; }
 
+#if defined(MSGPACK_USE_CPP03)
+
     template <typename T>
     T as() const;
 
+#else  // defined(MSGPACK_USE_CPP03)
+
     template <typename T>
-    void convert(T& v) const;
+    typename std::enable_if<msgpack::has_as<T>::value, T>::type as() const;
+
     template <typename T>
-    void convert(T* v) const;
+    typename std::enable_if<!msgpack::has_as<T>::value, T>::type as() const;
+
+#endif // defined(MSGPACK_USE_CPP03)
+
+    template <typename T>
+    T& convert(T& v) const;
+    template <typename T>
+    T* convert(T* v) const;
+
+    template <typename T>
+    bool convert_if_not_nil(T& v) const;
 
     object();
 

include/msgpack/pack.h

@@ -97,6 +97,9 @@ static int msgpack_pack_map(msgpack_packer* pk, size_t n);
 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_v4raw(msgpack_packer* pk, size_t l);
+static int msgpack_pack_v4raw_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);
 
@@ -150,4 +153,3 @@ inline void msgpack_packer_free(msgpack_packer* pk)
 #endif
 
 #endif /* msgpack/pack.h */
-

include/msgpack/pack.hpp

@@ -88,6 +88,10 @@ public:
     packer<Stream>& pack_str(uint32_t l);
     packer<Stream>& pack_str_body(const char* b, uint32_t l);
 
+    // v4
+    packer<Stream>& pack_v4raw(uint32_t l);
+    packer<Stream>& pack_v4raw_body(const char* b, uint32_t l);
+
     packer<Stream>& pack_bin(uint32_t l);
     packer<Stream>& pack_bin_body(const char* b, uint32_t l);
 
@@ -145,7 +149,7 @@ inline void pack(Stream& s, const T& v)
 }
 
 
-#if defined(__LITTLE_ENDIAN__)
+#if MSGPACK_ENDIAN_LITTLE_BYTE
 template <typename T>
 inline char take8_8(T d) {
     return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[0]);
@@ -163,7 +167,7 @@ inline char take8_64(T d) {
     return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[0]);
 }
 
-#elif defined(__BIG_ENDIAN__)
+#elif MSGPACK_ENDIAN_BIG_BYTE
 
 template <typename T>
 inline char take8_8(T d) {
@@ -182,6 +186,8 @@ inline char take8_64(T d) {
     return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[7]);
 }
 
+#else
+#error msgpack-c supports only big endian and little endian
 #endif
 
 template <typename Stream>
@@ -608,7 +614,10 @@ inline packer<Stream>& packer<Stream>::pack_double(double d)
     mem.f = d;
     char buf[9];
     buf[0] = static_cast<char>(0xcbu);
-#if defined(__arm__) && !(__ARM_EABI__) // arm-oabi
+
+#if defined(TARGET_OS_IPHONE)
+    // ok
+#elif defined(__arm__) && !(__ARM_EABI__) // arm-oabi
     // https://github.com/msgpack/msgpack-perl/pull/1
     mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL);
 #endif
@@ -684,7 +693,7 @@ template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_str(uint32_t l)
 {
     if(l < 32) {
-        unsigned char d = 0xa0u | static_cast<uint8_t>(l);
+        unsigned char d = static_cast<uint8_t>(0xa0u | l);
         char buf = take8_8(d);
         append_buffer(&buf, 1);
     } else if(l < 256) {
@@ -710,6 +719,34 @@ inline packer<Stream>& packer<Stream>::pack_str_body(const char* b, uint32_t l)
     return *this;
 }
 
+// Raw (V4)
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_v4raw(uint32_t l)
+{
+    if(l < 32) {
+        unsigned char d = static_cast<uint8_t>(0xa0u | l);
+        char buf = take8_8(d);
+        append_buffer(&buf, 1);
+    } else if(l < 65536) {
+        char buf[3];
+        buf[0] = static_cast<char>(0xdau); _msgpack_store16(&buf[1], static_cast<uint16_t>(l));
+        append_buffer(buf, 3);
+    } else {
+        char buf[5];
+        buf[0] = static_cast<char>(0xdbu); _msgpack_store32(&buf[1], static_cast<uint32_t>(l));
+        append_buffer(buf, 5);
+    }
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_v4raw_body(const char* b, uint32_t l)
+{
+    append_buffer(b, l);
+    return *this;
+}
+
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_bin(uint32_t l)
 {

include/msgpack/pack_template.h

@@ -16,16 +16,18 @@
  *    limitations under the License.
  */
 
-#if defined(__LITTLE_ENDIAN__)
+#if MSGPACK_ENDIAN_LITTLE_BYTE
 #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__)
+#elif MSGPACK_ENDIAN_BIG_BYTE
 #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]
+#else
+#error msgpack-c supports only big endian and little endian
 #endif
 
 #ifndef msgpack_pack_inline_func
@@ -669,7 +671,9 @@ msgpack_pack_inline_func(_double)(msgpack_pack_user x, double d)
     union { double f; uint64_t i; } mem;
     mem.f = d;
     buf[0] = 0xcb;
-#if defined(__arm__) && !(__ARM_EABI__) // arm-oabi
+#if defined(TARGET_OS_IPHONE)
+    // ok
+#elif defined(__arm__) && !(__ARM_EABI__) // arm-oabi
     // https://github.com/msgpack/msgpack-perl/pull/1
     mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL);
 #endif
@@ -777,6 +781,31 @@ 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);
 }
 
+/*
+ * Raw (V4)
+ */
+
+msgpack_pack_inline_func(_v4raw)(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(_v4raw_body)(msgpack_pack_user x, const void* b, size_t l)
+{
+    msgpack_pack_append_buffer(x, (const unsigned char*)b, l);
+}
+
 /*
  * Bin
  */
@@ -886,4 +915,3 @@ msgpack_pack_inline_func(_ext_body)(msgpack_pack_user x, const void* b, size_t l
 #undef msgpack_pack_real_int16
 #undef msgpack_pack_real_int32
 #undef msgpack_pack_real_int64
-

include/msgpack/predef.h

@@ -0,0 +1,19 @@
+/*
+Copyright Rene Rivera 2008-2013
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef MSGPACK_PREDEF_H
+#define MSGPACK_PREDEF_H
+
+#include <msgpack/predef/language.h>
+#include <msgpack/predef/architecture.h>
+#include <msgpack/predef/compiler.h>
+#include <msgpack/predef/library.h>
+#include <msgpack/predef/os.h>
+#include <msgpack/predef/other.h>
+#include <msgpack/predef/platform.h>
+
+#endif

include/msgpack/predef/architecture.h

@@ -0,0 +1,30 @@
+/*
+Copyright Rene Rivera 2008-2013
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef MSGPACK_PREDEF_ARCHITECTURE_H
+#define MSGPACK_PREDEF_ARCHITECTURE_H
+
+#include <msgpack/predef/architecture/alpha.h>
+#include <msgpack/predef/architecture/arm.h>
+#include <msgpack/predef/architecture/blackfin.h>
+#include <msgpack/predef/architecture/convex.h>
+#include <msgpack/predef/architecture/ia64.h>
+#include <msgpack/predef/architecture/m68k.h>
+#include <msgpack/predef/architecture/mips.h>
+#include <msgpack/predef/architecture/parisc.h>
+#include <msgpack/predef/architecture/ppc.h>
+#include <msgpack/predef/architecture/pyramid.h>
+#include <msgpack/predef/architecture/rs6k.h>
+#include <msgpack/predef/architecture/sparc.h>
+#include <msgpack/predef/architecture/superh.h>
+#include <msgpack/predef/architecture/sys370.h>
+#include <msgpack/predef/architecture/sys390.h>
+#include <msgpack/predef/architecture/x86.h>
+#include <msgpack/predef/architecture/z.h>
+/*#include <msgpack/predef/architecture/.h>*/
+
+#endif

include/msgpack/predef/architecture/alpha.h

@@ -0,0 +1,60 @@
+/*
+Copyright Rene Rivera 2008-2013
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef MSGPACK_PREDEF_ARCHITECTURE_ALPHA_H
+#define MSGPACK_PREDEF_ARCHITECTURE_ALPHA_H
+
+#include <msgpack/predef/version_number.h>
+#include <msgpack/predef/make.h>
+
+/*`
+[heading `MSGPACK_ARCH_ALPHA`]
+
+[@http://en.wikipedia.org/wiki/DEC_Alpha DEC Alpha] architecture.
+
+[table
+    [[__predef_symbol__] [__predef_version__]]
+    [[`__alpha__`] [__predef_detection__]]
+    [[`__alpha`] [__predef_detection__]]
+    [[`_M_ALPHA`] [__predef_detection__]]
+
+    [[`__alpha_ev4__`] [4.0.0]]
+    [[`__alpha_ev5__`] [5.0.0]]
+    [[`__alpha_ev6__`] [6.0.0]]
+    ]
+ */
+
+#define MSGPACK_ARCH_ALPHA MSGPACK_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__alpha__) || defined(__alpha) || \
+    defined(_M_ALPHA)
+#   undef MSGPACK_ARCH_ALPHA
+#   if !defined(MSGPACK_ARCH_ALPHA) && defined(__alpha_ev4__)
+#       define MSGPACK_ARCH_ALPHA MSGPACK_VERSION_NUMBER(4,0,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_ALPHA) && defined(__alpha_ev5__)
+#       define MSGPACK_ARCH_ALPHA MSGPACK_VERSION_NUMBER(5,0,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_ALPHA) && defined(__alpha_ev6__)
+#       define MSGPACK_ARCH_ALPHA MSGPACK_VERSION_NUMBER(6,0,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_ALPHA)
+#       define MSGPACK_ARCH_ALPHA MSGPACK_VERSION_NUMBER_AVAILABLE
+#   endif
+#endif
+
+#if MSGPACK_ARCH_ALPHA
+#   define MSGPACK_ARCH_ALPHA_AVAILABLE
+#endif
+
+#define MSGPACK_ARCH_ALPHA_NAME "DEC Alpha"
+
+#include <msgpack/predef/detail/test.h>
+MSGPACK_PREDEF_DECLARE_TEST(MSGPACK_ARCH_ALPHA,MSGPACK_ARCH_ALPHA_NAME)
+
+
+#endif

include/msgpack/predef/architecture/arm.h

@@ -0,0 +1,71 @@
+/*
+Copyright Rene Rivera 2008-2013
+Copyright Franz Detro 2014
+Copyright (c) Microsoft Corporation 2014
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef MSGPACK_PREDEF_ARCHITECTURE_ARM_H
+#define MSGPACK_PREDEF_ARCHITECTURE_ARM_H
+
+#include <msgpack/predef/version_number.h>
+#include <msgpack/predef/make.h>
+
+/*`
+[heading `MSGPACK_ARCH_ARM`]
+
+[@http://en.wikipedia.org/wiki/ARM_architecture ARM] architecture.
+
+[table
+    [[__predef_symbol__] [__predef_version__]]
+
+    [[`__arm__`] [__predef_detection__]]
+    [[`__arm64`] [__predef_detection__]]
+    [[`__thumb__`] [__predef_detection__]]
+    [[`__TARGET_ARCH_ARM`] [__predef_detection__]]
+    [[`__TARGET_ARCH_THUMB`] [__predef_detection__]]
+    [[`_M_ARM`] [__predef_detection__]]
+
+    [[`__arm64`] [8.0.0]]
+    [[`__TARGET_ARCH_ARM`] [V.0.0]]
+    [[`__TARGET_ARCH_THUMB`] [V.0.0]]
+    [[`_M_ARM`] [V.0.0]]
+    ]
+ */
+
+#define MSGPACK_ARCH_ARM MSGPACK_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__arm__) || defined(__arm64) || defined(__thumb__) || \
+    defined(__TARGET_ARCH_ARM) || defined(__TARGET_ARCH_THUMB) || \
+    defined(_M_ARM)
+#   undef MSGPACK_ARCH_ARM
+#   if !defined(MSGPACK_ARCH_ARM) && defined(__arm64)
+#       define MSGPACK_ARCH_ARM MSGPACK_VERSION_NUMBER(8,0,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_ARM) && defined(__TARGET_ARCH_ARM)
+#       define MSGPACK_ARCH_ARM MSGPACK_VERSION_NUMBER(__TARGET_ARCH_ARM,0,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_ARM) && defined(__TARGET_ARCH_THUMB)
+#       define MSGPACK_ARCH_ARM MSGPACK_VERSION_NUMBER(__TARGET_ARCH_THUMB,0,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_ARM) && defined(_M_ARM)
+#       define MSGPACK_ARCH_ARM MSGPACK_VERSION_NUMBER(_M_ARM,0,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_ARM)
+#       define MSGPACK_ARCH_ARM MSGPACK_VERSION_NUMBER_AVAILABLE
+#   endif
+#endif
+
+#if MSGPACK_ARCH_ARM
+#   define MSGPACK_ARCH_ARM_AVAILABLE
+#endif
+
+#define MSGPACK_ARCH_ARM_NAME "ARM"
+
+#include <msgpack/predef/detail/test.h>
+MSGPACK_PREDEF_DECLARE_TEST(MSGPACK_ARCH_ARM,MSGPACK_ARCH_ARM_NAME)
+
+
+#endif

include/msgpack/predef/architecture/blackfin.h

@@ -0,0 +1,47 @@
+/*
+Copyright Rene Rivera 2013
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef MSGPACK_PREDEF_ARCHITECTURE_BLACKFIN_H
+#define MSGPACK_PREDEF_ARCHITECTURE_BLACKFIN_H
+
+#include <msgpack/predef/version_number.h>
+#include <msgpack/predef/make.h>
+
+/*`
+[heading `MSGPACK_ARCH_BLACKFIN`]
+
+Blackfin Processors from Analog Devices.
+
+[table
+    [[__predef_symbol__] [__predef_version__]]
+
+    [[`__bfin__`] [__predef_detection__]]
+    [[`__BFIN__`] [__predef_detection__]]
+    [[`bfin`] [__predef_detection__]]
+    [[`BFIN`] [__predef_detection__]]
+    ]
+ */
+
+#define MSGPACK_ARCH_BLACKFIN MSGPACK_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__bfin__) || defined(__BFIN__) || \
+    defined(bfin) || defined(BFIN)
+#   undef MSGPACK_ARCH_BLACKFIN
+#   define MSGPACK_ARCH_BLACKFIN MSGPACK_VERSION_NUMBER_AVAILABLE
+#endif
+
+#if MSGPACK_ARCH_BLACKFIN
+#   define MSGPACK_ARCH_BLACKFIN_AVAILABLE
+#endif
+
+#define MSGPACK_ARCH_BLACKFIN_NAME "Blackfin"
+
+#include <msgpack/predef/detail/test.h>
+MSGPACK_PREDEF_DECLARE_TEST(MSGPACK_ARCH_BLACKFIN,MSGPACK_ARCH_BLACKFIN_NAME)
+
+
+#endif

include/msgpack/predef/architecture/convex.h

@@ -0,0 +1,67 @@
+/*
+Copyright Rene Rivera 2011-2013
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef MSGPACK_PREDEF_ARCHITECTURE_CONVEX_H
+#define MSGPACK_PREDEF_ARCHITECTURE_CONVEX_H
+
+#include <msgpack/predef/version_number.h>
+#include <msgpack/predef/make.h>
+
+/*`
+[heading `MSGPACK_ARCH_CONVEX`]
+
+[@http://en.wikipedia.org/wiki/Convex_Computer Convex Computer] architecture.
+
+[table
+    [[__predef_symbol__] [__predef_version__]]
+
+    [[`__convex__`] [__predef_detection__]]
+
+    [[`__convex_c1__`] [1.0.0]]
+    [[`__convex_c2__`] [2.0.0]]
+    [[`__convex_c32__`] [3.2.0]]
+    [[`__convex_c34__`] [3.4.0]]
+    [[`__convex_c38__`] [3.8.0]]
+    ]
+ */
+
+#define MSGPACK_ARCH_CONVEX MSGPACK_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__convex__)
+#   undef MSGPACK_ARCH_CONVEX
+#   if !defined(MSGPACK_ARCH_CONVEX) && defined(__convex_c1__)
+#       define MSGPACK_ARCH_CONVEX MSGPACK_VERSION_NUMBER(1,0,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_CONVEX) && defined(__convex_c2__)
+#       define MSGPACK_ARCH_CONVEX MSGPACK_VERSION_NUMBER(2,0,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_CONVEX) && defined(__convex_c32__)
+#       define MSGPACK_ARCH_CONVEX MSGPACK_VERSION_NUMBER(3,2,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_CONVEX) && defined(__convex_c34__)
+#       define MSGPACK_ARCH_CONVEX MSGPACK_VERSION_NUMBER(3,4,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_CONVEX) && defined(__convex_c38__)
+#       define MSGPACK_ARCH_CONVEX MSGPACK_VERSION_NUMBER(3,8,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_CONVEX)
+#       define MSGPACK_ARCH_CONVEX MSGPACK_VERSION_NUMBER_AVAILABLE
+#   endif
+#endif
+
+#if MSGPACK_ARCH_CONVEX
+#   define MSGPACK_ARCH_CONVEX_AVAILABLE
+#endif
+
+#define MSGPACK_ARCH_CONVEX_NAME "Convex Computer"
+
+#include <msgpack/predef/detail/test.h>
+MSGPACK_PREDEF_DECLARE_TEST(MSGPACK_ARCH_CONVEX,MSGPACK_ARCH_CONVEX_NAME)
+
+
+
+#endif

include/msgpack/predef/architecture/ia64.h

@@ -0,0 +1,49 @@
+/*
+Copyright Rene Rivera 2008-2013
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef MSGPACK_PREDEF_ARCHITECTURE_IA64_H
+#define MSGPACK_PREDEF_ARCHITECTURE_IA64_H
+
+#include <msgpack/predef/version_number.h>
+#include <msgpack/predef/make.h>
+
+/*`
+[heading `MSGPACK_ARCH_IA64`]
+
+[@http://en.wikipedia.org/wiki/Ia64 Intel Itanium 64] architecture.
+
+[table
+    [[__predef_symbol__] [__predef_version__]]
+
+    [[`__ia64__`] [__predef_detection__]]
+    [[`_IA64`] [__predef_detection__]]
+    [[`__IA64__`] [__predef_detection__]]
+    [[`__ia64`] [__predef_detection__]]
+    [[`_M_IA64`] [__predef_detection__]]
+    [[`__itanium__`] [__predef_detection__]]
+    ]
+ */
+
+#define MSGPACK_ARCH_IA64 MSGPACK_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__ia64__) || defined(_IA64) || \
+    defined(__IA64__) || defined(__ia64) || \
+    defined(_M_IA64) || defined(__itanium__)
+#   undef MSGPACK_ARCH_IA64
+#   define MSGPACK_ARCH_IA64 MSGPACK_VERSION_NUMBER_AVAILABLE
+#endif
+
+#if MSGPACK_ARCH_IA64
+#   define MSGPACK_ARCH_IA64_AVAILABLE
+#endif
+
+#define MSGPACK_ARCH_IA64_NAME "Intel Itanium 64"
+
+#include <msgpack/predef/detail/test.h>
+MSGPACK_PREDEF_DECLARE_TEST(MSGPACK_ARCH_IA64,MSGPACK_ARCH_IA64_NAME)
+
+#endif

include/msgpack/predef/architecture/m68k.h

@@ -0,0 +1,83 @@
+/*
+Copyright Rene Rivera 2008-2013
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef MSGPACK_PREDEF_ARCHITECTURE_M68K_H
+#define MSGPACK_PREDEF_ARCHITECTURE_M68K_H
+
+#include <msgpack/predef/version_number.h>
+#include <msgpack/predef/make.h>
+
+/*`
+[heading `MSGPACK_ARCH_M68K`]
+
+[@http://en.wikipedia.org/wiki/M68k Motorola 68k] architecture.
+
+[table
+    [[__predef_symbol__] [__predef_version__]]
+
+    [[`__m68k__`] [__predef_detection__]]
+    [[`M68000`] [__predef_detection__]]
+
+    [[`__mc68060__`] [6.0.0]]
+    [[`mc68060`] [6.0.0]]
+    [[`__mc68060`] [6.0.0]]
+    [[`__mc68040__`] [4.0.0]]
+    [[`mc68040`] [4.0.0]]
+    [[`__mc68040`] [4.0.0]]
+    [[`__mc68030__`] [3.0.0]]
+    [[`mc68030`] [3.0.0]]
+    [[`__mc68030`] [3.0.0]]
+    [[`__mc68020__`] [2.0.0]]
+    [[`mc68020`] [2.0.0]]
+    [[`__mc68020`] [2.0.0]]
+    [[`__mc68010__`] [1.0.0]]
+    [[`mc68010`] [1.0.0]]
+    [[`__mc68010`] [1.0.0]]
+    [[`__mc68000__`] [0.0.1]]
+    [[`mc68000`] [0.0.1]]
+    [[`__mc68000`] [0.0.1]]
+    ]
+ */
+
+#define MSGPACK_ARCH_M68K MSGPACK_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__m68k__) || defined(M68000)
+#   undef MSGPACK_ARCH_M68K
+#   if !defined(MSGPACK_ARCH_M68K) && (defined(__mc68060__) || defined(mc68060) || defined(__mc68060))
+#       define MSGPACK_ARCH_M68K MSGPACK_VERSION_NUMBER(6,0,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_M68K) && (defined(__mc68040__) || defined(mc68040) || defined(__mc68040))
+#       define MSGPACK_ARCH_M68K MSGPACK_VERSION_NUMBER(4,0,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_M68K) && (defined(__mc68030__) || defined(mc68030) || defined(__mc68030))
+#       define MSGPACK_ARCH_M68K MSGPACK_VERSION_NUMBER(3,0,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_M68K) && (defined(__mc68020__) || defined(mc68020) || defined(__mc68020))
+#       define MSGPACK_ARCH_M68K MSGPACK_VERSION_NUMBER(2,0,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_M68K) && (defined(__mc68010__) || defined(mc68010) || defined(__mc68010))
+#       define MSGPACK_ARCH_M68K MSGPACK_VERSION_NUMBER(1,0,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_M68K) && (defined(__mc68000__) || defined(mc68000) || defined(__mc68000))
+#       define MSGPACK_ARCH_M68K MSGPACK_VERSION_NUMBER_AVAILABLE
+#   endif
+#   if !defined(MSGPACK_ARCH_M68K)
+#       define MSGPACK_ARCH_M68K MSGPACK_VERSION_NUMBER_AVAILABLE
+#   endif
+#endif
+
+#if MSGPACK_ARCH_M68K
+#   define MSGPACK_ARCH_M68K_AVAILABLE
+#endif
+
+#define MSGPACK_ARCH_M68K_NAME "Motorola 68k"
+
+#include <msgpack/predef/detail/test.h>
+MSGPACK_PREDEF_DECLARE_TEST(MSGPACK_ARCH_M68K,MSGPACK_ARCH_M68K_NAME)
+
+
+#endif

include/msgpack/predef/architecture/mips.h

@@ -0,0 +1,74 @@
+/*
+Copyright Rene Rivera 2008-2013
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef MSGPACK_PREDEF_ARCHITECTURE_MIPS_H
+#define MSGPACK_PREDEF_ARCHITECTURE_MIPS_H
+
+#include <msgpack/predef/version_number.h>
+#include <msgpack/predef/make.h>
+
+/*`
+[heading `MSGPACK_ARCH_MIPS`]
+
+[@http://en.wikipedia.org/wiki/MIPS_architecture MIPS] architecture.
+
+[table
+    [[__predef_symbol__] [__predef_version__]]
+
+    [[`__mips__`] [__predef_detection__]]
+    [[`__mips`] [__predef_detection__]]
+    [[`__MIPS__`] [__predef_detection__]]
+
+    [[`__mips`] [V.0.0]]
+    [[`_MIPS_ISA_MIPS1`] [1.0.0]]
+    [[`_R3000`] [1.0.0]]
+    [[`_MIPS_ISA_MIPS2`] [2.0.0]]
+    [[`__MIPS_ISA2__`] [2.0.0]]
+    [[`_R4000`] [2.0.0]]
+    [[`_MIPS_ISA_MIPS3`] [3.0.0]]
+    [[`__MIPS_ISA3__`] [3.0.0]]
+    [[`_MIPS_ISA_MIPS4`] [4.0.0]]
+    [[`__MIPS_ISA4__`] [4.0.0]]
+    ]
+ */
+
+#define MSGPACK_ARCH_MIPS MSGPACK_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__mips__) || defined(__mips) || \
+    defined(__MIPS__)
+#   undef MSGPACK_ARCH_MIPS
+#   if !defined(MSGPACK_ARCH_MIPS) && (defined(__mips))
+#       define MSGPACK_ARCH_MIPS MSGPACK_VERSION_NUMBER(__mips,0,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_MIPS) && (defined(_MIPS_ISA_MIPS1) || defined(_R3000))
+#       define MSGPACK_ARCH_MIPS MSGPACK_VERSION_NUMBER(1,0,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_MIPS) && (defined(_MIPS_ISA_MIPS2) || defined(__MIPS_ISA2__) || defined(_R4000))
+#       define MSGPACK_ARCH_MIPS MSGPACK_VERSION_NUMBER(2,0,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_MIPS) && (defined(_MIPS_ISA_MIPS3) || defined(__MIPS_ISA3__))
+#       define MSGPACK_ARCH_MIPS MSGPACK_VERSION_NUMBER(3,0,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_MIPS) && (defined(_MIPS_ISA_MIPS4) || defined(__MIPS_ISA4__))
+#       define MSGPACK_ARCH_MIPS MSGPACK_VERSION_NUMBER(4,0,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_MIPS)
+#       define MSGPACK_ARCH_MIPS MSGPACK_VERSION_NUMBER_AVAILABLE
+#   endif
+#endif
+
+#if MSGPACK_ARCH_MIPS
+#   define MSGPACK_ARCH_MIPS_AVAILABLE
+#endif
+
+#define MSGPACK_ARCH_MIPS_NAME "MIPS"
+
+#include <msgpack/predef/detail/test.h>
+MSGPACK_PREDEF_DECLARE_TEST(MSGPACK_ARCH_MIPS,MSGPACK_ARCH_MIPS_NAME)
+
+
+#endif

include/msgpack/predef/architecture/parisc.h

@@ -0,0 +1,65 @@
+/*
+Copyright Rene Rivera 2008-2013
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef MSGPACK_PREDEF_ARCHITECTURE_PARISC_H
+#define MSGPACK_PREDEF_ARCHITECTURE_PARISC_H
+
+#include <msgpack/predef/version_number.h>
+#include <msgpack/predef/make.h>
+
+/*`
+[heading `MSGPACK_ARCH_PARISK`]
+
+[@http://en.wikipedia.org/wiki/PA-RISC_family HP/PA RISC] architecture.
+
+[table
+    [[__predef_symbol__] [__predef_version__]]
+
+    [[`__hppa__`] [__predef_detection__]]
+    [[`__hppa`] [__predef_detection__]]
+    [[`__HPPA__`] [__predef_detection__]]
+
+    [[`_PA_RISC1_0`] [1.0.0]]
+    [[`_PA_RISC1_1`] [1.1.0]]
+    [[`__HPPA11__`] [1.1.0]]
+    [[`__PA7100__`] [1.1.0]]
+    [[`_PA_RISC2_0`] [2.0.0]]
+    [[`__RISC2_0__`] [2.0.0]]
+    [[`__HPPA20__`] [2.0.0]]
+    [[`__PA8000__`] [2.0.0]]
+    ]
+ */
+
+#define MSGPACK_ARCH_PARISC MSGPACK_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__hppa__) || defined(__hppa) || defined(__HPPA__)
+#   undef MSGPACK_ARCH_PARISC
+#   if !defined(MSGPACK_ARCH_PARISC) && (defined(_PA_RISC1_0))
+#       define MSGPACK_ARCH_PARISC MSGPACK_VERSION_NUMBER(1,0,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_PARISC) && (defined(_PA_RISC1_1) || defined(__HPPA11__) || defined(__PA7100__))
+#       define MSGPACK_ARCH_PARISC MSGPACK_VERSION_NUMBER(1,1,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_PARISC) && (defined(_PA_RISC2_0) || defined(__RISC2_0__) || defined(__HPPA20__) || defined(__PA8000__))
+#       define MSGPACK_ARCH_PARISC MSGPACK_VERSION_NUMBER(2,0,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_PARISC)
+#       define MSGPACK_ARCH_PARISC MSGPACK_VERSION_NUMBER_AVAILABLE
+#   endif
+#endif
+
+#if MSGPACK_ARCH_PARISC
+#   define MSGPACK_ARCH_PARISC_AVAILABLE
+#endif
+
+#define MSGPACK_ARCH_PARISC_NAME "HP/PA RISC"
+
+#include <msgpack/predef/detail/test.h>
+MSGPACK_PREDEF_DECLARE_TEST(MSGPACK_ARCH_PARISC,MSGPACK_ARCH_PARISC_NAME)
+
+
+#endif

include/msgpack/predef/architecture/ppc.h

@@ -0,0 +1,73 @@
+/*
+Copyright Rene Rivera 2008-2013
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef MSGPACK_PREDEF_ARCHITECTURE_PPC_H
+#define MSGPACK_PREDEF_ARCHITECTURE_PPC_H
+
+#include <msgpack/predef/version_number.h>
+#include <msgpack/predef/make.h>
+
+/*`
+[heading `MSGPACK_ARCH_PPC`]
+
+[@http://en.wikipedia.org/wiki/PowerPC PowerPC] architecture.
+
+[table
+    [[__predef_symbol__] [__predef_version__]]
+
+    [[`__powerpc`] [__predef_detection__]]
+    [[`__powerpc__`] [__predef_detection__]]
+    [[`__POWERPC__`] [__predef_detection__]]
+    [[`__ppc__`] [__predef_detection__]]
+    [[`_M_PPC`] [__predef_detection__]]
+    [[`_ARCH_PPC`] [__predef_detection__]]
+    [[`__PPCGECKO__`] [__predef_detection__]]
+    [[`__PPCBROADWAY__`] [__predef_detection__]]
+    [[`_XENON`] [__predef_detection__]]
+
+    [[`__ppc601__`] [6.1.0]]
+    [[`_ARCH_601`] [6.1.0]]
+    [[`__ppc603__`] [6.3.0]]
+    [[`_ARCH_603`] [6.3.0]]
+    [[`__ppc604__`] [6.4.0]]
+    [[`__ppc604__`] [6.4.0]]
+    ]
+ */
+
+#define MSGPACK_ARCH_PPC MSGPACK_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__powerpc) || defined(__powerpc__) || \
+    defined(__POWERPC__) || defined(__ppc__) || \
+    defined(_M_PPC) || defined(_ARCH_PPC) || \
+    defined(__PPCGECKO__) || defined(__PPCBROADWAY__) || \
+    defined(_XENON)
+#   undef MSGPACK_ARCH_PPC
+#   if !defined (MSGPACK_ARCH_PPC) && (defined(__ppc601__) || defined(_ARCH_601))
+#       define MSGPACK_ARCH_PPC MSGPACK_VERSION_NUMBER(6,1,0)
+#   endif
+#   if !defined (MSGPACK_ARCH_PPC) && (defined(__ppc603__) || defined(_ARCH_603))
+#       define MSGPACK_ARCH_PPC MSGPACK_VERSION_NUMBER(6,3,0)
+#   endif
+#   if !defined (MSGPACK_ARCH_PPC) && (defined(__ppc604__) || defined(__ppc604__))
+#       define MSGPACK_ARCH_PPC MSGPACK_VERSION_NUMBER(6,4,0)
+#   endif
+#   if !defined (MSGPACK_ARCH_PPC)
+#       define MSGPACK_ARCH_PPC MSGPACK_VERSION_NUMBER_AVAILABLE
+#   endif
+#endif
+
+#if MSGPACK_ARCH_PPC
+#   define MSGPACK_ARCH_PPC_AVAILABLE
+#endif
+
+#define MSGPACK_ARCH_PPC_NAME "PowerPC"
+
+#include <msgpack/predef/detail/test.h>
+MSGPACK_PREDEF_DECLARE_TEST(MSGPACK_ARCH_PPC,MSGPACK_ARCH_PPC_NAME)
+
+
+#endif

include/msgpack/predef/architecture/pyramid.h

@@ -0,0 +1,43 @@
+/*
+Copyright Rene Rivera 2011-2013
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef MSGPACK_PREDEF_ARCHITECTURE_PYRAMID_H
+#define MSGPACK_PREDEF_ARCHITECTURE_PYRAMID_H
+
+#include <msgpack/predef/version_number.h>
+#include <msgpack/predef/make.h>
+
+/*`
+[heading `MSGPACK_ARCH_PYRAMID`]
+
+Pyramid 9810 architecture.
+
+[table
+    [[__predef_symbol__] [__predef_version__]]
+
+    [[`pyr`] [__predef_detection__]]
+    ]
+ */
+
+#define MSGPACK_ARCH_PYRAMID MSGPACK_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(pyr)
+#   undef MSGPACK_ARCH_PYRAMID
+#   define MSGPACK_ARCH_PYRAMID MSGPACK_VERSION_NUMBER_AVAILABLE
+#endif
+
+#if MSGPACK_ARCH_PYRAMID
+#   define MSGPACK_ARCH_PYRAMID_AVAILABLE
+#endif
+
+#define MSGPACK_ARCH_PYRAMID_NAME "Pyramid 9810"
+
+#include <msgpack/predef/detail/test.h>
+MSGPACK_PREDEF_DECLARE_TEST(MSGPACK_ARCH_PYRAMID,MSGPACK_ARCH_PYRAMID_NAME)
+
+
+#endif

include/msgpack/predef/architecture/rs6k.h

@@ -0,0 +1,56 @@
+/*
+Copyright Rene Rivera 2008-2013
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef MSGPACK_PREDEF_ARCHITECTURE_RS6K_H
+#define MSGPACK_PREDEF_ARCHITECTURE_RS6K_H
+
+#include <msgpack/predef/version_number.h>
+#include <msgpack/predef/make.h>
+
+/*`
+[heading `MSGPACK_ARCH_RS6000`]
+
+[@http://en.wikipedia.org/wiki/RS/6000 RS/6000] architecture.
+
+[table
+    [[__predef_symbol__] [__predef_version__]]
+
+    [[`__THW_RS6000`] [__predef_detection__]]
+    [[`_IBMR2`] [__predef_detection__]]
+    [[`_POWER`] [__predef_detection__]]
+    [[`_ARCH_PWR`] [__predef_detection__]]
+    [[`_ARCH_PWR2`] [__predef_detection__]]
+    ]
+ */
+
+#define MSGPACK_ARCH_RS6000 MSGPACK_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__THW_RS6000) || defined(_IBMR2) || \
+    defined(_POWER) || defined(_ARCH_PWR) || \
+    defined(_ARCH_PWR2)
+#   undef MSGPACK_ARCH_RS6000
+#   define MSGPACK_ARCH_RS6000 MSGPACK_VERSION_NUMBER_AVAILABLE
+#endif
+
+#if MSGPACK_ARCH_RS6000
+#   define MSGPACK_ARCH_RS6000_AVAILABLE
+#endif
+
+#define MSGPACK_ARCH_RS6000_NAME "RS/6000"
+
+#include <msgpack/predef/detail/test.h>
+MSGPACK_PREDEF_DECLARE_TEST(MSGPACK_ARCH_RS6000,MSGPACK_ARCH_RS6000_NAME)
+
+#define MSGPACK_ARCH_PWR MSGPACK_ARCH_RS6000
+
+#if MSGPACK_ARCH_PWR
+#   define MSGPACK_ARCH_PWR_AVAILABLE
+#endif
+
+#define MSGPACK_ARCH_PWR_NAME MSGPACK_ARCH_RS6000_NAME
+
+#endif

include/msgpack/predef/architecture/sparc.h

@@ -0,0 +1,55 @@
+/*
+Copyright Rene Rivera 2008-2014
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef MSGPACK_PREDEF_ARCHITECTURE_SPARC_H
+#define MSGPACK_PREDEF_ARCHITECTURE_SPARC_H
+
+#include <msgpack/predef/version_number.h>
+#include <msgpack/predef/make.h>
+
+/*`
+[heading `MSGPACK_ARCH_SPARC`]
+
+[@http://en.wikipedia.org/wiki/SPARC SPARC] architecture.
+
+[table
+    [[__predef_symbol__] [__predef_version__]]
+
+    [[`__sparc__`] [__predef_detection__]]
+    [[`__sparc`] [__predef_detection__]]
+
+    [[`__sparcv9`] [9.0.0]]
+    [[`__sparcv8`] [8.0.0]]
+    ]
+ */
+
+#define MSGPACK_ARCH_SPARC MSGPACK_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__sparc__) || defined(__sparc)
+#   undef MSGPACK_ARCH_SPARC
+#   if !defined(MSGPACK_ARCH_SPARC) && defined(__sparcv9)
+#       define MSGPACK_ARCH_SPARC MSGPACK_VERSION_NUMBER(9,0,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_SPARC) && defined(__sparcv8)
+#       define MSGPACK_ARCH_SPARC MSGPACK_VERSION_NUMBER(8,0,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_SPARC)
+#       define MSGPACK_ARCH_SPARC MSGPACK_VERSION_NUMBER_AVAILABLE
+#   endif
+#endif
+
+#if MSGPACK_ARCH_SPARC
+#   define MSGPACK_ARCH_SPARC_AVAILABLE
+#endif
+
+#define MSGPACK_ARCH_SPARC_NAME "SPARC"
+
+#include <msgpack/predef/detail/test.h>
+MSGPACK_PREDEF_DECLARE_TEST(MSGPACK_ARCH_SPARC,MSGPACK_ARCH_SPARC_NAME)
+
+
+#endif

include/msgpack/predef/architecture/superh.h

@@ -0,0 +1,68 @@
+/*
+Copyright Rene Rivera 2008-2013
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef MSGPACK_PREDEF_ARCHITECTURE_SUPERH_H
+#define MSGPACK_PREDEF_ARCHITECTURE_SUPERH_H
+
+#include <msgpack/predef/version_number.h>
+#include <msgpack/predef/make.h>
+
+/*`
+[heading `MSGPACK_ARCH_SH`]
+
+[@http://en.wikipedia.org/wiki/SuperH SuperH] architecture:
+If available versions \[1-5\] are specifically detected.
+
+[table
+    [[__predef_symbol__] [__predef_version__]]
+
+    [[`__sh__`] [__predef_detection__]]
+
+    [[`__SH5__`] [5.0.0]]
+    [[`__SH4__`] [4.0.0]]
+    [[`__sh3__`] [3.0.0]]
+    [[`__SH3__`] [3.0.0]]
+    [[`__sh2__`] [2.0.0]]
+    [[`__sh1__`] [1.0.0]]
+    ]
+ */
+
+#define MSGPACK_ARCH_SH MSGPACK_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__sh__)
+#   undef MSGPACK_ARCH_SH
+#   if !defined(MSGPACK_ARCH_SH) && (defined(__SH5__))
+#       define MSGPACK_ARCH_SH MSGPACK_VERSION_NUMBER(5,0,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_SH) && (defined(__SH4__))
+#       define MSGPACK_ARCH_SH MSGPACK_VERSION_NUMBER(4,0,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_SH) && (defined(__sh3__) || defined(__SH3__))
+#       define MSGPACK_ARCH_SH MSGPACK_VERSION_NUMBER(3,0,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_SH) && (defined(__sh2__))
+#       define MSGPACK_ARCH_SH MSGPACK_VERSION_NUMBER(2,0,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_SH) && (defined(__sh1__))
+#       define MSGPACK_ARCH_SH MSGPACK_VERSION_NUMBER(1,0,0)
+#   endif
+#   if !defined(MSGPACK_ARCH_SH)
+#       define MSGPACK_ARCH_SH MSGPACK_VERSION_NUMBER_AVAILABLE
+#   endif
+#endif
+
+#if MSGPACK_ARCH_SH
+#   define MSGPACK_ARCH_SH_AVAILABLE
+#endif
+
+#define MSGPACK_ARCH_SH_NAME "SuperH"
+
+#include <msgpack/predef/detail/test.h>
+MSGPACK_PREDEF_DECLARE_TEST(MSGPACK_ARCH_SH,MSGPACK_ARCH_SH_NAME)
+
+
+#endif

include/msgpack/predef/architecture/sys370.h

@@ -0,0 +1,44 @@
+/*
+Copyright Rene Rivera 2008-2013
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef MSGPACK_PREDEF_ARCHITECTURE_SYS370_H
+#define MSGPACK_PREDEF_ARCHITECTURE_SYS370_H
+
+#include <msgpack/predef/version_number.h>
+#include <msgpack/predef/make.h>
+
+/*`
+[heading `MSGPACK_ARCH_SYS370`]
+
+[@http://en.wikipedia.org/wiki/System/370 System/370] architecture.
+
+[table
+    [[__predef_symbol__] [__predef_version__]]
+
+    [[`__370__`] [__predef_detection__]]
+    [[`__THW_370__`] [__predef_detection__]]
+    ]
+ */
+
+#define MSGPACK_ARCH_SYS370 MSGPACK_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__370__) || defined(__THW_370__)
+#   undef MSGPACK_ARCH_SYS370
+#   define MSGPACK_ARCH_SYS370 MSGPACK_VERSION_NUMBER_AVAILABLE
+#endif
+
+#if MSGPACK_ARCH_SYS370
+#   define MSGPACK_ARCH_SYS370_AVAILABLE
+#endif
+
+#define MSGPACK_ARCH_SYS370_NAME "System/370"
+
+#include <msgpack/predef/detail/test.h>
+MSGPACK_PREDEF_DECLARE_TEST(MSGPACK_ARCH_SYS370,MSGPACK_ARCH_SYS370_NAME)
+
+
+#endif

include/msgpack/predef/architecture/sys390.h

@@ -0,0 +1,44 @@
+/*
+Copyright Rene Rivera 2008-2013
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef MSGPACK_PREDEF_ARCHITECTURE_SYS390_H
+#define MSGPACK_PREDEF_ARCHITECTURE_SYS390_H
+
+#include <msgpack/predef/version_number.h>
+#include <msgpack/predef/make.h>
+
+/*`
+[heading `MSGPACK_ARCH_SYS390`]
+
+[@http://en.wikipedia.org/wiki/System/390 System/390] architecture.
+
+[table
+    [[__predef_symbol__] [__predef_version__]]
+
+    [[`__s390__`] [__predef_detection__]]
+    [[`__s390x__`] [__predef_detection__]]
+    ]
+ */
+
+#define MSGPACK_ARCH_SYS390 MSGPACK_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__s390__) || defined(__s390x__)
+#   undef MSGPACK_ARCH_SYS390
+#   define MSGPACK_ARCH_SYS390 MSGPACK_VERSION_NUMBER_AVAILABLE
+#endif
+
+#if MSGPACK_ARCH_SYS390
+#   define MSGPACK_ARCH_SYS390_AVAILABLE
+#endif
+
+#define MSGPACK_ARCH_SYS390_NAME "System/390"
+
+#include <msgpack/predef/detail/test.h>
+MSGPACK_PREDEF_DECLARE_TEST(MSGPACK_ARCH_SYS390,MSGPACK_ARCH_SYS390_NAME)
+
+
+#endif

include/msgpack/predef/architecture/x86.h

@@ -0,0 +1,38 @@
+/*
+Copyright Rene Rivera 2008-2013
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef MSGPACK_PREDEF_ARCHITECTURE_X86_H
+#define MSGPACK_PREDEF_ARCHITECTURE_X86_H
+
+#include <msgpack/predef/architecture/x86/32.h>
+#include <msgpack/predef/architecture/x86/64.h>
+
+/*`
+[heading `MSGPACK_ARCH_X86`]
+
+[@http://en.wikipedia.org/wiki/X86 Intel x86] architecture. This is
+a category to indicate that either `MSGPACK_ARCH_X86_32` or
+`MSGPACK_ARCH_X86_64` is detected.
+ */
+
+#define MSGPACK_ARCH_X86 MSGPACK_VERSION_NUMBER_NOT_AVAILABLE
+
+#if MSGPACK_ARCH_X86_32 || MSGPACK_ARCH_X86_64
+#   undef MSGPACK_ARCH_X86
+#   define MSGPACK_ARCH_X86 MSGPACK_VERSION_NUMBER_AVAILABLE
+#endif
+
+#if MSGPACK_ARCH_X86
+#   define MSGPACK_ARCH_X86_AVAILABLE
+#endif
+
+#define MSGPACK_ARCH_X86_NAME "Intel x86"
+
+#include <msgpack/predef/detail/test.h>
+MSGPACK_PREDEF_DECLARE_TEST(MSGPACK_ARCH_X86,MSGPACK_ARCH_X86_NAME)
+
+#endif