Merge pull request #364 from redboltz/1_2_0_rel

Updated version. Appended CHANGELOG.

.gitignore

@@ -1,5 +1,7 @@
 # Files generated by the bootstrap script.
 /INSTALL
+/AUTHORS
+/ChangeLog
 /NEWS
 /README
 /ac/
@@ -9,16 +11,6 @@
 /configure
 /msgpack_vc2008.sln
 /msgpack_vc2008.vcproj
-/src/msgpack/pack_define.h
-/src/msgpack/pack_template.h
-/src/msgpack/sysdep.h
-/src/msgpack/type/define.hpp
-/src/msgpack/type/tuple.hpp
-/src/msgpack/unpack_define.h
-/src/msgpack/unpack_template.h
-/src/msgpack/zone.hpp
-/test/cases.mpac
-/test/cases_compact.mpac
 Makefile.in
 
 # Files generated by the configure script.
@@ -29,6 +21,7 @@ Makefile.in
 /libtool
 /msgpack.pc
 /src/msgpack/version.h
+/src/msgpack/version.hpp
 /stamp-h1
 Makefile
 .deps

.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

@@ -0,0 +1,91 @@
+language: cpp
+os:
+  - linux
+  - osx
+cache:
+  - apt
+compiler:
+  - clang
+  - gcc
+os:
+  - osx
+  - linux
+before_install:
+  - 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:
+  - 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
+  - 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="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} ${BOOST} ${BOOST_INC}

AUTHORS

@@ -1 +0,0 @@
-FURUHASHI Sadayuki <frsyuki _at_ users.sourceforge.jp>

CHANGELOG.md

@@ -0,0 +1,161 @@
+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
+  * Improve user types adaptation mechanism (#262)
+    Since version 1.0.0, users need to obey the correct include order.
+    However, it is very difficult to maintain the correct order in big
+    projects. version 1.1.0 removed this order. Users don't need to
+    care about include order. Migration guide from 1.0.x to 1.1.0 has
+    been written. See https://github.com/msgpack/msgpack-c/wiki
+
+  * Fix vector<bool> size check (#251)
+  * Fix inttypes.h inclusion on MSVC (#257)
+  * Support documents generation by Doxygen (#259)
+  * Remove C99 style variable declaration (#253)
+  * Improve documents (https://github.com/msgpack/msgpack-c/wiki)
+2015-03-22 version 1.0.1:
+  * Fix compilation error on Mac 10.9 (#244)
+  * Fix typos in documents (#240)
+  * Update CHANGELOG.md for version 1.0.0 (#242)
+  * Fix erb templates for the next code generation (#239)
+
+2015-03-10 version 1.0.0:
+  * Support msgpack v5 format (str, bin, and ext) https://github.com/msgpack/msgpack/blob/master/spec.md (#142)
+  * Support std::tuple, std::forward_list, std::array, std::unordered_set, std::unordered_map on C++11. tr1 unordered containers are still supported (#53, #130, #137, #154, #169)
+  * Update msgpack-c as a header-only library on C++ (#142)
+  * Move include directory (#142)
+  * Update the name of float format family on msgpack::object from 'dec' to 'f64' (#194)
+  * Remove existing elements on associative containers when unpacking (#127)
+  * Add an API versioning functionality https://github.com/msgpack/msgpack-c/wiki/cpp_versioning (#139)
+  * Add C++11 enum class support (#205)
+  * Map std::vector<char> and std::array<char> to BIN (#100)
+  * Map '\0' teminated char* and char const* to STR (#206)
+  * Add the new parameter on unpacking functions and classes to limit msgpack's bytestream size (https://github.com/msgpack/msgpack-c/wiki/cpp_unpacker#limit-size-of-elements) (#175)
+  * Add the copy or reference choosing function on unpack() and unpacker (https://github.com/msgpack/msgpack-c/wiki/cpp_unpacker#memory-management)
+  * Add the new unpack() overloads for C++11 https://github.com/msgpack/msgpack-c/wiki/cpp_unpacker (#128)
+  * Add a msgpack::object::with_zone (deep) copying function (#133, #163)
+  * Remove the compile-time defined limit of msgpack nest level on C++ (#218)
+  * Add the new unpack() overloads that use an existing zone (#201)
+  * Add the range-based for loop support on msgpack object array and map (#203)
+  * Add msgpack revision getter function for 'revision' (#237)
+  * Support EXT for C (#118, #129)
+  * Fix unpacking buffer allocation problem when malformed data is given (#160, #185)
+  * Add dll exporting function on MSVC (#162)
+  * Fix msgpack::zone::allocate_no_align(). Now it allocates the memory that is not aligned as expected (#171)
+  * Improve documents (https://github.com/msgpack/msgpack-c/wiki)
+  * Other bug fixes and refactoring: #62, #91, #95, #97, #107, #109, #113, #117, #119, #121, #122, #123, #126, #131, #136, #138, #140, #143, #145, #146, #150, #151, #152, #156, #157, #158, #161, #165, #170, #172, #179, #180, #181, #182, #183, #192, #195, #199, #200, #207, #211, #212, #219, #222, #224, #230, #231, #232, #233, #234, #235
+
+2014-07-02 version 0.5.9:
+
+  * Support std::tr1 unordered containers by default (#51, #63, #68, #69)
+  * Remove some warnings (#56)
+  * Fix segmentation fault after malloc failures (#58, #59)
+  * Fix alloc/dealloc mismatch (#52, #61)
+  * Fix sample codes (#60, #64)
+  * Support implicit conversion from integer to float/double (#54)
+  * Improve documents (#45, #75, #82, #83)
+  * Support CMake (#20, #87)
+  * Remove Ruby dependencies in bootstrap (#86, #87)
+  * Add FILE* buffer (#40)
+  * Other bug fixes and refactoring: #39, #73, #77, #79, #80, #81, #84, #90
+
+2013-12-23 version 0.5.8:
+
+  * Move to the new github repository msgpack/msgpack-c
+  * Support the new deserialization specification
+  * fixes the problem of unpack helpers for array and map with 32bit compilers (#37, #38)
+  * Other bug fixes and refactoring: #46, #41, #36, #35, #33, #32, #30, #29, #28, #27, #26, #25, #8, #3
+  * Update of documents: #23, #18, #17
+
+2011-08-08 version 0.5.7:
+
+  * fixes compile error problem with llvm-gcc and Mac OS X Lion
+
+2011-04-24 version 0.5.6:
+
+  * #42 fixes double-free problem on msgpack_unpacker_release_zone
+
+2011-02-24 version 0.5.5:
+
+  * eliminates dependency of winsock2.h header
+  * fixes msgpack_vc.postbuild.bat file
+  * fixes some implicit cast warnings
+
+2010-08-29 version 0.5.4:
+
+  * includes msgpack_vc2008.vcproj file in source package
+  * fixes type::fix_int types
+
+2010-08-27 version 0.5.3:
+
+  * adds type::fix_{u,}int{8,16,32,64} types
+  * adds msgpack_pack_fix_{u,}int{8,16,32,64} functions
+  * adds packer<Stream>::pack_fix_{u,}int{8,16,32,64} functions
+  * fixes include paths
+
+2010-07-14 version 0.5.2:
+
+  * type::raw::str(), operator==, operator!=, operator< and operator> are now const
+  * generates version.h using AC_OUTPUT macro in ./configure
+
+2010-07-06 version 0.5.1:
+
+  * Add msgpack_vrefbuffer_new and msgpack_vrefbuffer_free
+  * Add msgpack_sbuffer_new and msgpack_sbuffer_free
+  * Add msgpack_unpacker_next and msgpack_unpack_next
+  * msgpack::unpack returns void
+  * Add MSGPACK_VERSION{,_MAJOR,_MINOR} macros to check header version
+  * Add msgpack_version{,_major,_minor} functions to check library version
+  * ./configure supports --disable-cxx option not to build C++ API
+
+2010-04-29 version 0.5.0:
+
+  * msgpack_object_type is changed. MSGPACK_OBJECT_NIL is now 0x00.
+  * New safe streaming deserializer API.
+  * Add object::object(const T&) and object::operator=(const T&)
+  * 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

@@ -0,0 +1,361 @@
+CMAKE_MINIMUM_REQUIRED (VERSION 2.8.6)
+PROJECT (msgpack)
+
+FILE (READ ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/version_master.h contents)
+STRING (REGEX MATCH "#define MSGPACK_VERSION_MAJOR *([0-9a-zA-Z_]*)" NULL_OUT ${contents})
+SET (VERSION_MAJOR ${CMAKE_MATCH_1})
+STRING (REGEX MATCH "#define MSGPACK_VERSION_MINOR *([0-9a-zA-Z_]*)" NULL_OUT ${contents})
+SET (VERSION_MINOR ${CMAKE_MATCH_1})
+STRING (REGEX MATCH "#define MSGPACK_VERSION_REVISION *([0-9a-zA-Z_]*)" NULL_OUT ${contents})
+SET (VERSION_REVISION ${CMAKE_MATCH_1})
+SET (VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_REVISION})
+
+SET (prefix ${CMAKE_INSTALL_PREFIX})
+SET (exec_prefix "\${prefix}")
+SET (libdir "\${exec_prefix}/lib")
+SET (includedir "\${prefix}/include")
+
+OPTION (MSGPACK_CXX11 "Using c++11 compiler" OFF)
+OPTION (MSGPACK_32BIT "32bit compile" OFF)
+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")
+      SET (CMAKE_CXX_FLAGS "-std=c++11 ${CMAKE_CXX_FLAGS}")
+   ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+      SET (CMAKE_CXX_FLAGS "-std=c++11 ${CMAKE_CXX_FLAGS}")
+   ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+      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 ()
+
+IF (MSGPACK_32BIT)
+   IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+      SET (CMAKE_CXX_FLAGS "-m32 ${CMAKE_CXX_FLAGS}")
+      SET (CMAKE_C_FLAGS "-m32 ${CMAKE_C_FLAGS}")
+      SET (CMAKE_EXE_LINKER_FLAGS "-m32 ${CMAKE_EXE_LINKER_FLAGS}")
+   ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+      SET (CMAKE_CXX_FLAGS "-m32 ${CMAKE_CXX_FLAGS}")
+      SET (CMAKE_C_FLAGS "-m32 ${CMAKE_C_FLAGS}")
+      SET (CMAKE_EXE_LINKER_FLAGS "-m32 ${CMAKE_EXE_LINKER_FLAGS}")
+   ENDIF ()
+ENDIF ()
+
+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 ("
+#include <bits/atomicity.h>
+int atomic_sub(int i) { return __gnu_cxx::__exchange_and_add(&i, -1) - 1; }
+int atomic_add(int i) { return __gnu_cxx::__exchange_and_add(&i, 1) + 1; }
+int main(int argc, char * argv[])
+{
+    atomic_sub(1);
+    atomic_add(1);
+}
+" MSGPACK_ENABLE_GCC_CXX_ATOMIC)
+
+IF (MSGPACK_ENABLE_GCC_CXX_ATOMIC)
+    LIST (APPEND msgpack_SOURCES
+        src/gcc_atomic.cpp
+    )
+ENDIF ()
+
+
+LIST (APPEND msgpack_SOURCES
+    src/unpack.c
+    src/objectc.c
+    src/version.c
+    src/vrefbuffer.c
+    src/zone.c
+)
+
+LIST (APPEND msgpack_HEADERS
+    include/msgpack/pack_define.h
+    include/msgpack/pack_template.h
+    include/msgpack/unpack_define.h
+    include/msgpack/unpack_template.h
+    include/msgpack/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
+    include/msgpack/pack.h
+    include/msgpack/unpack.h
+    include/msgpack/object.h
+    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/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_array.hpp
+        include/msgpack/adaptor/detail/cpp03_define_map.hpp
+        include/msgpack/adaptor/detail/cpp03_msgpack_tuple.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
+        include/msgpack/adaptor/list.hpp
+        include/msgpack/adaptor/map.hpp
+        include/msgpack/adaptor/msgpack_tuple.hpp
+        include/msgpack/adaptor/nil.hpp
+        include/msgpack/adaptor/pair.hpp
+        include/msgpack/adaptor/raw.hpp
+        include/msgpack/adaptor/v4raw.hpp
+        include/msgpack/adaptor/set.hpp
+        include/msgpack/adaptor/string.hpp
+        include/msgpack/adaptor/tr1/unordered_map.hpp
+        include/msgpack/adaptor/tr1/unordered_set.hpp
+        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
+        include/msgpack/sbuffer.hpp
+        include/msgpack/type.hpp
+        include/msgpack/unpack.hpp
+        include/msgpack/version.hpp
+        include/msgpack/versioning.hpp
+        include/msgpack/vrefbuffer.hpp
+        include/msgpack/zbuffer.hpp
+        include/msgpack/zone.hpp
+    )
+    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 (
+    COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/src/msgpack
+)
+
+CONFIGURE_FILE (
+    msgpack.pc.in
+    msgpack.pc
+    @ONLY
+)
+
+INCLUDE_DIRECTORIES (
+    ./
+    include/
+    ${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}
+    ${msgpack_HEADERS}
+)
+
+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 ()
+    # 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)
+    ADD_SUBDIRECTORY (test)
+ENDIF ()
+
+IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+    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 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+    ELSE ()
+        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
+    ENDIF ()
+ENDIF ()
+
+IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC90" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC10")
+    SET_SOURCE_FILES_PROPERTIES(${msgpack_SOURCES} PROPERTIES LANGUAGE CXX)
+ENDIF()
+
+IF (NOT DEFINED CMAKE_INSTALL_LIBDIR)
+    SET(CMAKE_INSTALL_LIBDIR lib)
+ENDIF ()
+
+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)
+    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
+    )
+    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
+    )
+    ADD_CUSTOM_TARGET (
+        doxygen
+        DEPENDS doxygen_c doxygen_cpp
+    )
+ENDIF ()

CROSSLANG.md

@@ -22,7 +22,7 @@ as comparing that implementations.
     or
     $ port install msgpack  # MacPorts
     
-    $ g++ -Wall -lmsgpack crosslang.cc -o crosslang
+    $ g++ -Wall crosslang.cc -lmsgpack -o crosslang
 
     $ ./crosslang
     Usage: ./crosslang [in-file] [out-file]

ChangeLog

@@ -1,58 +0,0 @@
-2013-12-23 version 0.5.8:
-
-  * Move to the new github repository msgpack/msgpack-c
-  * Support the new deserialization specification
-  * fixes the problem of unpack helpers for array and map with 32bit compilers (#37, #38)
-  * Other bug fixes and refactoring: #46, #41, #36, #35, #33, #32, #30, #29, #28, #27, #26, #25, #8, #3
-  * Update of documents: #23, #18, #17
-
-2011-08-08 version 0.5.7:
-
-  * fixes compile error problem with llvm-gcc and Mac OS X Lion
-
-2011-04-24 version 0.5.6:
-
-  * #42 fixes double-free problem on msgpack_unpacker_release_zone
-
-2011-02-24 version 0.5.5:
-
-  * eliminates dependency of winsock2.h header
-  * fixes msgpack_vc.postbuild.bat file
-  * fixes some implicit cast warnings
-
-2010-08-29 version 0.5.4:
-
-  * includes msgpack_vc2008.vcproj file in source package
-  * fixes type::fix_int types
-
-2010-08-27 version 0.5.3:
-
-  * adds type::fix_{u,}int{8,16,32,64} types
-  * adds msgpack_pack_fix_{u,}int{8,16,32,64} functions
-  * adds packer<Stream>::pack_fix_{u,}int{8,16,32,64} functions
-  * fixes include paths
-
-2010-07-14 version 0.5.2:
-
-  * type::raw::str(), operator==, operator!=, operator< and operator> are now const
-  * generates version.h using AC_OUTPUT macro in ./configure
-
-2010-07-06 version 0.5.1:
-
-  * Add msgpack_vrefbuffer_new and msgpack_vrefbuffer_free
-  * Add msgpack_sbuffer_new and msgpack_sbuffer_free
-  * Add msgpack_unpacker_next and msgpack_unpack_next
-  * msgpack::unpack returns void
-  * Add MSGPACK_VERSION{,_MAJOR,_MINOR} macros to check header version
-  * Add msgpack_version{,_major,_minor} functions to check library version
-  * ./configure supports --disable-cxx option not to build C++ API
-
-2010-04-29 version 0.5.0:
-
-  * msgpack_object_type is changed. MSGPACK_OBJECT_NIL is now 0x00.
-  * New safe streaming deserializer API.
-  * Add object::object(const T&) and object::operator=(const T&)
-  * Add operator==(object, const T&)
-  * MSGPACK_DEFINE macro defines msgpack_object(object* obj, zone* z)
-  * C++ programs doesn't need to link "msgpackc" library.
-

Makefile.am

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

NOTICE

@@ -1,4 +1,36 @@
-MessagePack is developed by FURUHASHI Sadayuki, licensed under Apache License,
-Version 2.0. The original software and related information is available at
-http://msgpack.sourceforge.jp/.
+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.
+---------------------------------------------------------------------------

QUICKSTART-C.md

@@ -2,7 +2,7 @@
 
 The serialization library is production-ready.
 
-Currently, no RPC implementation is not available.
+Currently, RPC implementation is not available.
 
 # Install
 

QUICKSTART-CPP.md

@@ -2,7 +2,7 @@
 
 The serialization library is production-ready.
 
-Currently, RPC implementation is testing phase. Requires newer kernel, not running on RHEL5/CentOS5.
+Currently, RPC implementation is in testing phase. Requires newer kernel, not running on RHEL5/CentOS5.
 
 # Install
 
@@ -103,7 +103,7 @@ int main(void) {
         msgpack::sbuffer buffer;
 
         msgpack::packer<msgpack::sbuffer> pk(&buffer);
-        pk.pack_array(3)
+        pk.pack_array(3);
         pk.pack(std::string("Log message ... 1"));
         pk.pack(std::string("Log message ... 2"));
         pk.pack(std::string("Log message ... 3"));
@@ -112,10 +112,10 @@ int main(void) {
         msgpack::sbuffer buffer2;
 
         msgpack::packer<msgpack::sbuffer> pk2(&buffer2);
-        pk2.pack_map(2)
+        pk2.pack_map(2);
         pk2.pack(std::string("x"));
         pk2.pack(3);
-        pk2.pack(std::string("y));
+        pk2.pack(std::string("y"));
         pk2.pack(3.4321);
 
 }
@@ -124,7 +124,7 @@ int main(void) {
 
 ## User-defined classes
 
-You can use serialize/deserializes user-defined classes using MSGPACK_DEFINE macro.
+You can use serialize/deserializes user-defined classes using `MSGPACK_DEFINE` macro.
 
 ```cpp
 #include <msgpack.hpp>

README.md

@@ -1,73 +1,219 @@
-MessagePack for C/C++
-=====================
-Binary-based efficient object serialization library.
+`msgpack` for C/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)
 
-## Installation
+It's like JSON but small and fast.
 
-Download latest package from [releases of MessagePack](http://sourceforge.net/projects/msgpack/files/) and extract it.
+Overview
+--------
 
-On UNIX-like platform, run ./configure && make && sudo make install:
+[MessagePack](http://msgpack.org/) is an efficient binary serialization
+format, which lets you exchange data among multiple languages like JSON,
+except that it's faster and smaller. Small integers are encoded into a
+single byte while typical short strings require only one extra byte in
+addition to the strings themselves.
 
-    $ ./configure
-    $ make
-    $ sudo make install
+Example
+-------
 
-On Windows, open msgpack_vc8.vcproj or msgpack_vc2008 file and build it using batch build. DLLs are built on lib folder,
-and the headers are built on include folder.
+In C:
 
-To use the library in your program, include msgpack.hpp header and link "msgpack" library.
+```c
+#include <msgpack.h>
+#include <stdio.h>
 
+int main(void)
+{
+    /* msgpack::sbuffer is a simple buffer implementation. */
+    msgpack_sbuffer sbuf;
+    msgpack_sbuffer_init(&sbuf);
 
-## Example
-```CPP
-#include <msgpack.hpp>
-#include <vector>
-    
-int main(void) {
-    // This is target object.
-    std::vector<std::string> target;
-    target.push_back("Hello,");
-    target.push_back("World!");
-    
-    // Serialize it.
-    msgpack::sbuffer sbuf;  // simple buffer
-    msgpack::pack(&sbuf, target);
-    
-    // Deserialize the serialized data.
-    msgpack::unpacked msg;    // includes memory pool and deserialized object
-    msgpack::unpack(&msg, sbuf.data(), sbuf.size());
-    msgpack::object obj = msg.get();
-    
-    // Print the deserialized object to stdout.
-    std::cout << obj << std::endl;    // ["Hello," "World!"]
-    
-    // Convert the deserialized object to staticaly typed object.
-    std::vector<std::string> result;
-    obj.convert(&result);
-    
-    // If the type is mismatched, it throws msgpack::type_error.
-    obj.as<int>();  // type is mismatched, msgpack::type_error is thrown
+    /* serialize values into the buffer using msgpack_sbuffer_write callback function. */
+    msgpack_packer pk;
+    msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
+
+    msgpack_pack_array(&pk, 3);
+    msgpack_pack_int(&pk, 1);
+    msgpack_pack_true(&pk);
+    msgpack_pack_str(&pk, 7);
+    msgpack_pack_str_body(&pk, "example", 7);
+
+    /* deserialize the buffer into msgpack_object instance. */
+    /* deserialized object is valid during the msgpack_zone instance alive. */
+    msgpack_zone mempool;
+    msgpack_zone_init(&mempool, 2048);
+
+    msgpack_object deserialized;
+    msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
+
+    /* print the deserialized object. */
+    msgpack_object_print(stdout, deserialized);
+    puts("");
+
+    msgpack_zone_destroy(&mempool);
+    msgpack_sbuffer_destroy(&sbuf);
+
+    return 0;
 }
 ```
 
-See [QuickStart for C](QUICKSTART-C.md) and [QuickStart for C++](QUICKSTART-CPP.md) for other example codes.
+See [`QUICKSTART-C.md`](./QUICKSTART-C.md) for more details.
 
-## License
+In C++:
 
-    Copyright (C) 2008-2010 FURUHASHI Sadayuki
-    
-       Licensed under the Apache License, Version 2.0 (the "License");
-       you may not use this file except in compliance with the License.
-       You may obtain a copy of the License at
-    
-           http://www.apache.org/licenses/LICENSE-2.0
-    
-       Unless required by applicable law or agreed to in writing, software
-       distributed under the License is distributed on an "AS IS" BASIS,
-       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-       See the License for the specific language governing permissions and
-       limitations under the License.
+```c++
+#include <msgpack.hpp>
+#include <string>
+#include <iostream>
+#include <sstream>
 
-See also NOTICE file.
+int main(void)
+{
+    msgpack::type::tuple<int, bool, std::string> src(1, true, "example");
 
+    // serialize the object into the buffer.
+    // any classes that implements write(const char*,size_t) can be a buffer.
+    std::stringstream buffer;
+    msgpack::pack(buffer, src);
+
+    // send the buffer ...
+    buffer.seekg(0);
+
+    // deserialize the buffer into msgpack::object instance.
+    std::string str(buffer.str());
+
+    msgpack::unpacked result;
+
+    msgpack::unpack(result, str.data(), str.size());
+
+    // deserialized object is valid during the msgpack::unpacked instance alive.
+    msgpack::object deserialized = result.get();
+
+    // msgpack::object supports ostream.
+    std::cout << deserialized << std::endl;
+
+    // convert msgpack::object instance into the original type.
+    // if the type is mismatched, it throws msgpack::type_error exception.
+    msgpack::type::tuple<int, bool, std::string> dst;
+    deserialized.convert(&dst);
+
+    return 0;
+}
+```
+
+See [`QUICKSTART-CPP.md`](./QUICKSTART-CPP.md) for more details.
+
+Usage
+-----
+
+### C++ Header Only Library
+
+When you use msgpack on C++03 and C++11, you can just add
+msgpack-c/include to your include path:
+
+    g++ -I msgpack-c/include your_source_file.cpp
+
+If you want to use C version of msgpack, you need to build it. You can
+also install the C and C++ versions of msgpack.
+
+### Building and Installing
+
+#### Install from git repository
+
+##### Using autotools
+
+You will need:
+
+ - `gcc >= 4.1.0` or `clang >= 3.3.0`
+ - `autoconf >= 2.60`
+ - `automake >= 1.10`
+ - `libtool >= 2.2.4`
+
+The build steps below are for C and C++03. If compiling for C++11,
+add `-std=c++11` to the environmental variable `CXXFLAGS` with
+`export CXXFLAGS="$CXXFLAGS -std=c++11"` prior to following the
+directions below.
+
+```bash
+$ git clone https://github.com/msgpack/msgpack-c
+$ cd msgpack-c
+$ ./bootstrap
+$ ./configure
+$ make
+```
+
+You can install the resulting library like this:
+
+```bash
+$ sudo make install
+```
+##### Using cmake
+
+###### Using the Terminal (CLI)
+
+You will need:
+
+ - `gcc >= 4.1.0`
+ - `cmake >= 2.8.0`
+
+C and C++03:
+
+    $ git clone https://github.com/msgpack/msgpack-c.git
+    $ cd msgpack-c
+    $ cmake .
+    $ make
+    $ sudo make install
+
+If you want to setup C++11 version of msgpack instead,
+execute the following commands:
+
+    $ git clone https://github.com/msgpack/msgpack-c.git
+    $ cd msgpack-c
+    $ cmake -DMSGPACK_CXX11=ON .
+    $ sudo make install
+
+##### GUI on Windows
+
+Clone msgpack-c git repository.
+
+    $ git clone https://github.com/msgpack/msgpack-c.git
+
+or using GUI git client.
+
+e.g.) tortoise git https://code.google.com/p/tortoisegit/
+
+1. Launch [cmake GUI client](http://www.cmake.org/cmake/resources/software.html).
+
+2. Set 'Where is the source code:' text box and 'Where to build
+the binaries:' text box.
+
+3. Click 'Configure' button.
+
+4. Choose your Visual Studio version.
+
+5. Click 'Generate' button.
+
+6. Open the created msgpack.sln on Visual Studio.
+
+7. Build all.
+
+### Documentation
+
+You can get addtional information on the
+[wiki](https://github.com/msgpack/msgpack-c/wiki).
+
+Contributing
+------------
+
+`msgpack-c` is developed on GitHub at [msgpack/msgpack-c](https://github.com/msgpack/msgpack-c).
+To report an issue or send a pull request, use the
+[issue tracker](https://github.com/msgpack/msgpack-c/issues).
+
+Here's the list of [great contributors](https://github.com/msgpack/msgpack-c/graphs/contributors).
+
+License
+-------
+
+`msgpack-c` is licensed under the Apache License Version 2.0. See
+the [`LICENSE`](./LICENSE) file for details.

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

bootstrap

@@ -36,15 +36,9 @@ test -f AUTHORS   || touch AUTHORS
 test -f COPYING   || touch COPYING
 test -f ChangeLog || touch ChangeLog
 test -f NEWS      || touch NEWS
+test -f NOTICE    || touch NOTICE
 test -f README    || cp -f README.md README
 
-./preprocess
-if [ $? -ne 0 ]; then
-	exit 1
-fi
-
-
-
 ACLOCAL="aclocal"
 ACLOCAL_FILES="aclocal.m4"
 ALWAYS_CLEAN="config.status config.log config.cache libtool"

ci/build_autotools.sh

@@ -0,0 +1,63 @@
+#!/bin/sh
+
+./bootstrap
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+if [ $1 = "cpp11" ]
+then
+    cpp11="-std=c++11"
+else
+    cpp11=""
+fi
+
+if [ $2 = "32" ]
+then
+    bit32="-m32"
+else
+    bit32=""
+fi
+
+if [ $3 = "boost" ]
+then
+    boost="-DMSGPACK_USE_BOOST"
+else
+    boost=""
+fi
+
+./configure CFLAGS="$bit32" CXXFLAGS="$bit32 $cpp11 $boost -I$4"
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+make
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+make check
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+make install DESTDIR=`pwd`/build/install
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+exit 0

ci/build_cmake.sh

@@ -0,0 +1,103 @@
+#!/bin/bash
+
+mkdir build
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+cd build
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+if [ $1 = "cpp11" ]
+then
+    cpp11="-DMSGPACK_CXX11=ON"
+else
+    cpp11=""
+fi
+
+if [ $2 = "32" ]
+then
+    bit32="-DMSGPACK_32BIT=ON"
+else
+    bit32=""
+fi
+
+if [ $3 = "boost" ]
+then
+    boost="-DMSGPACK_BOOST=ON"
+else
+    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
+    exit $ret
+fi
+
+make
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+make test
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+make install DESTDIR=`pwd`/install
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+if [ "$2" != "32" ]
+then
+    ctest -T memcheck | tee memcheck.log
+
+    ret=${PIPESTATUS[0]}
+    if [ $ret -ne 0 ]
+    then
+        exit $ret
+    fi
+    cat memcheck.log | grep "Memory Leak" > /dev/null
+    ret=$?
+    if [ $ret -eq 0 ]
+    then
+        exit 1
+    fi
+fi
+
+exit 0

configure.in

@@ -1,13 +1,12 @@
-AC_INIT(src/object.cpp)
+AC_INIT(msgpack, m4_esyscmd([cat include/msgpack/version_master.h | tr -d "\n" | sed -e 's/#define MSGPACK_VERSION_MAJOR[[:space:]]*\([[:alnum:]]*\)/\1./g' -e 's/#define MSGPACK_VERSION_MINOR[[:space:]]*\([[:alnum:]]*\)/\1./g' -e 's/#define MSGPACK_VERSION_REVISION[[:space:]]*\([[:alnum:]]*\)/\1/g' | tr -d "\n"]))
 AC_CONFIG_AUX_DIR(ac)
-AM_INIT_AUTOMAKE(msgpack, 0.5.8)
+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
@@ -15,12 +14,12 @@ AC_PROG_CC
 
 AC_MSG_CHECKING([if C++ API is enabled])
 AC_ARG_ENABLE(cxx,
-	AS_HELP_STRING([--disable-cxx],
-				   [don't build C++ API]) )   #'
+    AS_HELP_STRING([--disable-cxx],
+                   [don't build C++ API]) )   #'
 AC_MSG_RESULT([$enable_cxx])
 if test "$enable_cxx" != "no"; then
-	AC_PROG_CXX
-	AM_PROG_CC_C_O
+    AC_PROG_CXX
+    AM_PROG_CC_C_O
 fi
 AM_CONDITIONAL(ENABLE_CXX, test "$enable_cxx" != "no")
 
@@ -31,70 +30,69 @@ AM_PROG_AS
 
 AC_MSG_CHECKING([if debug option is enabled])
 AC_ARG_ENABLE(debug,
-	AS_HELP_STRING([--disable-debug],
-				   [disable assert macros and omit -g option]) )
+    AS_HELP_STRING([--disable-debug],
+                   [disable assert macros and omit -g option]) )
 AC_MSG_RESULT([$enable_debug])
 if test "$enable_debug" != "no"; then
-	CXXFLAGS="$CXXFLAGS -g"
-	CFLAGS="$CFLAGS -g"
+    CXXFLAGS="$CXXFLAGS -g"
+    CFLAGS="$CFLAGS -g"
 else
-	CXXFLAGS="$CXXFLAGS -DNDEBUG"
-	CFLAGS="$CFLAGS -DNDEBUG"
+    CXXFLAGS="$CXXFLAGS -DNDEBUG"
+    CFLAGS="$CFLAGS -DNDEBUG"
 fi
 
 
 AC_CACHE_CHECK([for __sync_* atomic operations], msgpack_cv_atomic_ops, [
-	AC_TRY_LINK([
-		int atomic_sub(int i) { return __sync_sub_and_fetch(&i, 1); }
-		int atomic_add(int i) { return __sync_add_and_fetch(&i, 1); }
-	], [atomic_sub(1); atomic_add(1);], msgpack_cv_atomic_ops="yes")
-	])
-if test "$msgpack_cv_atomic_ops" != "yes"; then
-	if test "$enable_cxx" = "no"; then
-		AC_MSG_ERROR([__sync_* atomic operations are not found. Try to enable C++ support.
-If you are using gcc >= 4.1 and the default target CPU architecture is "i386", try to
-add CFLAGS="-march=i686" and CXXFLAGS="-march=i686" options to ./configure as follows:
-
-  $ ./configure CFLAGS="-march=i686" CXXFLAGS="-march=i686"
-					  ])
-	fi
-
-	AC_LANG_PUSH([C++])
-	AC_CACHE_CHECK([for __gnu_cxx::__exchange_and_add], msgpack_cv_gcc_cxx_atomic_ops, [
-		AC_TRY_LINK([
-			#include <bits/atomicity.h>
-			int atomic_sub(int i) { return __gnu_cxx::__exchange_and_add(&i, -1) - 1; }
-			int atomic_add(int i) { return __gnu_cxx::__exchange_and_add(&i, 1) + 1; }
-		], [atomic_sub(1); atomic_add(1);], msgpack_cv_gcc_cxx_atomic_ops="yes")
-		])
-	AC_LANG_POP([C++])
-
-	if test "$msgpack_cv_gcc_cxx_atomic_ops" != "yes"; then
-		AC_MSG_ERROR([__sync_* atomic operations nor __gnu_cxx::__exchange_and_add are not found.
-
-If you are using gcc >= 4.1 and the default target CPU architecture is "i386", try to
-add CFLAGS="-march=i686" and CXXFLAGS="-march=i686" options to ./configure as follows:
-
-  $ ./configure CFLAGS="-march=i686" CXXFLAGS="-march=i686"
+    AC_TRY_LINK([
+        int atomic_sub(int i) { return __sync_sub_and_fetch(&i, 1); }
+        int atomic_add(int i) { return __sync_add_and_fetch(&i, 1); }
+    ], [atomic_sub(1); atomic_add(1);], msgpack_cv_atomic_ops="yes")
 ])
+if test "$msgpack_cv_atomic_ops" != "yes"; then
+    if test "$enable_cxx" = "no"; then
+        AC_MSG_ERROR([__sync_* atomic operations are not found. Try to enable C++ support.
+If you are using gcc >= 4.1 and the default target CPU architecture is "i386", try to
+add CFLAGS="-march=i686" and CXXFLAGS="-march=i686" options to ./configure as follows:
 
-	else
-		enable_gcc_cxx_atomic=yes
-	fi
+  $ ./configure CFLAGS="-march=i686" CXXFLAGS="-march=i686"
+        ])
+    fi
+
+    AC_LANG_PUSH([C++])
+    AC_CACHE_CHECK([for __gnu_cxx::__exchange_and_add], msgpack_cv_gcc_cxx_atomic_ops, [
+        AC_TRY_LINK([
+            #include <bits/atomicity.h>
+            int atomic_sub(int i) { return __gnu_cxx::__exchange_and_add(&i, -1) - 1; }
+            int atomic_add(int i) { return __gnu_cxx::__exchange_and_add(&i, 1) + 1; }
+        ], [atomic_sub(1); atomic_add(1);], msgpack_cv_gcc_cxx_atomic_ops="yes")
+    ])
+    AC_LANG_POP([C++])
+
+    if test "$msgpack_cv_gcc_cxx_atomic_ops" != "yes"; then
+        AC_MSG_ERROR([__sync_* atomic operations nor __gnu_cxx::__exchange_and_add are not found.
+
+If you are using gcc >= 4.1 and the default target CPU architecture is "i386", try to
+add CFLAGS="-march=i686" and CXXFLAGS="-march=i686" options to ./configure as follows:
+
+  $ ./configure CFLAGS="-march=i686" CXXFLAGS="-march=i686"
+        ])
+
+    else
+        enable_gcc_cxx_atomic=yes
+    fi
 fi
 
 AM_CONDITIONAL(ENABLE_GCC_CXX_ATOMIC, test "$enable_gcc_cxx_atomic" = "yes")
 
-
-major=`echo $VERSION | sed 's/\([[0-9]]*\)\.\([[0-9]]*\).*/\1/'`
-minor=`echo $VERSION | sed 's/\([[0-9]]*\)\.\([[0-9]]*\).*/\2/'`
+major=`echo $VERSION | sed 's/\([[0-9]]*\)\.\([[0-9]]*\).\([[0-9]]*\).*/\1/'`
+minor=`echo $VERSION | sed 's/\([[0-9]]*\)\.\([[0-9]]*\).\([[0-9]]*\).*/\2/'`
+revision=`echo $VERSION | sed 's/\([[0-9]]*\)\.\([[0-9]]*\).\([[0-9]]*\).*/\3/'`
 AC_SUBST(VERSION_MAJOR, $major)
 AC_SUBST(VERSION_MINOR, $minor)
+AC_SUBST(VERSION_REVISION, $revision)
 
 
 AC_OUTPUT([Makefile
-		   msgpack.pc
-		   src/Makefile
-		   src/msgpack/version.h
-		   test/Makefile])
-
+           msgpack.pc
+           src/Makefile
+           test/Makefile])

crosslang.cc

@@ -5,7 +5,7 @@
 // or
 // $ port install msgpack  # MacPorts
 //
-// $ g++ -Wall -lmsgpack crosslang.cc
+// $ g++ -Wall crosslang.cc -lmsgpack
 //
 #include <msgpack.hpp>
 #include <iostream>

erb/cpp03_define_array.hpp.erb

@@ -0,0 +1,181 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_CPP03_DEFINE_ARRAY_HPP
+#define MSGPACK_CPP03_DEFINE_ARRAY_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/msgpack_tuple.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/object_fwd.hpp"
+
+#define MSGPACK_DEFINE_ARRAY(...) \
+    template <typename Packer> \
+    void msgpack_pack(Packer& pk) const \
+    { \
+        msgpack::type::make_define_array(__VA_ARGS__).msgpack_pack(pk); \
+    } \
+    void msgpack_unpack(msgpack::object const& 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_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 { \
+  /** @cond */ \
+  MSGPACK_API_VERSION_NAMESPACE(v1) { \
+  /** @endcond */ \
+  namespace adaptor { \
+    template<> \
+    struct convert<enum_name> { \
+      msgpack::object const& operator()(msgpack::object const& o, enum_name& v) const {\
+        int tmp; \
+        o >> tmp; \
+        v = static_cast<enum_name>(tmp); \
+        return o; \
+      } \
+    }; \
+    template<> \
+    struct object<enum_name> { \
+      void operator()(msgpack::object& o, const enum_name& v) const {\
+        o << static_cast<int>(v); \
+      } \
+    }; \
+    template<> \
+    struct object_with_zone<enum_name> { \
+      void operator()(msgpack::object::with_zone& o, const enum_name& v) const { \
+        o << static_cast<int>(v); \
+      } \
+    }; \
+    template<> \
+    struct pack<enum_name> { \
+      template <typename Stream> \
+      msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const enum_name& v) const { \
+        return o << static_cast<int>(v); \
+      } \
+    }; \
+  } \
+  /** @cond */ \
+  } \
+  /** @endcond */ \
+  }
+
+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_array;
+/// @endcond
+
+template <>
+struct define_array<> {
+    typedef define_array<> value_type;
+    typedef tuple<> tuple_type;
+    template <typename Packer>
+    void msgpack_pack(Packer& pk) const
+    {
+        pk.pack_array(0);
+    }
+    void msgpack_unpack(msgpack::object const& o)
+    {
+        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+    }
+    void msgpack_object(msgpack::object* o, msgpack::zone&) const
+    {
+        o->type = msgpack::type::ARRAY;
+        o->via.array.ptr = nullptr;
+        o->via.array.size = 0;
+    }
+};
+
+/// @cond
+<%0.upto(GENERATION_LIMIT) {|i|%>
+template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
+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_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
+    {
+        pk.pack_array(<%=i+1%>);
+        <%0.upto(i) {|j|%>
+        pk.pack(a<%=j%>);<%}%>
+    }
+    void msgpack_unpack(msgpack::object const& o)
+    {
+        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+        const size_t size = o.via.array.size;
+        if(size > 0) {
+            msgpack::object *ptr = o.via.array.ptr;
+            switch(size) {
+            default:<%(i).downto(0) {|j|%>
+            case <%=j+1%>: ptr[<%=j%>].convert(a<%=j%>);<%}%>
+            }
+        }
+    }
+    void msgpack_object(msgpack::object* o, msgpack::zone& z) const
+    {
+        o->type = msgpack::type::ARRAY;
+        o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*<%=i+1%>));
+        o->via.array.size = <%=i+1%>;
+        <%0.upto(i) {|j|%>
+        o->via.array.ptr[<%=j%>] = msgpack::object(a<%=j%>, z);<%}%>
+    }
+    <%0.upto(i) {|j|%>
+    A<%=j%>& a<%=j%>;<%}%>
+};
+<%}%>
+/// @endcond
+
+inline define_array<> make_define_array()
+{
+    return define_array<>();
+}
+
+/// @cond
+<%0.upto(GENERATION_LIMIT) {|i|%>
+template <typename A0<%1.upto(i) {|j|%>, typename 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_array<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_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_msgpack_tuple.hpp.erb

@@ -0,0 +1,246 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_CPP03_MSGPACK_TUPLE_HPP
+#define MSGPACK_CPP03_MSGPACK_TUPLE_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/object.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace type {
+
+// FIXME operator==
+// FIXME operator!=
+<% GENERATION_LIMIT = 31 %>
+
+/// @cond
+template <typename A0 = void<%1.upto(GENERATION_LIMIT+1) {|i|%>, typename A<%=i%> = void<%}%>>
+struct tuple;
+/// @endcond
+
+template <typename Tuple, int N>
+struct tuple_element;
+
+template <typename Tuple, int N>
+struct const_tuple_element;
+
+template <typename T>
+struct tuple_type {
+    typedef T type;
+    typedef T value_type;
+    typedef T& reference;
+    typedef const T& const_reference;
+    typedef const T& transparent_reference;
+};
+
+template <typename T>
+struct tuple_type<T&> {
+    typedef T type;
+    typedef T& value_type;
+    typedef T& reference;
+    typedef const T& const_reference;
+    typedef T& transparent_reference;
+};
+
+template <typename T>
+struct tuple_type<const T&> {
+    typedef T type;
+    typedef T& value_type;
+    typedef T& reference;
+    typedef const T& const_reference;
+    typedef const T& transparent_reference;
+};
+
+/// @cond
+<%0.upto(GENERATION_LIMIT) {|i|%>
+<%0.upto(i) {|j|%>
+template <typename A0<%1.upto(i) {|k|%>, typename A<%=k%><%}%>>
+struct tuple_element<tuple<A0<%1.upto(i) {|k|%>, A<%=k%><%}%>>, <%=j%>> : tuple_type<A<%=j%>> {
+    tuple_element(tuple<A0<%1.upto(i) {|k|%>, A<%=k%> <%}%>>& x) : m_x(x.a<%=j%>) {}
+    typename tuple_type<A<%=j%>>::reference get() { return m_x; }
+    typename tuple_type<A<%=j%>>::const_reference get() const { return m_x; }
+private:
+    typename tuple_type<A<%=j%>>::reference m_x;
+};
+<%}%>
+<%}%>
+
+<%0.upto(GENERATION_LIMIT) {|i|%>
+<%0.upto(i) {|j|%>
+template <typename A0<%1.upto(i) {|k|%>, typename A<%=k%><%}%>>
+struct const_tuple_element<tuple<A0<%1.upto(i) {|k|%>, A<%=k%><%}%>>, <%=j%>> : tuple_type<A<%=j%>> {
+    const_tuple_element(const tuple<A0<%1.upto(i) {|k|%>, A<%=k%><%}%>>& x) : m_x(x.a<%=j%>) {}
+    typename tuple_type<A<%=j%>>::const_reference get() const { return m_x; }
+private:
+    typename tuple_type<A<%=j%>>::const_reference m_x;
+};
+<%}%>
+<%}%>
+/// @endcond
+
+template <>
+struct tuple<> {
+    tuple() {}
+    tuple(msgpack::object const& o) { o.convert(*this); }
+    typedef tuple<> value_type;
+};
+
+/// @cond
+<%0.upto(GENERATION_LIMIT) {|i|%>
+template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
+struct tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
+    typedef tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> value_type;
+    tuple() {}
+    tuple(typename tuple_type<A0>::transparent_reference _a0<%1.upto(i) {|j|%>, typename tuple_type<A<%=j%>>::transparent_reference _a<%=j%><%}%>) :
+        a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {}
+    tuple(msgpack::object const& o) { o.convert(*this); }
+    template <int N> typename tuple_element<value_type, N>::reference get()
+        { return tuple_element<value_type, N>(*this).get(); }
+    template <int N> typename const_tuple_element<value_type, N>::const_reference get() const
+        { return const_tuple_element<value_type, N>(*this).get(); }
+    <%0.upto(i) {|j|%>
+    A<%=j%> a<%=j%>;<%}%>
+};
+
+template <int N, typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
+inline typename type::tuple_element<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>, N>::reference get(type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& t)
+{ return t.template get<N>(); }
+template <int N, typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
+inline typename type::const_tuple_element<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>, N>::const_reference get(type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> const& t)
+{ return t.template get<N>(); }
+<%}%>
+/// @endcond
+
+inline tuple<> make_tuple()
+{
+    return tuple<>();
+}
+
+/// @cond
+<%0.upto(GENERATION_LIMIT) {|i|%>
+template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
+inline tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_tuple(typename tuple_type<A0>::transparent_reference a0<%1.upto(i) {|j|%>, typename tuple_type<A<%=j%>>::transparent_reference a<%=j%><%}%>)
+{
+    return tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>);
+}
+<%}%>
+/// @endcond
+
+}  // namespace type
+
+namespace adaptor {
+
+template <>
+struct convert<type::tuple<> > {
+    msgpack::object const& operator()(
+        msgpack::object const& o,
+        type::tuple<>&) const {
+        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+        return o;
+    }
+};
+
+/// @cond
+<%0.upto(GENERATION_LIMIT) {|i|%>
+template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
+struct convert<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> > {
+    msgpack::object const& operator()(
+        msgpack::object const& o,
+        type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) const {
+        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+        if(o.via.array.size < <%=i+1%>) { throw msgpack::type_error(); }
+        <%0.upto(i) {|j|%>
+        // In order to avoid clang++'s invalid warning, msgpack::object:: has been added.
+        o.via.array.ptr[<%=j%>].msgpack::object::convert<typename type::tuple_type<A<%=j%>>::type>(v.template get<<%=j%>>());<%}%>
+        return o;
+    }
+};
+<%}%>
+/// @endcond
+
+template <>
+struct pack<type::tuple<> > {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(
+        msgpack::packer<Stream>& o,
+        const type::tuple<>&) const {
+        o.pack_array(0);
+        return o;
+    }
+};
+
+/// @cond
+<%0.upto(GENERATION_LIMIT) {|i|%>
+template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
+struct pack<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> > {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(
+        msgpack::packer<Stream>& o,
+        const type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) const {
+        o.pack_array(<%=i+1%>);
+        <%0.upto(i) {|j|%>
+        o.pack(v.template get<<%=j%>>());<%}%>
+        return o;
+    }
+};
+<%}%>
+/// @endcond
+
+template <>
+struct object_with_zone<type::tuple<> > {
+    void operator()(
+        msgpack::object::with_zone& o,
+        const type::tuple<>&) const {
+        o.type = msgpack::type::ARRAY;
+        o.via.array.ptr = nullptr;
+        o.via.array.size = 0;
+    }
+};
+
+/// @cond
+<%0.upto(GENERATION_LIMIT) {|i|%>
+template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
+struct object_with_zone<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> > {
+    void operator()(
+        msgpack::object::with_zone& o,
+        const type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) const {
+        o.type = msgpack::type::ARRAY;
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*<%=i+1%>));
+        o.via.array.size = <%=i+1%>;
+        <%0.upto(i) {|j|%>
+        o.via.array.ptr[<%=j%>] = msgpack::object(v.template get<<%=j%>>(), o.zone);<%}%>
+    }
+};
+<%}%>
+/// @endcond
+
+} // namespace adaptor
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+}  // namespace msgpack
+
+#endif // MSGPACK_CPP03_MSGPACK_TUPLE_HPP

erb/cpp03_zone.hpp.erb

@@ -0,0 +1,346 @@
+//
+// MessagePack for C++ memory pool
+//
+// Copyright (C) 2008-2010 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_CPP03_ZONE_HPP
+#define MSGPACK_CPP03_ZONE_HPP
+
+#include <cstdlib>
+#include <memory>
+#include <vector>
+
+#include "msgpack/versioning.hpp"
+
+#ifndef MSGPACK_ZONE_CHUNK_SIZE
+#define MSGPACK_ZONE_CHUNK_SIZE 8192
+#endif
+
+#ifndef MSGPACK_ZONE_ALIGN
+#define MSGPACK_ZONE_ALIGN sizeof(void*)
+#endif
+
+<% GENERATION_LIMIT = 15 %>
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+class zone {
+    struct finalizer {
+        finalizer(void (*func)(void*), void* data):m_func(func), m_data(data) {}
+        void operator()() { m_func(m_data); }
+        void (*m_func)(void*);
+        void* m_data;
+    };
+    struct finalizer_array {
+        finalizer_array():m_tail(nullptr), m_end(nullptr), m_array(nullptr) {}
+        void call() {
+            finalizer* fin = m_tail;
+            for(; fin != m_array; --fin) (*(fin-1))();
+        }
+        ~finalizer_array() {
+            call();
+            ::free(m_array);
+        }
+        void clear() {
+            call();
+            m_tail = m_array;
+        }
+        void push(void (*func)(void* data), void* data)
+        {
+            finalizer* fin = m_tail;
+
+            if(fin == m_end) {
+                push_expand(func, data);
+                return;
+            }
+
+            fin->m_func = func;
+            fin->m_data = data;
+
+            ++m_tail;
+        }
+        void push_expand(void (*func)(void*), void* data) {
+            const size_t nused = m_end - m_array;
+            size_t nnext;
+            if(nused == 0) {
+                nnext = (sizeof(finalizer) < 72/2) ?
+                    72 / sizeof(finalizer) : 8;
+            } else {
+                nnext = nused * 2;
+            }
+            finalizer* tmp =
+                static_cast<finalizer*>(::realloc(m_array, sizeof(finalizer) * nnext));
+            if(!tmp) {
+                throw std::bad_alloc();
+            }
+            m_array     = tmp;
+            m_end   = tmp + nnext;
+            m_tail  = tmp + nused;
+            new (m_tail) finalizer(func, data);
+
+            ++m_tail;
+        }
+        finalizer* m_tail;
+        finalizer* m_end;
+        finalizer* m_array;
+    };
+    struct chunk {
+        chunk* m_next;
+    };
+    struct chunk_list {
+        chunk_list(size_t chunk_size)
+        {
+            chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + chunk_size));
+            if(!c) {
+                throw std::bad_alloc();
+            }
+
+            m_head = c;
+            m_free = chunk_size;
+            m_ptr  = reinterpret_cast<char*>(c) + sizeof(chunk);
+            c->m_next = nullptr;
+        }
+        ~chunk_list()
+        {
+            chunk* c = m_head;
+            while(c) {
+                chunk* n = c->m_next;
+                ::free(c);
+                c = n;
+            }
+        }
+        void clear(size_t chunk_size)
+        {
+            chunk* c = m_head;
+            while(true) {
+                chunk* n = c->m_next;
+                if(n) {
+                    ::free(c);
+                    c = n;
+                } else {
+                    break;
+                }
+            }
+            m_head->m_next = nullptr;
+            m_free = chunk_size;
+            m_ptr  = reinterpret_cast<char*>(m_head) + sizeof(chunk);
+        }
+        size_t m_free;
+        char* m_ptr;
+        chunk* m_head;
+    };
+    size_t m_chunk_size;
+    chunk_list m_chunk_list;
+    finalizer_array m_finalizer_array;
+
+public:
+    zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE) /* throw() */;
+
+public:
+    void* allocate_align(size_t size, size_t align = MSGPACK_ZONE_ALIGN);
+    void* allocate_no_align(size_t size);
+
+    void push_finalizer(void (*func)(void*), void* data);
+
+    template <typename T>
+    void push_finalizer(msgpack::unique_ptr<T> obj);
+
+    void clear();
+
+    void swap(zone& o);
+    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() */
+    {
+        ::free(p);
+    }
+    static void* operator new(std::size_t size, void* place) /* throw() */
+    {
+        return ::operator new(size, place);
+    }
+    static void operator delete(void* p, void* place) /* throw() */
+    {
+        ::operator delete(p, place);
+    }
+    /// @cond
+    <%0.upto(GENERATION_LIMIT) {|i|%>
+    template <typename T<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
+    T* allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>);
+    <%}%>
+    /// @endcond
+
+private:
+    void undo_allocate(size_t size);
+
+    template <typename T>
+    static void object_destruct(void* obj);
+
+    template <typename T>
+    static void object_delete(void* obj);
+
+    void* allocate_expand(size_t size);
+private:
+    zone(const zone&);
+    zone& operator=(const zone&);
+};
+
+inline zone::zone(size_t chunk_size) /* throw() */ :m_chunk_size(chunk_size), m_chunk_list(m_chunk_size)
+{
+}
+
+inline void* zone::allocate_align(size_t size, size_t align)
+{
+    char* aligned =
+        reinterpret_cast<char*>(
+            reinterpret_cast<size_t>(
+                (m_chunk_list.m_ptr + (align - 1))) / align * align);
+    size_t adjusted_size = size + (aligned - m_chunk_list.m_ptr);
+    if(m_chunk_list.m_free >= adjusted_size) {
+        m_chunk_list.m_free -= adjusted_size;
+        m_chunk_list.m_ptr  += adjusted_size;
+        return aligned;
+    }
+    return reinterpret_cast<char*>(
+        reinterpret_cast<size_t>(
+            allocate_expand(size + (align - 1))) / align * align);
+}
+
+inline void* zone::allocate_no_align(size_t size)
+{
+    if(m_chunk_list.m_free < size) {
+        return allocate_expand(size);
+    }
+
+    char* ptr = m_chunk_list.m_ptr;
+    m_chunk_list.m_free -= size;
+    m_chunk_list.m_ptr  += size;
+
+    return ptr;
+}
+
+inline void* zone::allocate_expand(size_t size)
+{
+    chunk_list* const cl = &m_chunk_list;
+
+    size_t sz = m_chunk_size;
+
+    while(sz < size) {
+        size_t tmp_sz = sz * 2;
+        if (tmp_sz <= sz) {
+            sz = size;
+            break;
+        }
+        sz = tmp_sz;
+    }
+
+    chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + sz));
+    if (!c) throw std::bad_alloc();
+
+    char* ptr = reinterpret_cast<char*>(c) + sizeof(chunk);
+
+    c->m_next  = cl->m_head;
+    cl->m_head = c;
+    cl->m_free = sz - size;
+    cl->m_ptr  = ptr + size;
+
+    return ptr;
+}
+
+inline void zone::push_finalizer(void (*func)(void*), void* data)
+{
+    m_finalizer_array.push(func, data);
+}
+
+template <typename T>
+inline void zone::push_finalizer(msgpack::unique_ptr<T> obj)
+{
+    m_finalizer_array.push(&zone::object_delete<T>, obj.release());
+}
+
+inline void zone::clear()
+{
+    m_finalizer_array.clear();
+    m_chunk_list.clear(m_chunk_size);
+}
+
+inline void zone::swap(zone& o)
+{
+    using std::swap;
+    swap(m_chunk_size, o.m_chunk_size);
+    swap(m_chunk_list, o.m_chunk_list);
+    swap(m_finalizer_array, o.m_finalizer_array);
+}
+
+template <typename T>
+void zone::object_destruct(void* obj)
+{
+    static_cast<T*>(obj)->~T();
+}
+
+template <typename T>
+void zone::object_delete(void* obj)
+{
+    delete static_cast<T*>(obj);
+}
+
+inline void zone::undo_allocate(size_t size)
+{
+    m_chunk_list.m_ptr  -= 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%><%}%>>
+T* zone::allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>)
+{
+    void* x = allocate_align(sizeof(T));
+    try {
+        m_finalizer_array.push(&zone::object_destruct<T>, x);
+    } catch (...) {
+        undo_allocate(sizeof(T));
+        throw;
+    }
+    try {
+        return new (x) T(<%=(1..i).map{|j|"a#{j}"}.join(', ')%>);
+    } catch (...) {
+        --m_finalizer_array.m_tail;
+        undo_allocate(sizeof(T));
+        throw;
+    }
+}
+<%}%>
+/// @endcond
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+}  // namespace msgpack
+
+#endif // MSGPACK_CPP03_ZONE_HPP

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

@@ -0,0 +1,122 @@
+#include <msgpack.h>
+#include <stdio.h>
+#include <assert.h>
+
+
+typedef struct receiver {
+    msgpack_sbuffer sbuf;
+    size_t rest;
+} receiver;
+
+void receiver_init(receiver *r) {
+    msgpack_packer pk;
+
+    msgpack_sbuffer_init(&r->sbuf);
+    msgpack_packer_init(&pk, &r->sbuf, msgpack_sbuffer_write);
+    /* 1st object */
+    msgpack_pack_array(&pk, 3);
+    msgpack_pack_int(&pk, 1);
+    msgpack_pack_true(&pk);
+    msgpack_pack_str(&pk, 7);
+    msgpack_pack_str_body(&pk, "example", 7);
+    /* 2nd object */
+    msgpack_pack_str(&pk, 6);
+    msgpack_pack_str_body(&pk, "second", 6);
+    /* 3rd object */
+    msgpack_pack_array(&pk, 2);
+    msgpack_pack_int(&pk, 42);
+    msgpack_pack_false(&pk);
+    r->rest = r->sbuf.size;
+}
+
+size_t receiver_recv(receiver *r, char* buf, size_t try_size) {
+    size_t off = r->sbuf.size - r->rest;
+
+    size_t actual_size = try_size;
+    if (actual_size > r->rest) actual_size = r->rest;
+
+    memcpy(buf, r->sbuf.data + off, actual_size);
+    r->rest -= actual_size;
+
+    return actual_size;
+}
+
+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) {
+    /* buf is allocated by unpacker. */
+    msgpack_unpacker* unp = msgpack_unpacker_new(100);
+    msgpack_unpacked result;
+    msgpack_unpack_return ret;
+    size_t recv_len;
+    int recv_count = 0;
+    int i = 0;
+
+    msgpack_unpacked_init(&result);
+    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) {
+            msgpack_object obj = result.data;
+
+            /* Use obj. */
+            printf("Object no %d:\n", ++i);
+            msgpack_object_print(stdout, obj);
+            printf("\n");
+            /* If you want to allocate something on the zone, you can use zone. */
+            /* msgpack_zone* zone = result.zone; */
+            /* The lifetime of the obj and the zone,  */
+
+            ret = msgpack_unpacker_next(unp, &result);
+        }
+        if (ret == MSGPACK_UNPACK_PARSE_ERROR) {
+            printf("The data in the buf is invalid format.\n");
+            msgpack_unpacked_destroy(&result);
+            return;
+        }
+    }
+    msgpack_unpacked_destroy(&result);
+    msgpack_unpacker_free(unp);
+}
+
+int main(void) {
+    receiver r;
+    receiver_init(&r);
+
+    unpack(&r);
+
+    return 0;
+}
+
+/* Output */
+
+/*
+receive count: 0 4 bytes received.
+receive count: 1 4 bytes received.
+receive count: 2 4 bytes received.
+Object no 1:
+[1, true, "example"]
+receive count: 3 4 bytes received.
+receive count: 4 4 bytes received.
+Object no 2:
+"second"
+receive count: 5 1 bytes received.
+Object no 3:
+[42, false]
+*/

example/c/simple_c.c

@@ -0,0 +1,47 @@
+#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;
+    msgpack_packer pk;
+    msgpack_zone mempool;
+    msgpack_object deserialized;
+
+    /* msgpack::sbuffer is a simple buffer implementation. */
+    msgpack_sbuffer_init(&sbuf);
+
+    /* serialize values into the buffer using msgpack_sbuffer_write callback function. */
+    msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
+
+    msgpack_pack_array(&pk, 3);
+    msgpack_pack_int(&pk, 1);
+    msgpack_pack_true(&pk);
+    msgpack_pack_str(&pk, 7);
+    msgpack_pack_str_body(&pk, "example", 7);
+
+    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);
+
+    msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
+
+    /* print the deserialized object. */
+    msgpack_object_print(stdout, deserialized);
+    puts("");
+
+    msgpack_zone_destroy(&mempool);
+    msgpack_sbuffer_destroy(&sbuf);
+
+    return 0;
+}

example/c/speed_test_uint32_array.c

@@ -0,0 +1,36 @@
+#include <msgpack.h>
+
+void test()
+{
+    size_t size = 10000000;
+    msgpack_sbuffer buf;
+    msgpack_packer * pk;
+    size_t upk_pos = 0;
+    msgpack_unpacked msg;
+
+    msgpack_sbuffer_init(&buf);
+
+    pk = msgpack_packer_new(&buf, msgpack_sbuffer_write);
+
+    msgpack_pack_array(pk, size);
+    {
+        size_t idx = 0;
+        for (; idx < size; ++idx)
+            msgpack_pack_uint32(pk, 1);
+    }
+    msgpack_packer_free(pk);
+
+    msgpack_unpacked_init(&msg);
+
+    while (msgpack_unpack_next(&msg, buf.data, buf.size, &upk_pos)) {
+    }
+
+    msgpack_sbuffer_destroy(&buf);
+}
+
+int main(void)
+{
+    int i = 0;
+    for (; i < 10; ++i) test();
+    return 0;
+}

example/c/speed_test_uint64_array.c

@@ -0,0 +1,37 @@
+#include <msgpack.h>
+
+void test()
+{
+    uint64_t test_u64 = 0xFFF0000000000001LL;
+    size_t size = 10000000;
+    msgpack_sbuffer buf;
+    msgpack_packer * pk;
+    size_t upk_pos = 0;
+    msgpack_unpacked msg;
+
+    msgpack_sbuffer_init(&buf);
+
+    pk = msgpack_packer_new(&buf, msgpack_sbuffer_write);
+
+    msgpack_pack_array(pk, size);
+    {
+        size_t idx = 0;
+        for (; idx < size; ++idx)
+            msgpack_pack_uint64(pk, test_u64);
+    }
+    msgpack_packer_free(pk);
+
+    msgpack_unpacked_init(&msg);
+
+    while (msgpack_unpack_next(&msg, buf.data, buf.size, &upk_pos)) {
+    }
+
+    msgpack_sbuffer_destroy(&buf);
+}
+
+int main(void)
+{
+    int i = 0;
+    for (; i < 10; ++i) test();
+    return 0;
+}

example/c/user_buffer_unpack.c

@@ -0,0 +1,76 @@
+#include <msgpack.h>
+#include <stdio.h>
+#include <assert.h>
+
+void prepare(msgpack_sbuffer* sbuf) {
+    msgpack_packer pk;
+
+    msgpack_packer_init(&pk, sbuf, msgpack_sbuffer_write);
+    /* 1st object */
+    msgpack_pack_array(&pk, 3);
+    msgpack_pack_int(&pk, 1);
+    msgpack_pack_true(&pk);
+    msgpack_pack_str(&pk, 7);
+    msgpack_pack_str_body(&pk, "example", 7);
+    /* 2nd object */
+    msgpack_pack_str(&pk, 6);
+    msgpack_pack_str_body(&pk, "second", 6);
+    /* 3rd object */
+    msgpack_pack_array(&pk, 2);
+    msgpack_pack_int(&pk, 42);
+    msgpack_pack_false(&pk);
+}
+
+void unpack(char const* buf, size_t len) {
+    /* buf is allocated by client. */
+    msgpack_unpacked result;
+    size_t off = 0;
+    msgpack_unpack_return ret;
+    int i = 0;
+    msgpack_unpacked_init(&result);
+    ret = msgpack_unpack_next(&result, buf, len, &off);
+    while (ret == MSGPACK_UNPACK_SUCCESS) {
+        msgpack_object obj = result.data;
+
+        /* Use obj. */
+        printf("Object no %d:\n", ++i);
+        msgpack_object_print(stdout, obj);
+        printf("\n");
+        /* If you want to allocate something on the zone, you can use zone. */
+        /* msgpack_zone* zone = result.zone; */
+        /* The lifetime of the obj and the zone,  */
+
+        ret = msgpack_unpack_next(&result, buf, len, &off);
+    }
+    msgpack_unpacked_destroy(&result);
+
+    if (ret == MSGPACK_UNPACK_CONTINUE) {
+        printf("All msgpack_object in the buffer is consumed.\n");
+    }
+    else if (ret == MSGPACK_UNPACK_PARSE_ERROR) {
+        printf("The data in the buf is invalid format.\n");
+    }
+}
+
+int main(void) {
+    msgpack_sbuffer sbuf;
+    msgpack_sbuffer_init(&sbuf);
+
+    prepare(&sbuf);
+    unpack(sbuf.data, sbuf.size);
+
+    msgpack_sbuffer_destroy(&sbuf);
+    return 0;
+}
+
+/* Output */
+
+/*
+Object no 1:
+[1, true, "example"]
+Object no 2:
+"second"
+Object no 3:
+[42, false]
+All msgpack_object in the buffer is consumed.
+*/

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

@@ -0,0 +1,111 @@
+// MessagePack for C++ example
+//
+// 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.
+//
+
+#include <string>
+#include <iostream>
+#include <iomanip>
+#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;
+}
+
+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
+            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:
+    std::string name_;
+    int age_;
+
+public:
+    MSGPACK_DEFINE(name_, age_, MSGPACK_BASE(my_base1), MSGPACK_BASE(my_base2));
+};
+
+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);
+        my.a = 123;
+        my.set_b("ABC");
+        my.set_c("DEF");
+        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);
+        my.a = 123;
+        my.set_b("ABC");
+        my.set_c("DEF");
+        msgpack::zone z;
+        msgpack::object obj(my, z);
+        std::cout << obj << std::endl;
+        assert(obj.as<my_class>() == my);
+    }
+}

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/class_non_intrusive.cpp

@@ -0,0 +1,126 @@
+// MessagePack for C++ example
+//
+// 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.
+//
+
+#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.
+    my_class(std::string const& name, int age):name_(name), age_(age) {}
+
+    // my_class should provide getters for the data members you want to pack.
+    std::string const& get_name() const { return name_; }
+    int get_age() const { return 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_;
+};
+
+// User defined class template specialization
+namespace msgpack {
+MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) {
+namespace adaptor {
+
+template<>
+struct convert<my_class> {
+    msgpack::object const& operator()(msgpack::object const& o, my_class& v) const {
+        if (o.type != msgpack::type::ARRAY) throw msgpack::type_error();
+        if (o.via.array.size != 2) throw msgpack::type_error();
+        v = my_class(
+            o.via.array.ptr[0].as<std::string>(),
+            o.via.array.ptr[1].as<int>());
+        return o;
+    }
+};
+
+template<>
+struct pack<my_class> {
+    template <typename Stream>
+    packer<Stream>& operator()(msgpack::packer<Stream>& o, my_class const& v) const {
+        // packing member variables as an array.
+        o.pack_array(2);
+        o.pack(v.get_name());
+        o.pack(v.get_age());
+        return o;
+    }
+};
+
+template <>
+struct object_with_zone<my_class> {
+    void operator()(msgpack::object::with_zone& o, my_class const& v) const {
+        o.type = type::ARRAY;
+        o.via.array.size = 2;
+        o.via.array.ptr = static_cast<msgpack::object*>(
+            o.zone.allocate_align(sizeof(msgpack::object) * o.via.array.size));
+        o.via.array.ptr[0] = msgpack::object(v.get_name(), o.zone);
+        o.via.array.ptr[1] = msgpack::object(v.get_age(), o.zone);
+    }
+};
+
+} // namespace adaptor
+} // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
+} // namespace msgpack
+
+
+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/custom.cpp

@@ -0,0 +1,75 @@
+// MessagePack for C++ example
+//
+// 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.
+//
+
+#include <msgpack.hpp>
+#include <sstream>
+#include <string>
+#include <iostream>
+
+class old_class {
+public:
+    old_class() : value("default") { }
+
+    std::string value;
+
+    MSGPACK_DEFINE(value);
+};
+
+class new_class {
+public:
+    new_class() : value("default"), flag(-1) { }
+
+    std::string value;
+    int flag;
+
+    MSGPACK_DEFINE(value, flag);
+};
+
+int main(void)
+{
+    {
+        old_class oc;
+        new_class nc;
+
+        std::stringstream sbuf;
+        msgpack::pack(sbuf, oc);
+
+        msgpack::unpacked result;
+        msgpack::unpack(result, sbuf.str().data(), sbuf.str().size());
+        msgpack::object obj = result.get();
+
+        obj.convert(&nc);
+
+        std::cout << obj << " value=" << nc.value << " flag=" << nc.flag << std::endl;
+    }
+
+    {
+        new_class nc;
+        old_class oc;
+
+        std::stringstream sbuf;
+        msgpack::pack(sbuf, nc);
+
+        msgpack::unpacked result;
+        msgpack::unpack(result, sbuf.str().data(), sbuf.str().size());
+        msgpack::object obj = result.get();
+
+        obj.convert(&oc);
+
+        std::cout << obj << " value=" << oc.value << std::endl;
+    }
+}

example/cpp03/enum.cpp

@@ -0,0 +1,67 @@
+// 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 <sstream>
+#include <iostream>
+#include <cassert>
+
+#include <msgpack.hpp>
+
+enum my_enum {
+    elem1,
+    elem2,
+    elem3
+};
+
+MSGPACK_ADD_ENUM(my_enum);
+
+int main(void)
+{
+    {   // pack, unpack
+        std::stringstream sbuf;
+        msgpack::pack(sbuf, elem1);
+        msgpack::pack(sbuf, elem2);
+        my_enum e3 = elem3;
+        msgpack::pack(sbuf, e3);
+
+        msgpack::unpacked result;
+        std::size_t off = 0;
+
+        msgpack::unpack(result, sbuf.str().data(), sbuf.str().size(), off);
+        std::cout << result.get().as<my_enum>() << std::endl;
+        assert(result.get().as<my_enum>() == elem1);
+
+        msgpack::unpack(result, sbuf.str().data(), sbuf.str().size(), off);
+        std::cout << result.get().as<my_enum>() << std::endl;
+        assert(result.get().as<my_enum>() == elem2);
+
+        msgpack::unpack(result, sbuf.str().data(), sbuf.str().size(), off);
+        std::cout << result.get().as<my_enum>() << std::endl;
+        assert(result.get().as<my_enum>() == elem3);
+    }
+    {   // create object without zone
+        msgpack::object obj(elem2);
+        std::cout << obj.as<my_enum>() << std::endl;
+        assert(obj.as<my_enum>() == elem2);
+    }
+    {   // create object with zone
+        msgpack::zone z;
+        msgpack::object objz(elem3, z);
+        std::cout << objz.as<my_enum>() << std::endl;
+        assert(objz.as<my_enum>() == elem3);
+    }
+}

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.cpp

@@ -0,0 +1,105 @@
+// MessagePack for C++ example
+//
+// 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.
+//
+
+#include <msgpack.hpp>
+#include <string>
+#include <iostream>
+#include <sstream>
+
+// This example uses obsolete APIs
+// See protocol_new.cpp
+namespace myprotocol {
+    using namespace msgpack::type;
+    using msgpack::define;
+
+    struct Get : define< tuple<uint32_t, std::string> > {
+        Get() { }
+        Get(uint32_t f, const std::string& k) :
+            define_type(msgpack_type(f, k)) { }
+        uint32_t&    flags() { return msgpack::type::get<0>(*this); }
+        std::string& key()   { return msgpack::type::get<1>(*this); }
+    };
+
+    struct Put : define< tuple<uint32_t, std::string, raw_ref> > {
+        Put() { }
+        Put(uint32_t f, const std::string& k, const char* valref, uint32_t vallen) :
+            define_type(msgpack_type( f, k, raw_ref(valref,vallen) )) { }
+        uint32_t&    flags() { return msgpack::type::get<0>(*this); }
+        std::string& key()   { return msgpack::type::get<1>(*this); }
+        raw_ref&     value() { return msgpack::type::get<2>(*this); }
+    };
+
+    struct MultiGet : define< std::vector<Get> > {
+    };
+}
+
+
+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/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

@@ -0,0 +1,50 @@
+// 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 <iostream>
+#include <sstream>
+#include <cassert>
+
+#include <string>
+#include <vector>
+
+#include <msgpack.hpp>
+
+
+int main() {
+    std::vector<int> v;
+    v.push_back(1);
+    v.push_back(42);
+    std::string s("ABC");
+
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+    msgpack::pack(ss, s);
+
+    msgpack::zone z;
+    std::size_t offset = 0;
+
+    // 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.
+    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/simple.cpp

@@ -0,0 +1,54 @@
+// MessagePack for C++ example
+//
+// 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.
+//
+
+#include <msgpack.hpp>
+#include <string>
+#include <iostream>
+#include <sstream>
+
+int main(void)
+{
+    msgpack::type::tuple<int, bool, std::string> src(1, true, "example");
+
+    // serialize the object into the buffer.
+    // any classes that implements write(const char*,size_t) can be a buffer.
+    std::stringstream buffer;
+    msgpack::pack(buffer, src);
+
+    // send the buffer ...
+    buffer.seekg(0);
+
+    // deserialize the buffer into msgpack::object instance.
+    std::string str(buffer.str());
+
+    msgpack::unpacked result;
+
+    msgpack::unpack(result, str.data(), str.size());
+
+    // deserialized object is valid during the msgpack::unpacked instance alive.
+    msgpack::object deserialized = result.get();
+
+    // msgpack::object supports ostream.
+    std::cout << deserialized << std::endl;
+
+    // convert msgpack::object instance into the original type.
+    // if the type is mismatched, it throws msgpack::type_error exception.
+    msgpack::type::tuple<int, bool, std::string> dst;
+    deserialized.convert(&dst);
+
+    return 0;
+}

example/cpp03/speed_test.cpp

@@ -0,0 +1,71 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2013-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.
+//
+
+// g++ -std=c++11 -O3 -g -Ipath_to_msgpack_src -Ipath_to_boost speed_test.cc -Lpath_to_boost_lib -lboost_timer -lboost_system
+// export LD_LIBRARY_PATH=path_to_boost_lib
+
+#include <msgpack.hpp>
+#include <string>
+#include <iostream>
+#include <sstream>
+#include <map>
+#include <boost/timer/timer.hpp>
+
+void test_map_pack_unpack() {
+    std::cout << "[TEST][map_pack_unpack]" << std::endl;
+    // setup
+    std::cout << "Setting up map data..." << std::endl;
+    std::map<int, int> m1;
+    int const num = 30000000L;
+    for (int i = 0; i < num; ++i) m1[i] = i;
+    std::cout << "Start packing..." << std::endl;
+    std::stringstream buffer;
+    {
+        boost::timer::cpu_timer timer;
+        msgpack::pack(buffer, m1);
+        std::string result = timer.format();
+        std::cout << result << std::endl;
+    }
+    std::cout << "Pack finished..." << std::endl;
+
+    buffer.seekg(0);
+    std::string str(buffer.str());
+
+    msgpack::unpacked unpacked;
+    std::cout << "Start unpacking...by void unpack(unpacked& result, const char* data, size_t len)" << std::endl;
+    {
+        boost::timer::cpu_timer timer;
+        msgpack::unpack(unpacked, str.data(), str.size());
+        std::string result = timer.format();
+        std::cout << result << std::endl;
+    }
+    std::cout << "Unpack finished..." << std::endl;
+    std::map<int, int> m2;
+    std::cout << "Start converting..." << std::endl;
+    {
+        boost::timer::cpu_timer timer;
+        unpacked.get().convert(&m2);
+        std::string result = timer.format();
+        std::cout << result << std::endl;
+    }
+    std::cout << "Convert finished..." << std::endl;
+}
+
+int main(void)
+{
+    test_map_pack_unpack();
+}

example/cpp03/speed_test_nested_array.cpp

@@ -0,0 +1,94 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2013-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.
+//
+
+// g++ -std=c++11 -O3 -g -Ipath_to_msgpack_src -Ipath_to_boost speed_test.cc -Lpath_to_boost_lib -lboost_timer -lboost_system
+// export LD_LIBRARY_PATH=path_to_boost_lib
+
+#include <msgpack.hpp>
+#include <string>
+#include <iostream>
+#include <sstream>
+#include <vector>
+#include <boost/timer/timer.hpp>
+
+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 (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);
+        }
+    }
+};
+
+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 (std::size_t elem = 0; elem < num_of_elems; ++elem) {
+            v.push_back(val);
+        }
+    }
+};
+
+void test_array_of_array() {
+    std::cout << "[TEST][array_of_array]" << std::endl;
+    // setup
+    int const depth = 4;
+    std::cout << "Setting up array data..." << std::endl;
+    vecvec<int, depth>::type v1;
+    vecvec<int, depth>::fill(v1, 3, 42);
+
+    std::cout << "Start packing..." << std::endl;
+    std::stringstream buffer;
+    {
+        boost::timer::cpu_timer timer;
+        msgpack::pack(buffer, v1);
+        std::string result = timer.format();
+        std::cout << result << std::endl;
+    }
+    std::cout << "Pack finished..." << std::endl;
+
+    buffer.seekg(0);
+    std::string str(buffer.str());
+
+    msgpack::unpacked unpacked;
+    std::cout << "Start unpacking...by void unpack(unpacked& result, const char* data, size_t len)" << std::endl;
+    {
+        boost::timer::cpu_timer timer;
+        msgpack::unpack(unpacked, str.data(), str.size());
+        std::string result = timer.format();
+        std::cout << result << std::endl;
+    }
+    std::cout << "Unpack finished..." << std::endl;
+    vecvec<int, depth>::type v2;
+    std::cout << "Start converting..." << std::endl;
+    {
+        boost::timer::cpu_timer timer;
+        unpacked.get().convert(&v2);
+        std::string result = timer.format();
+        std::cout << result << std::endl;
+    }
+    std::cout << "Convert finished..." << std::endl;
+}
+
+int main(void)
+{
+    test_array_of_array();
+}

example/cpp03/stream.cpp

@@ -0,0 +1,150 @@
+// MessagePack for C++ example
+//
+// 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.
+//
+
+#include <msgpack.hpp>
+#include <iostream>
+#include <stdexcept>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <pthread.h>
+
+class Server {
+public:
+    Server(int sock) : m_sock(sock) { }
+
+    ~Server() { }
+
+    typedef msgpack::unique_ptr<msgpack::zone> unique_zone;
+
+    void socket_readable()
+    {
+        m_pac.reserve_buffer(1024);
+
+        ssize_t count =
+            read(m_sock, m_pac.buffer(), m_pac.buffer_capacity());
+
+        if(count <= 0) {
+            if(count == 0) {
+                throw std::runtime_error("connection closed");
+            }
+            if(errno == EAGAIN || errno == EINTR) {
+                return;
+            }
+            throw std::runtime_error(strerror(errno));
+        }
+
+        m_pac.buffer_consumed(count);
+
+        msgpack::unpacked result;
+        while (m_pac.next(&result)) {
+            msgpack::object msg = result.get();
+            unique_zone& life = result.zone();
+            process_message(msg, life);
+        }
+
+        if(m_pac.message_size() > 10*1024*1024) {
+            throw std::runtime_error("message is too large");
+        }
+    }
+
+private:
+    void process_message(msgpack::object msg, unique_zone&)
+    {
+        std::cout << "message reached: " << msg << std::endl;
+    }
+
+private:
+    int m_sock;
+    msgpack::unpacker m_pac;
+};
+
+
+static void* run_server(void* arg)
+{
+    try {
+        Server* srv = reinterpret_cast<Server*>(arg);
+
+        while(true) {
+            srv->socket_readable();
+        }
+        return NULL;
+
+    } catch (std::exception& e) {
+        std::cerr << "error while processing client packet: "
+                  << e.what() << std::endl;
+        return NULL;
+
+    } catch (...) {
+        std::cerr << "error while processing client packet: "
+                  << "unknown error" << std::endl;
+        return NULL;
+    }
+}
+
+struct fwriter {
+    fwriter(int fd) : m_fp( fdopen(fd, "w") ) { }
+
+    void write(const char* buf, size_t buflen)
+    {
+        size_t count = fwrite(buf, buflen, 1, m_fp);
+        if(count < 1) {
+            std::cout << buflen << std::endl;
+            std::cout << count << std::endl;
+            throw std::runtime_error(strerror(errno));
+        }
+    }
+
+    void flush() { fflush(m_fp); }
+
+    void close() { fclose(m_fp); }
+
+private:
+    FILE* m_fp;
+};
+
+
+int main(void)
+{
+    int pair[2];
+    if (pipe(pair) != 0) return -1;
+
+    // run server thread
+    Server srv(pair[0]);
+    pthread_t thread;
+    pthread_create(&thread, NULL,
+            run_server, reinterpret_cast<void*>(&srv));
+
+    // client thread:
+    fwriter writer(pair[1]);
+    msgpack::packer<fwriter> pk(writer);
+
+    typedef msgpack::type::tuple<std::string, std::string, std::string> put_t;
+    typedef msgpack::type::tuple<std::string, std::string> get_t;
+
+    put_t req1("put", "apple", "red");
+    put_t req2("put", "lemon", "yellow");
+    get_t req3("get", "apple");
+    pk.pack(req1);
+    pk.pack(req2);
+    pk.pack(req3);
+    writer.flush();
+    writer.close();
+
+    pthread_join(thread, NULL);
+}

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

@@ -0,0 +1,157 @@
+// 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 <iostream>
+#include <sstream>
+#include <cassert>
+
+#include <array>
+#include <tuple>
+#include <unordered_map>
+#include <unordered_set>
+#include <forward_list>
+#include <string>
+
+#include <msgpack.hpp>
+
+void array() {
+    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::cout << obj << std::endl;
+    assert((obj.as<std::array<int, 5>>()) == a);
+}
+
+void tuple() {
+    std::tuple<bool, std::string, int> t(true, "ABC", 42);
+    std::stringstream ss;
+    msgpack::pack(ss, t);
+
+    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);
+}
+
+void unordered_map() {
+    std::unordered_map<std::string, int> m { {"ABC", 1}, {"DEF", 3} };
+    std::stringstream ss;
+    msgpack::pack(ss, m);
+
+    auto und = msgpack::unpack(ss.str().data(), ss.str().size());
+    msgpack::object obj = und.get();
+
+    std::cout << obj << std::endl;
+    assert(obj.as<decltype(m)>() == m);
+}
+
+void unordered_set() {
+    std::unordered_set<std::string> s { "ABC", "DEF" };
+    std::stringstream ss;
+    msgpack::pack(ss, 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() {
+    using type = std::forward_list<std::string>;
+    type f { "ABC", "DEF" };
+    std::stringstream ss;
+    msgpack::pack(ss, 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::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" };
+    std::forward_list<std::string>       f { "ABC", "DEF" };
+
+    std::stringstream ss;
+    msgpack::pack(ss, a);
+    msgpack::pack(ss, t);
+    msgpack::pack(ss, m);
+    msgpack::pack(ss, s);
+    msgpack::pack(ss, f);
+
+    std::size_t offset = 0;
+    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() {
+    array();
+    tuple();
+    unordered_map();
+    unordered_set();
+    forward_list();
+    combi();
+}

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

example/custom.cc

@@ -1,58 +0,0 @@
-#include <msgpack.hpp>
-#include <string>
-#include <iostream>
-
-class old_class {
-public:
-	old_class() : value("default") { }
-
-	std::string value;
-
-	MSGPACK_DEFINE(value);
-};
-
-class new_class {
-public:
-	new_class() : value("default"), flag(-1) { }
-
-	std::string value;
-	int flag;
-
-	MSGPACK_DEFINE(value, flag);
-};
-
-int main(void)
-{
-	{
-		old_class oc;
-		new_class nc;
-
-		msgpack::sbuffer sbuf;
-		msgpack::pack(sbuf, oc);
-
-		msgpack::zone zone;
-		msgpack::object obj;
-		msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &zone, &obj);
-
-		obj.convert(&nc);
-
-		std::cout << obj << " value=" << nc.value << " flag=" << nc.flag << std::endl;
-	}
-
-	{
-		new_class nc;
-		old_class oc;
-
-		msgpack::sbuffer sbuf;
-		msgpack::pack(sbuf, nc);
-
-		msgpack::zone zone;
-		msgpack::object obj;
-		msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &zone, &obj);
-
-		obj.convert(&oc);
-
-		std::cout << obj << " value=" << oc.value << std::endl;
-	}
-}
-

example/protocol.cc

@@ -1,86 +0,0 @@
-#include <msgpack.hpp>
-#include <string>
-#include <iostream>
-#include <sstream>
-
-namespace myprotocol {
-	using namespace msgpack::type;
-	using msgpack::define;
-
-	struct Get : define< tuple<uint32_t, std::string> > {
-		Get() { }
-		Get(uint32_t f, const std::string& k) :
-			define_type(msgpack_type(f, k)) { }
-		uint32_t&    flags() { return get<0>(); }
-		std::string& key()   { return get<1>(); }
-	};
-
-	struct Put : define< tuple<uint32_t, std::string, raw_ref> > {
-		Put() { }
-		Put(uint32_t f, const std::string& k, const char* valref, uint32_t vallen) :
-			define_type(msgpack_type( f, k, raw_ref(valref,vallen) )) { }
-		uint32_t&    flags() { return get<0>(); }
-		std::string& key()   { return get<1>(); }
-		raw_ref&     value() { return get<2>(); }
-	};
-
-	struct MultiGet : define< std::vector<Get> > {
-	};
-}
-
-
-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::zone mempool;
-		msgpack::object o =
-			msgpack::unpack(buffer.data(), buffer.size(), mempool);
-
-		myprotocol::Get req;
-		msgpack::convert(req, o);
-		std::cout << "received: " << o << std::endl;
-	}
-
-
-	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::zone mempool;
-		msgpack::object o =
-			msgpack::unpack(buffer.data(), buffer.size(), mempool);
-
-		myprotocol::MultiGet req;
-		msgpack::convert(req, o);
-		std::cout << "received: " << o << std::endl;
-	}
-}
-

example/simple.c

@@ -1,37 +0,0 @@
-#include <msgpack.h>
-#include <stdio.h>
-
-int main(void)
-{
-	/* msgpack::sbuffer is a simple buffer implementation. */
-	msgpack_sbuffer sbuf;
-	msgpack_sbuffer_init(&sbuf);
-
-	/* serialize values into the buffer using msgpack_sbuffer_write callback function. */
-	msgpack_packer pk;
-	msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
-
-	msgpack_pack_array(&pk, 3);
-	msgpack_pack_int(&pk, 1);
-	msgpack_pack_true(&pk);
-	msgpack_pack_raw(&pk, 7);
-	msgpack_pack_raw_body(&pk, "example", 7);
-
-	/* deserialize the buffer into msgpack_object instance. */
-	/* deserialized object is valid during the msgpack_zone instance alive. */
-	msgpack_zone mempool;
-	msgpack_zone_init(&mempool, 2048);
-
-	msgpack_object deserialized;
-	msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
-
-	/* print the deserialized object. */
-	msgpack_object_print(stdout, deserialized);
-	puts("");
-
-	msgpack_zone_destroy(&mempool);
-	msgpack_sbuffer_destroy(&sbuf);
-
-	return 0;
-}
-

example/simple.cc

@@ -1,37 +0,0 @@
-#include <msgpack.hpp>
-#include <string>
-#include <iostream>
-#include <sstream>
-
-int main(void)
-{
-	msgpack::type::tuple<int, bool, std::string> src(1, true, "example");
-
-	// serialize the object into the buffer.
-	// any classes that implements write(const char*,size_t) can be a buffer.
-	std::stringstream buffer;
-	msgpack::pack(buffer, src);
-
-	// send the buffer ...
-	buffer.seekg(0);
-
-	// deserialize the buffer into msgpack::object instance.
-	std::string str(buffer.str());
-
-	// deserialized object is valid during the msgpack::zone instance alive.
-	msgpack::zone mempool;
-
-	msgpack::object deserialized;
-	msgpack::unpack(str.data(), str.size(), NULL, &mempool, &deserialized);
-
-	// msgpack::object supports ostream.
-	std::cout << deserialized << std::endl;
-
-	// convert msgpack::object instance into the original type.
-	// if the type is mismatched, it throws msgpack::type_error exception.
-	msgpack::type::tuple<int, bool, std::string> dst;
-	deserialized.convert(&dst);
-
-	return 0;
-}
-

example/speed_test_uint32_array.c

@@ -1,36 +0,0 @@
-#include <msgpack.h>
-#include <assert.h>
-
-void test()
-{
-	size_t size = 10000000;
-	msgpack_sbuffer buf;
-	msgpack_sbuffer_init(&buf);
-
-	msgpack_packer * pk = msgpack_packer_new(&buf, msgpack_sbuffer_write);
-
-	msgpack_pack_array(pk, size);
-	{
-		int idx = 0;
-		for (; idx < size; ++idx)
-			msgpack_pack_uint32(pk, 1);
-	}
-	msgpack_packer_free(pk);
-
-
-	size_t upk_pos = 0;
-	msgpack_unpacked msg;
-	msgpack_unpacked_init(&msg);
-
-	while (msgpack_unpack_next(&msg, buf.data, buf.size, &upk_pos)) {
-	}
-
-	msgpack_sbuffer_destroy(&buf);
-}
-
-int main(int argc, char **argv)
-{
-	int i = 0;
-	for (; i < 10; ++i) test();
-	return 0;
-}

example/speed_test_uint64_array.c

@@ -1,37 +0,0 @@
-#include <msgpack.h>
-#include <assert.h>
-
-void test()
-{
-	uint64_t test_u64 = 0xFFF0000000000001LL;
-	size_t size = 10000000;
-	msgpack_sbuffer buf;
-	msgpack_sbuffer_init(&buf);
-
-	msgpack_packer * pk = msgpack_packer_new(&buf, msgpack_sbuffer_write);
-
-	msgpack_pack_array(pk, size);
-	{
-		int idx = 0;
-		for (; idx < size; ++idx)
-			msgpack_pack_uint64(pk, test_u64);
-	}
-	msgpack_packer_free(pk);
-
-
-	size_t upk_pos = 0;
-	msgpack_unpacked msg;
-	msgpack_unpacked_init(&msg);
-
-	while (msgpack_unpack_next(&msg, buf.data, buf.size, &upk_pos)) {
-	}
-
-	msgpack_sbuffer_destroy(&buf);
-}
-
-int main(int argc, char **argv)
-{
-	int i = 0;
-	for (; i < 10; ++i) test();
-	return 0;
-}

example/stream.cc

@@ -1,136 +0,0 @@
-#include <msgpack.hpp>
-#include <iostream>
-#include <stdexcept>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-#include <errno.h>
-#include <pthread.h>
-
-class Server {
-public:
-	Server(int sock) : m_sock(sock) { }
-
-	~Server() { }
-
-	typedef std::auto_ptr<msgpack::zone> auto_zone;
-
-	void socket_readable()
-	{
-		m_pac.reserve_buffer(1024);
-
-		ssize_t count =
-			read(m_sock, m_pac.buffer(), m_pac.buffer_capacity());
-
-		if(count <= 0) {
-			if(count == 0) {
-				throw std::runtime_error("connection closed");
-			}
-			if(errno == EAGAIN || errno == EINTR) {
-				return;
-			}
-			throw std::runtime_error(strerror(errno));
-		}
-
-		m_pac.buffer_consumed(count);
-
-		while(m_pac.execute()) {
-			msgpack::object msg = m_pac.data();
-
-			auto_zone life( m_pac.release_zone() );
-
-			m_pac.reset();
-
-			process_message(msg, life);
-		}
-
-		if(m_pac.message_size() > 10*1024*1024) {
-			throw std::runtime_error("message is too large");
-		}
-	}
-
-private:
-	void process_message(msgpack::object msg, auto_zone& life)
-	{
-		std::cout << "message reached: " << msg << std::endl;
-	}
-
-private:
-	int m_sock;
-	msgpack::unpacker m_pac;
-};
-
-
-static void* run_server(void* arg)
-try {
-	Server* srv = reinterpret_cast<Server*>(arg);
-
-	while(true) {
-		srv->socket_readable();
-	}
-	return NULL;
-
-} catch (std::exception& e) {
-	std::cerr << "error while processing client packet: "
-		<< e.what() << std::endl;
-	return NULL;
-
-} catch (...) {
-	std::cerr << "error while processing client packet: "
-		<< "unknown error" << std::endl;
-	return NULL;
-}
-
-
-struct fwriter {
-	fwriter(int fd) : m_fp( fdopen(fd, "w") ) { }
-
-	void write(const char* buf, size_t buflen)
-	{
-		size_t count = fwrite(buf, buflen, 1, m_fp);
-		if(count < 1) {
-			std::cout << buflen << std::endl;
-			std::cout << count << std::endl;
-			throw std::runtime_error(strerror(errno));
-		}
-	}
-
-	void flush() { fflush(m_fp); }
-
-	void close() { fclose(m_fp); }
-
-private:
-	FILE* m_fp;
-};
-
-
-int main(void)
-{
-	int pair[2];
-	pipe(pair);
-
-	// run server thread
-	Server srv(pair[0]);
-	pthread_t thread;
-	pthread_create(&thread, NULL,
-			run_server, reinterpret_cast<void*>(&srv));
-
-	// client thread:
-	fwriter writer(pair[1]);
-	msgpack::packer<fwriter> pk(writer);
-
-	typedef msgpack::type::tuple<std::string, std::string, std::string> put_t;
-	typedef msgpack::type::tuple<std::string, std::string> get_t;
-
-	put_t req1("put", "apple", "red");
-	put_t req2("put", "lemon", "yellow");
-	get_t req3("get", "apple");
-	pk.pack(req1);
-	pk.pack(req2);
-	pk.pack(req3);
-	writer.flush();
-	writer.close();
-
-	pthread_join(thread, NULL);
-}
-

include/msgpack.h

@@ -20,6 +20,8 @@
  * @{
  * @}
  */
+
+#include "msgpack/util.h"
 #include "msgpack/object.h"
 #include "msgpack/zone.h"
 #include "msgpack/pack.h"

include/msgpack.hpp

@@ -16,9 +16,11 @@
 //    limitations under the License.
 //
 #include "msgpack/object.hpp"
+#include "msgpack/iterator.hpp"
 #include "msgpack/zone.hpp"
 #include "msgpack/pack.hpp"
 #include "msgpack/unpack.hpp"
 #include "msgpack/sbuffer.hpp"
 #include "msgpack/vrefbuffer.hpp"
-#include "msgpack.h"
+#include "msgpack/version.hpp"
+#include "msgpack/type.hpp"

include/msgpack/adaptor/adaptor_base.hpp

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

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/bool.hpp

@@ -0,0 +1,74 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_TYPE_BOOL_HPP
+#define MSGPACK_TYPE_BOOL_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace adaptor {
+
+template <>
+struct convert<bool> {
+    msgpack::object const& operator()(msgpack::object const& o, bool& v) const {
+        if(o.type != msgpack::type::BOOLEAN) { throw msgpack::type_error(); }
+        v = o.via.boolean;
+        return o;
+    }
+};
+
+template <>
+struct pack<bool> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const bool& v) const {
+        if(v) { o.pack_true(); }
+        else { o.pack_false(); }
+        return o;
+    }
+};
+
+template <>
+struct object<bool> {
+    void operator()(msgpack::object& o, bool v) const {
+        o.type = msgpack::type::BOOLEAN;
+        o.via.boolean = v;
+    }
+};
+
+template <>
+struct object_with_zone<bool> {
+    void operator()(msgpack::object::with_zone& o, bool v) const {
+        static_cast<msgpack::object&>(o) << v;
+    }
+};
+
+} // namespace adaptor
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+}  // namespace msgpack
+
+#endif // MSGPACK_TYPE_BOOL_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 supress warning on Boost.1.58.0
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__)
+
+#include <boost/optional.hpp>
+
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__)
+
+namespace 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/char_ptr.hpp

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

include/msgpack/adaptor/check_container_size.hpp

@@ -0,0 +1,75 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2015 KONDO Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_CHECK_CONTAINER_SIZE_HPP
+#define MSGPACK_CHECK_CONTAINER_SIZE_HPP
+
+#include "msgpack/versioning.hpp"
+#include <stdexcept>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+struct container_size_overflow : public std::runtime_error {
+    explicit container_size_overflow(const std::string& msg)
+        :std::runtime_error(msg) {}
+#if !defined(MSGPACK_USE_CPP03)
+    explicit container_size_overflow(const char* msg):
+        std::runtime_error(msg) {}
+#endif // !defined(MSGPACK_USE_CPP03)
+};
+
+namespace detail {
+
+template <std::size_t N>
+inline void check_container_size(std::size_t size) {
+    if (size > 0xffffffff) throw container_size_overflow("container size overflow");
+}
+
+template <>
+inline void check_container_size<4>(std::size_t /*size*/) {
+}
+
+template <std::size_t N>
+inline void check_container_size_for_ext(std::size_t size) {
+    if (size > 0xffffffff) throw container_size_overflow("container size overflow");
+}
+
+template <>
+inline void check_container_size_for_ext<4>(std::size_t size) {
+    if (size > 0xfffffffe) throw container_size_overflow("container size overflow");
+}
+
+} // namespace detail
+
+template <typename T>
+inline uint32_t checked_get_container_size(T size) {
+    detail::check_container_size<sizeof(T)>(size);
+    return static_cast<uint32_t>(size);
+}
+
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+}  // namespace msgpack
+
+#endif // MSGPACK_CHECK_CONTAINER_SIZE_HPP

include/msgpack/adaptor/cpp11/array.hpp

@@ -0,0 +1,146 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2014-2015 KONDO Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+
+#ifndef MSGPACK_CPP11_ARRAY_HPP
+#define MSGPACK_CPP11_ARRAY_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/adaptor/check_container_size.hpp"
+#include "msgpack/meta.hpp"
+
+#include <array>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace adaptor {
+
+namespace detail {
+
+namespace array {
+
+template<typename T, std::size_t N1, std::size_t... I1, std::size_t N2, std::size_t... I2>
+inline std::array<T, N1+N2> concat(
+    std::array<T, N1>&& a1,
+    std::array<T, N2>&& a2,
+    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 {
+        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+        if(o.via.array.size != N) { 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;
+            T* it = &v[0];
+            do {
+                p->convert(*it);
+                ++p;
+                ++it;
+            } while(p < pend);
+        }
+        return o;
+    }
+};
+
+template <typename T, std::size_t N>
+struct pack<std::array<T, N>> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::array<T, N>& v) const {
+        uint32_t size = checked_get_container_size(v.size());
+        o.pack_array(size);
+        for(auto const& e : v) o.pack(e);
+        return o;
+    }
+};
+
+template <typename T, std::size_t N>
+struct object_with_zone<std::array<T, N>> {
+    void operator()(msgpack::object::with_zone& o, const std::array<T, N>& v) const {
+        o.type = msgpack::type::ARRAY;
+        if(v.empty()) {
+            o.via.array.ptr = nullptr;
+            o.via.array.size = 0;
+        } else {
+            uint32_t size = checked_get_container_size(v.size());
+            msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
+            o.via.array.size = size;
+            o.via.array.ptr = p;
+            for (auto const& e : v) *p++ = msgpack::object(e, o.zone);
+        }
+    }
+};
+
+} // namespace adaptor
+
+/// @cond
+} // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+} // namespace msgpack
+
+#endif // MSGPACK_CPP11_ARRAY_HPP

include/msgpack/adaptor/cpp11/array_char.hpp

@@ -0,0 +1,97 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2014-2015 KONDO Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_TYPE_ARRAY_CHAR_HPP
+#define MSGPACK_TYPE_ARRAY_CHAR_HPP
+
+#include "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<char, N>> {
+    msgpack::object const& operator()(msgpack::object const& o, std::array<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<char, N>> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::array<char, N>& v) const {
+        uint32_t size = checked_get_container_size(v.size());
+        o.pack_bin(size);
+        o.pack_bin_body(v.data(), size);
+
+        return o;
+    }
+};
+
+template <std::size_t N>
+struct object<std::array<char, N>> {
+    void operator()(msgpack::object& o, const std::array<char, N>& v) const {
+        uint32_t size = checked_get_container_size(v.size());
+        o.type = msgpack::type::BIN;
+        o.via.bin.ptr = v.data();
+        o.via.bin.size = size;
+    }
+};
+
+template <std::size_t N>
+struct object_with_zone<std::array<char, N>> {
+    void operator()(msgpack::object::with_zone& o, const std::array<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_CHAR_HPP

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

@@ -0,0 +1,102 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2014 KONDO-2015 Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+
+#ifndef MSGPACK_CPP11_FORWARD_LIST_HPP
+#define MSGPACK_CPP11_FORWARD_LIST_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/adaptor/check_container_size.hpp"
+
+#include <forward_list>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace adaptor {
+
+template <typename T, typename Alloc>
+    struct as<std::forward_list<T, Alloc>, typename std::enable_if<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;
+        for (auto &e : v) {
+            p->convert(e);
+            ++p;
+        }
+        return o;
+    }
+};
+
+template <typename T, typename Alloc>
+struct pack<std::forward_list<T, Alloc>> {
+    template <typename Stream>
+    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);
+        return o;
+    }
+};
+
+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;
+            o.via.array.size = 0;
+        } else {
+            uint32_t size = checked_get_container_size(std::distance(v.begin(), v.end()));
+            o.via.array.size = size;
+            msgpack::object* p = static_cast<msgpack::object*>(
+                o.zone.allocate_align(sizeof(msgpack::object)*size));
+            o.via.array.ptr = p;
+            for(auto const& e : v) *p++ = msgpack::object(e, o.zone);
+        }
+    }
+};
+
+} // namespace adaptor
+
+/// @cond
+} // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+} // namespace msgpack
+
+#endif // MSGPACK_CPP11_FORWARD_LIST_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

@@ -0,0 +1,184 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_CPP11_TUPLE_HPP
+#define MSGPACK_CPP11_TUPLE_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/adaptor/check_container_size.hpp"
+#include "msgpack/meta.hpp"
+
+#include <tuple>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+// --- Pack from tuple to packer stream ---
+template <typename Stream, typename Tuple, std::size_t N>
+struct StdTuplePacker {
+    static void pack(
+        msgpack::packer<Stream>& o,
+        const Tuple& v) {
+        StdTuplePacker<Stream, Tuple, N-1>::pack(o, v);
+        o.pack(std::get<N-1>(v));
+    }
+};
+
+template <typename Stream, typename Tuple>
+struct StdTuplePacker<Stream, Tuple, 0> {
+    static void pack (
+        msgpack::packer<Stream>&,
+        const Tuple&) {
+    }
+};
+
+namespace adaptor {
+
+template <typename... Args>
+struct pack<std::tuple<Args...>> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(
+        msgpack::packer<Stream>& o,
+        const std::tuple<Args...>& v) const {
+        uint32_t size = checked_get_container_size(sizeof...(Args));
+        o.pack_array(size);
+        StdTuplePacker<Stream, decltype(v), sizeof...(Args)>::pack(o, v);
+        return o;
+    }
+};
+
+} // namespace adaptor
+
+// --- Convert from tuple to object ---
+
+template <typename... Args>
+struct StdTupleAs;
+
+template <typename T, typename... Args>
+struct StdTupleAsImpl {
+    static std::tuple<T, Args...> as(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(
+        msgpack::object const& o,
+        Tuple& v) {
+        StdTupleConverter<Tuple, N-1>::convert(o, v);
+        o.via.array.ptr[N-1].convert<typename std::remove_reference<decltype(std::get<N-1>(v))>::type>(std::get<N-1>(v));
+    }
+};
+
+template <typename Tuple>
+struct StdTupleConverter<Tuple, 0> {
+    static void convert (
+        msgpack::object const&,
+        Tuple&) {
+    }
+};
+
+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()(
+        msgpack::object const& o,
+        std::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(); }
+        StdTupleConverter<decltype(v), sizeof...(Args)>::convert(o, v);
+        return o;
+    }
+};
+
+} // namespace adaptor
+
+// --- Convert from tuple to object with zone ---
+template <typename Tuple, std::size_t N>
+struct StdTupleToObjectWithZone {
+    static void convert(
+        msgpack::object::with_zone& o,
+        const Tuple& v) {
+        StdTupleToObjectWithZone<Tuple, N-1>::convert(o, v);
+        o.via.array.ptr[N-1] = msgpack::object(std::get<N-1>(v), o.zone);
+    }
+};
+
+template <typename Tuple>
+struct StdTupleToObjectWithZone<Tuple, 0> {
+    static void convert (
+        msgpack::object::with_zone&,
+        const Tuple&) {
+    }
+};
+
+namespace adaptor {
+
+template <typename... Args>
+struct object_with_zone<std::tuple<Args...>> {
+    void operator()(
+        msgpack::object::with_zone& o,
+        std::tuple<Args...> const& v) const {
+        uint32_t size = checked_get_container_size(sizeof...(Args));
+        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;
+        StdTupleToObjectWithZone<decltype(v), sizeof...(Args)>::convert(o, v);
+    }
+};
+
+} // namespace adaptor
+
+/// @cond
+} // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+} // namespace msgpack
+
+#endif // MSGPACK_CPP11_TUPLE_HPP

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

@@ -0,0 +1,190 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2014-2015 KONDO Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_TYPE_UNORDERED_MAP_HPP
+#define MSGPACK_TYPE_UNORDERED_MAP_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/adaptor/check_container_size.hpp"
+
+#include <unordered_map>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace adaptor {
+
+template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
+struct as<
+    std::unordered_map<K, V, Hash, Compare, Alloc>,
+    typename std::enable_if<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, 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[std::move(key)]);
+        }
+        v = std::move(tmp);
+        return o;
+    }
+};
+
+template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
+struct pack<std::unordered_map<K, V, Hash, Compare, Alloc>> {
+    template <typename Stream>
+        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, Hash, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
+            it != it_end; ++it) {
+            o.pack(it->first);
+            o.pack(it->second);
+        }
+        return o;
+    }
+};
+
+template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
+struct object_with_zone<std::unordered_map<K, V, Hash, Compare, Alloc>> {
+    void operator()(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;
+            o.via.map.size = 0;
+        } 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::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);
+                ++p;
+                ++it;
+            } while(p < pend);
+        }
+    }
+};
+
+
+template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
+struct as<
+    std::unordered_multimap<K, V, Hash, Compare, Alloc>,
+    typename std::enable_if<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, 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(std::move(value));
+        }
+        v = std::move(tmp);
+        return o;
+    }
+};
+
+template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
+struct pack<std::unordered_multimap<K, V, Hash, Compare, Alloc>> {
+    template <typename Stream>
+        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, Hash, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
+            it != it_end; ++it) {
+            o.pack(it->first);
+            o.pack(it->second);
+        }
+        return o;
+    }
+};
+
+template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
+struct object_with_zone<std::unordered_multimap<K, V, Hash, Compare, Alloc>> {
+    void operator()(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;
+            o.via.map.size = 0;
+        } 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::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);
+                ++p;
+                ++it;
+            } while(p < pend);
+        }
+    }
+};
+
+} // namespace adaptor
+
+/// @cond
+} // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+} // namespace msgpack
+
+
+#endif // MSGPACK_TYPE_UNORDERED_MAP_HPP

include/msgpack/adaptor/cpp11/unordered_set.hpp

@@ -0,0 +1,180 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2014-2015 KONDO Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_TYPE_UNORDERED_SET_HPP
+#define MSGPACK_TYPE_UNORDERED_SET_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/adaptor/check_container_size.hpp"
+
+#include <unordered_set>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace adaptor {
+
+template <typename Key, typename Hash, typename Compare, typename Alloc>
+struct as<std::unordered_set<Key, Hash, Compare, Alloc>, typename std::enable_if<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<Key, Hash, Compare, Alloc> v;
+        while (p > pbegin) {
+            --p;
+            v.insert(p->as<Key>());
+        }
+        return v;
+    }
+};
+
+template <typename Key, typename Hash, typename Compare, typename Alloc>
+struct convert<std::unordered_set<Key, Hash, Compare, Alloc>> {
+    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 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<Key, Hash, Compare, Alloc>& v) const {
+        uint32_t size = checked_get_container_size(v.size());
+        o.pack_array(size);
+        for(typename std::unordered_set<Key, Hash, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
+            it != it_end; ++it) {
+            o.pack(*it);
+        }
+        return o;
+    }
+};
+
+template <typename Key, typename Hash, typename Compare, typename Alloc>
+struct object_with_zone<std::unordered_set<Key, Hash, Compare, Alloc>> {
+    void operator()(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;
+            o.via.array.size = 0;
+        } 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::unordered_set<Key, Hash, Compare, Alloc>::const_iterator it(v.begin());
+            do {
+                *p = msgpack::object(*it, o.zone);
+                ++p;
+                ++it;
+            } while(p < pend);
+        }
+    }
+};
+
+
+template <typename Key, typename Hash, typename Compare, typename Alloc>
+struct as<std::unordered_multiset<Key, Hash, Compare, Alloc>, typename std::enable_if<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<Key, Hash, Compare, Alloc> v;
+        while (p > pbegin) {
+            --p;
+            v.insert(p->as<Key>());
+        }
+        return v;
+    }
+};
+
+template <typename Key, typename Hash, typename Compare, typename Alloc>
+struct convert<std::unordered_multiset<Key, Hash, Compare, Alloc>> {
+    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 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<Key, Hash, Compare, Alloc>& v) const {
+        uint32_t size = checked_get_container_size(v.size());
+        o.pack_array(size);
+        for(typename std::unordered_multiset<Key, Hash, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
+            it != it_end; ++it) {
+            o.pack(*it);
+        }
+        return o;
+    }
+};
+
+template <typename Key, typename Hash, typename Compare, typename Alloc>
+struct object_with_zone<std::unordered_multiset<Key, Hash, Compare, Alloc>> {
+    void operator()(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;
+            o.via.array.size = 0;
+        } 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::unordered_multiset<Key, Hash, Compare, Alloc>::const_iterator it(v.begin());
+            do {
+                *p = msgpack::object(*it, o.zone);
+                ++p;
+                ++it;
+            } while(p < pend);
+        }
+    }
+};
+
+} // namespace adaptor
+
+/// @cond
+} // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+} // namespace msgpack
+
+#endif // MSGPACK_TYPE_UNORDERED_SET_HPP

include/msgpack/adaptor/define.hpp

@@ -0,0 +1,39 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_DEFINE_HPP
+#define MSGPACK_DEFINE_HPP
+
+#include "msgpack/cpp_config.hpp"
+
+#if defined(MSGPACK_USE_CPP03)
+#include "detail/cpp03_define_array.hpp"
+#include "detail/cpp03_define_map.hpp"
+#else  // MSGPACK_USE_CPP03
+#include "detail/cpp11_define_array.hpp"
+#include "detail/cpp11_define_map.hpp"
+#endif // MSGPACK_USE_CPP03
+
+#if defined(MSGPACK_USE_DEFINE_MAP)
+#define MSGPACK_DEFINE MSGPACK_DEFINE_MAP
+#define MSGPACK_BASE MSGPACK_BASE_MAP
+#else  // defined(MSGPACK_USE_DEFINE_MAP)
+#define MSGPACK_DEFINE MSGPACK_DEFINE_ARRAY
+#define MSGPACK_BASE MSGPACK_BASE_ARRAY
+#endif // defined(MSGPACK_USE_DEFINE_MAP)
+
+#endif // MSGPACK_DEFINE_HPP

include/msgpack/adaptor/deque.hpp

@@ -0,0 +1,116 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2015 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_TYPE_DEQUE_HPP
+#define MSGPACK_TYPE_DEQUE_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/adaptor/check_container_size.hpp"
+
+#include <deque>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace adaptor {
+
+#if !defined(MSGPACK_USE_CPP03)
+
+template <typename T, typename Alloc>
+struct as<std::deque<T, Alloc>, typename std::enable_if<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, Alloc>::iterator it = v.begin();
+        for(; p < pend; ++p, ++it) {
+            p->convert(*it);
+        }
+        return o;
+    }
+};
+
+template <typename T, typename Alloc>
+struct pack<std::deque<T, Alloc> > {
+    template <typename Stream>
+    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, Alloc>::const_iterator it(v.begin()), it_end(v.end());
+            it != it_end; ++it) {
+            o.pack(*it);
+        }
+        return o;
+    }
+};
+
+template <typename T, typename Alloc>
+struct object_with_zone<std::deque<T, Alloc> > {
+    void operator()(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;
+            o.via.array.size = 0;
+        } 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::deque<T, Alloc>::const_iterator it(v.begin());
+            do {
+                *p = msgpack::object(*it, o.zone);
+                ++p;
+                ++it;
+            } while(p < pend);
+        }
+    }
+};
+
+} // namespace adaptor
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+}  // namespace msgpack
+
+#endif /* msgpack/type/deque.hpp */

include/msgpack/adaptor/detail/cpp11_define_array.hpp

@@ -0,0 +1,201 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_CPP11_DEFINE_ARRAY_HPP
+#define MSGPACK_CPP11_DEFINE_ARRAY_HPP
+
+#include "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_ARRAY(...) \
+    template <typename Packer> \
+    void msgpack_pack(Packer& pk) const \
+    { \
+        msgpack::type::make_define_array(__VA_ARGS__).msgpack_pack(pk); \
+    } \
+    void msgpack_unpack(msgpack::object const& 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_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 { \
+  /** @cond */ \
+  MSGPACK_API_VERSION_NAMESPACE(v1) { \
+  /** @endcond */ \
+  namespace adaptor { \
+    template<> \
+    struct convert<enum_name> { \
+      msgpack::object const& operator()(msgpack::object const& o, enum_name& v) const { \
+        std::underlying_type<enum_name>::type tmp; \
+        o >> tmp; \
+        v = static_cast<enum_name>(tmp);   \
+        return o; \
+      } \
+    }; \
+    template<> \
+    struct object<enum_name> { \
+      void operator()(msgpack::object& o, const enum_name& v) const { \
+        auto tmp = static_cast<std::underlying_type<enum_name>::type>(v); \
+        o << tmp; \
+      } \
+    }; \
+    template<> \
+    struct object_with_zone<enum_name> { \
+      void operator()(msgpack::object::with_zone& o, const enum_name& v) const {  \
+        auto tmp = static_cast<std::underlying_type<enum_name>::type>(v); \
+        o << tmp; \
+      } \
+    }; \
+    template <> \
+    struct pack<enum_name> { \
+      template <typename Stream> \
+      msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const enum_name& v) const { \
+        return o << static_cast<std::underlying_type<enum_name>::type>(v); \
+      } \
+    }; \
+  } \
+  /** @cond */ \
+  } \
+  /** @endcond */ \
+  }
+
+namespace msgpack {
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+namespace type {
+
+template <typename Tuple, std::size_t N>
+struct define_array_imp {
+    template <typename Packer>
+    static void pack(Packer& pk, Tuple const& t) {
+        define_array_imp<Tuple, N-1>::pack(pk, t);
+        pk.pack(std::get<N-1>(t));
+    }
+    static void unpack(msgpack::object const& o, Tuple& t) {
+        define_array_imp<Tuple, N-1>::unpack(o, t);
+        const size_t size = o.via.array.size;
+        if(size <= N-1) { return; }
+        o.via.array.ptr[N-1].convert(std::get<N-1>(t));
+    }
+    static void object(msgpack::object* o, msgpack::zone& z, Tuple const& 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_array_imp<Tuple, 1> {
+    template <typename Packer>
+    static void pack(Packer& pk, Tuple const& t) {
+        pk.pack(std::get<0>(t));
+    }
+    static void unpack(msgpack::object const& o, Tuple& t) {
+        const size_t size = o.via.array.size;
+        if(size <= 0) { return; }
+        o.via.array.ptr[0].convert(std::get<0>(t));
+    }
+    static void object(msgpack::object* o, msgpack::zone& z, Tuple const& t) {
+        o->via.array.ptr[0] = msgpack::object(std::get<0>(t), z);
+    }
+};
+
+template <typename... Args>
+struct define_array {
+    typedef define_array<Args...> value_type;
+    typedef std::tuple<Args...> tuple_type;
+    define_array(Args&... args) :
+        a(args...) {}
+    template <typename Packer>
+    void msgpack_pack(Packer& pk) const
+    {
+        pk.pack_array(sizeof...(Args));
+
+        define_array_imp<std::tuple<Args&...>, sizeof...(Args)>::pack(pk, a);
+    }
+    void msgpack_unpack(msgpack::object const& o)
+    {
+        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+
+        define_array_imp<std::tuple<Args&...>, sizeof...(Args)>::unpack(o, a);
+    }
+    void msgpack_object(msgpack::object* o, msgpack::zone& z) const
+    {
+        o->type = msgpack::type::ARRAY;
+        o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*sizeof...(Args)));
+        o->via.array.size = sizeof...(Args);
+
+        define_array_imp<std::tuple<Args&...>, sizeof...(Args)>::object(o, z, a);
+    }
+
+    std::tuple<Args&...> a;
+};
+
+template <>
+struct define_array<> {
+    typedef define_array<> value_type;
+    typedef std::tuple<> tuple_type;
+    template <typename Packer>
+    void msgpack_pack(Packer& pk) const
+    {
+        pk.pack_array(0);
+    }
+    void msgpack_unpack(msgpack::object const& o)
+    {
+        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+    }
+    void msgpack_object(msgpack::object* o, msgpack::zone&) const
+    {
+        o->type = msgpack::type::ARRAY;
+        o->via.array.ptr = NULL;
+        o->via.array.size = 0;
+    }
+};
+
+inline define_array<> make_define_array()
+{
+    return define_array<>();
+}
+
+template <typename... Args>
+inline define_array<Args...> make_define_array(Args&... args)
+{
+    return define_array<Args...>(args...);
+}
+
+}  // namespace type
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+}  // namespace msgpack
+
+#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

@@ -0,0 +1,283 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_CPP11_MSGPACK_TUPLE_HPP
+#define MSGPACK_CPP11_MSGPACK_TUPLE_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/object_fwd.hpp"
+#include "msgpack/meta.hpp"
+
+#include <tuple>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace type {
+    // tuple
+    using std::get;
+    using std::tuple_size;
+    using std::tuple_element;
+    using std::uses_allocator;
+    using std::ignore;
+    using std::swap;
+
+    template< class... Types >
+    class tuple : public std::tuple<Types...> {
+    public:
+        using base = std::tuple<Types...>;
+
+        using base::base;
+
+        tuple() = default;
+        tuple(tuple const&) = default;
+        tuple(tuple&&) = default;
+
+        template<typename... OtherTypes>
+        tuple(tuple<OtherTypes...> const& other):base(static_cast<std::tuple<OtherTypes...> const&>(other)) {}
+        template<typename... OtherTypes>
+        tuple(tuple<OtherTypes...> && other):base(static_cast<std::tuple<OtherTypes...> &&>(other)) {}
+
+        tuple& operator=(tuple const&) = default;
+        tuple& operator=(tuple&&) = default;
+
+        template<typename... OtherTypes>
+        tuple& operator=(tuple<OtherTypes...> const& other) {
+            *static_cast<base*>(this) = static_cast<std::tuple<OtherTypes...> const&>(other);
+            return *this;
+        }
+        template<typename... OtherTypes>
+        tuple& operator=(tuple<OtherTypes...> && other) {
+            *static_cast<base*>(this) = static_cast<std::tuple<OtherTypes...> &&>(other);
+            return *this;
+        }
+
+        template< std::size_t I>
+        typename tuple_element<I, base >::type&
+        get() & { return std::get<I>(*this); }
+
+        template< std::size_t I>
+        typename tuple_element<I, base >::type const&
+        get() const& { return std::get<I>(*this); }
+
+        template< std::size_t I>
+        typename tuple_element<I, base >::type&&
+        get() && { return std::get<I>(*this); }
+    };
+
+    template <class... Args>
+    inline tuple<Args...> make_tuple(Args&&... args) {
+        return tuple<Args...>(args...);
+    }
+
+    template<class... Args>
+    inline tuple<Args&&...> forward_as_tuple (Args&&... args) noexcept {
+        return tuple<Args&&...>(std::forward<Args>(args)...);
+    }
+
+    template <class... Tuples>
+    inline auto tuple_cat(Tuples&&... args) ->
+        decltype(
+            std::tuple_cat(std::forward<typename std::remove_reference<Tuples>::type::base>(args)...)
+        ) {
+        return std::tuple_cat(std::forward<typename std::remove_reference<Tuples>::type::base>(args)...);
+    }
+    template <class... Args>
+    inline tuple<Args&...> tie(Args&... args) {
+        return tuple<Args&...>(args...);
+    }
+} // namespace type
+
+// --- Pack from tuple to packer stream ---
+template <typename Stream, typename Tuple, std::size_t N>
+struct MsgpackTuplePacker {
+    static void pack(
+        msgpack::packer<Stream>& o,
+        const Tuple& v) {
+        MsgpackTuplePacker<Stream, Tuple, N-1>::pack(o, v);
+        o.pack(type::get<N-1>(v));
+    }
+};
+
+template <typename Stream, typename Tuple>
+struct MsgpackTuplePacker<Stream, Tuple, 1> {
+    static void pack (
+        msgpack::packer<Stream>& o,
+        const Tuple& v) {
+        o.pack(type::get<0>(v));
+    }
+};
+
+template <typename Stream, typename Tuple>
+struct MsgpackTuplePacker<Stream, Tuple, 0> {
+    static void pack (
+        msgpack::packer<Stream>&,
+        const Tuple&) {
+    }
+};
+
+namespace adaptor {
+
+template <typename... Args>
+struct pack<msgpack::type::tuple<Args...>> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(
+        msgpack::packer<Stream>& o,
+        const msgpack::type::tuple<Args...>& v) const {
+        o.pack_array(sizeof...(Args));
+        MsgpackTuplePacker<Stream, decltype(v), sizeof...(Args)>::pack(o, v);
+        return o;
+    }
+};
+
+} // namespace adaptor
+
+// --- Convert from tuple to object ---
+
+template <typename... Args>
+struct MsgpackTupleAs;
+
+template <typename T, typename... Args>
+struct MsgpackTupleAsImpl {
+    static 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(
+        msgpack::object const& o,
+        Tuple& v) {
+        MsgpackTupleConverter<Tuple, N-1>::convert(o, v);
+        o.via.array.ptr[N-1].convert<typename std::remove_reference<decltype(type::get<N-1>(v))>::type>(type::get<N-1>(v));
+    }
+};
+
+template <typename Tuple>
+struct MsgpackTupleConverter<Tuple, 1> {
+    static void convert (
+        msgpack::object const& o,
+        Tuple& v) {
+        o.via.array.ptr[0].convert<typename std::remove_reference<decltype(type::get<0>(v))>::type>(type::get<0>(v));
+    }
+};
+
+template <typename Tuple>
+struct MsgpackTupleConverter<Tuple, 0> {
+    static void convert (
+        msgpack::object const&,
+        Tuple&) {
+    }
+};
+
+namespace adaptor {
+
+template <typename... 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,
+        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);
+        return o;
+    }
+};
+
+} // namespace adaptor
+
+// --- Convert from tuple to object with zone ---
+template <typename Tuple, std::size_t N>
+struct MsgpackTupleToObjectWithZone {
+    static void convert(
+        msgpack::object::with_zone& o,
+        const Tuple& v) {
+        MsgpackTupleToObjectWithZone<Tuple, N-1>::convert(o, v);
+        o.via.array.ptr[N-1] = msgpack::object(type::get<N-1>(v), o.zone);
+    }
+};
+
+template <typename Tuple>
+struct MsgpackTupleToObjectWithZone<Tuple, 1> {
+    static void convert (
+        msgpack::object::with_zone& o,
+        const Tuple& v) {
+        o.via.array.ptr[0] = msgpack::object(type::get<0>(v), o.zone);
+    }
+};
+
+template <typename Tuple>
+struct MsgpackTupleToObjectWithZone<Tuple, 0> {
+    static void convert (
+        msgpack::object::with_zone&,
+        const Tuple&) {
+    }
+};
+
+namespace adaptor {
+
+template <typename... Args>
+    struct object_with_zone<msgpack::type::tuple<Args...>> {
+    void operator()(
+        msgpack::object::with_zone& o,
+        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);
+        MsgpackTupleToObjectWithZone<decltype(v), sizeof...(Args)>::convert(o, v);
+    }
+};
+
+}  // namespace adaptor
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
+///@endcond
+
+}  // namespace msgpack
+
+#endif // MSGPACK_CPP11_MSGPACK_TUPLE_HPP

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 aleady been checked at ext's constructor
+        uint32_t size = v.size();
+        o.pack_ext(size, v.type());
+        o.pack_ext_body(v.data(), size);
+        return o;
+    }
+};
+
+template <>
+struct object_with_zone<msgpack::type::ext> {
+    void operator()(msgpack::object::with_zone& o, const msgpack::type::ext& v) const {
+        // size limit has aleady 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 shoudn't assume that.
+    ext_ref() : m_ptr(static_cast<char*>(static_cast<void*>(&m_size))), m_size(0) {}
+    ext_ref(const char* p, uint32_t s) :
+        m_ptr(s == 0 ? static_cast<char*>(static_cast<void*>(&m_size)) : p),
+        m_size(s == 0 ? 0 : s - 1) {
+        detail::check_container_size_for_ext<sizeof(std::size_t)>(s);
+    }
+
+    // size limit has aleady been checked at ext's constructor
+    ext_ref(ext const& x) : m_ptr(&x.m_data[0]), m_size(x.size()) {}
+
+    const char* data() const {
+        return m_ptr + 1;
+    }
+
+    uint32_t size() const {
+        return m_size;
+    }
+
+    int8_t type() const {
+        return static_cast<int8_t>(m_ptr[0]);
+    }
+
+    std::string str() const {
+        return std::string(m_ptr + 1, m_size);
+    }
+
+    bool operator== (const ext_ref& x) const {
+        return m_size == x.m_size && std::memcmp(m_ptr, x.m_ptr, m_size) == 0;
+    }
+
+    bool operator!= (const ext_ref& x) const {
+        return !(*this == x);
+    }
+
+    bool operator< (const ext_ref& x) const {
+        if (m_size < x.m_size) return true;
+        if (m_size > x.m_size) return false;
+        return std::memcmp(m_ptr, x.m_ptr, m_size) < 0;
+    }
+
+    bool operator> (const ext_ref& x) const {
+        if (m_size > x.m_size) return true;
+        if (m_size < x.m_size) return false;
+        return std::memcmp(m_ptr, x.m_ptr, m_size) > 0;
+    }
+private:
+    const char* m_ptr;
+    uint32_t m_size;
+    friend struct msgpack::adaptor::object<msgpack::type::ext_ref>;
+};
+
+inline ext::ext(ext_ref const& x) {
+    // size limit has aleady been checked at ext_ref's constructor
+    m_data.reserve(x.size() + 1);
+
+    m_data.push_back(x.type());
+    m_data.insert(m_data.end(), x.data(), x.data() + x.size());
+}
+
+} // namespace type
+
+namespace adaptor {
+
+template <>
+struct convert<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 aleady been checked at ext_ref's constructor
+        uint32_t size = v.size();
+        o.pack_ext(size, v.type());
+        o.pack_ext_body(v.data(), size);
+        return o;
+    }
+};
+
+template <>
+struct object<msgpack::type::ext_ref> {
+    void operator()(msgpack::object& o, const msgpack::type::ext_ref& v) const {
+        // size limit has aleady 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/fixint.hpp

@@ -0,0 +1,306 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2020 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_TYPE_FIXINT_HPP
+#define MSGPACK_TYPE_FIXINT_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/adaptor/int.hpp"
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace type {
+
+
+template <typename T>
+struct fix_int {
+    fix_int() : value(0) { }
+    fix_int(T value) : value(value) { }
+
+    operator T() const { return value; }
+
+    T get() const { return value; }
+
+private:
+    T value;
+};
+
+
+typedef fix_int<uint8_t>  fix_uint8;
+typedef fix_int<uint16_t> fix_uint16;
+typedef fix_int<uint32_t> fix_uint32;
+typedef fix_int<uint64_t> fix_uint64;
+
+typedef fix_int<int8_t>  fix_int8;
+typedef fix_int<int16_t> fix_int16;
+typedef fix_int<int32_t> fix_int32;
+typedef fix_int<int64_t> fix_int64;
+
+
+}  // namespace type
+
+namespace adaptor {
+
+template <>
+struct convert<type::fix_int8> {
+    msgpack::object const& operator()(msgpack::object const& o, type::fix_int8& v) const
+    { v = type::detail::convert_integer<int8_t>(o); return o; }
+};
+
+template <>
+struct convert<type::fix_int16> {
+    msgpack::object const& operator()(msgpack::object const& o, type::fix_int16& v) const
+    { v = type::detail::convert_integer<int16_t>(o); return o; }
+};
+
+template <>
+struct convert<type::fix_int32> {
+    msgpack::object const& operator()(msgpack::object const& o, type::fix_int32& v) const
+    { v = type::detail::convert_integer<int32_t>(o); return o; }
+};
+
+template <>
+struct convert<type::fix_int64> {
+    msgpack::object const& operator()(msgpack::object const& o, type::fix_int64& v) const
+    { v = type::detail::convert_integer<int64_t>(o); return o; }
+};
+
+
+template <>
+struct convert<type::fix_uint8> {
+    msgpack::object const& operator()(msgpack::object const& o, type::fix_uint8& v) const
+    { v = type::detail::convert_integer<uint8_t>(o); return o; }
+};
+
+template <>
+struct convert<type::fix_uint16> {
+    msgpack::object const& operator()(msgpack::object const& o, type::fix_uint16& v) const
+    { v = type::detail::convert_integer<uint16_t>(o); return o; }
+};
+
+template <>
+struct convert<type::fix_uint32> {
+    msgpack::object const& operator()(msgpack::object const& o, type::fix_uint32& v) const
+    { v = type::detail::convert_integer<uint32_t>(o); return o; }
+};
+
+template <>
+struct convert<type::fix_uint64> {
+    msgpack::object const& operator()(msgpack::object const& o, type::fix_uint64& v) const
+    { v = type::detail::convert_integer<uint64_t>(o); return o; }
+};
+
+template <>
+struct pack<type::fix_int8> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const type::fix_int8& v) const
+    { o.pack_fix_int8(v); return o; }
+};
+
+template <>
+struct pack<type::fix_int16> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const type::fix_int16& v) const
+    { o.pack_fix_int16(v); return o; }
+};
+
+template <>
+struct pack<type::fix_int32> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const type::fix_int32& v) const
+    { o.pack_fix_int32(v); return o; }
+};
+
+template <>
+struct pack<type::fix_int64> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const type::fix_int64& v) const
+    { o.pack_fix_int64(v); return o; }
+};
+
+
+template <>
+struct pack<type::fix_uint8> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const type::fix_uint8& v) const
+    { o.pack_fix_uint8(v); return o; }
+};
+
+template <>
+struct pack<type::fix_uint16> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const type::fix_uint16& v) const
+    { o.pack_fix_uint16(v); return o; }
+};
+
+template <>
+struct pack<type::fix_uint32> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const type::fix_uint32& v) const
+    { o.pack_fix_uint32(v); return o; }
+};
+
+template <>
+struct pack<type::fix_uint64> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const type::fix_uint64& v) const
+    { o.pack_fix_uint64(v); return o; }
+};
+
+template <>
+struct object<type::fix_int8> {
+    void operator()(msgpack::object& o, type::fix_int8 v) const {
+        if (v.get() < 0) {
+            o.type = msgpack::type::NEGATIVE_INTEGER;
+            o.via.i64 = v.get();
+        }
+        else {
+            o.type = msgpack::type::POSITIVE_INTEGER;
+            o.via.u64 = v.get();
+        }
+    }
+};
+
+template <>
+struct object<type::fix_int16> {
+    void operator()(msgpack::object& o, type::fix_int16 v) const {
+        if(v.get() < 0) {
+            o.type = msgpack::type::NEGATIVE_INTEGER;
+            o.via.i64 = v.get();
+        }
+        else {
+            o.type = msgpack::type::POSITIVE_INTEGER;
+            o.via.u64 = v.get();
+        }
+    }
+};
+
+template <>
+struct object<type::fix_int32> {
+    void operator()(msgpack::object& o, type::fix_int32 v) const {
+        if (v.get() < 0) {
+            o.type = msgpack::type::NEGATIVE_INTEGER;
+            o.via.i64 = v.get();
+        }
+        else {
+            o.type = msgpack::type::POSITIVE_INTEGER;
+            o.via.u64 = v.get();
+        }
+    }
+};
+
+template <>
+struct object<type::fix_int64> {
+    void operator()(msgpack::object& o, type::fix_int64 v) const {
+        if (v.get() < 0) {
+            o.type = msgpack::type::NEGATIVE_INTEGER;
+            o.via.i64 = v.get();
+        }
+        else {
+            o.type = msgpack::type::POSITIVE_INTEGER;
+            o.via.u64 = v.get();
+        }
+    }
+};
+
+template <>
+struct object<type::fix_uint8> {
+    void operator()(msgpack::object& o, type::fix_uint8 v) const
+    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v.get(); }
+};
+
+template <>
+struct object<type::fix_uint16> {
+    void operator()(msgpack::object& o, type::fix_uint16 v) const
+    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v.get(); }
+};
+
+template <>
+struct object<type::fix_uint32> {
+    void operator()(msgpack::object& o, type::fix_uint32 v) const
+    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v.get(); }
+};
+
+template <>
+struct object<type::fix_uint64> {
+    void operator()(msgpack::object& o, type::fix_uint64 v) const
+    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v.get(); }
+};
+
+template <>
+struct object_with_zone<type::fix_int8> {
+    void operator()(msgpack::object::with_zone& o, type::fix_int8 v) const
+    { static_cast<msgpack::object&>(o) << v; }
+};
+
+template <>
+struct object_with_zone<type::fix_int16> {
+    void operator()(msgpack::object::with_zone& o, type::fix_int16 v) const
+    { static_cast<msgpack::object&>(o) << v; }
+};
+
+template <>
+struct object_with_zone<type::fix_int32> {
+    void operator()(msgpack::object::with_zone& o, type::fix_int32 v) const
+    { static_cast<msgpack::object&>(o) << v; }
+};
+
+template <>
+struct object_with_zone<type::fix_int64> {
+    void operator()(msgpack::object::with_zone& o, type::fix_int64 v) const
+    { static_cast<msgpack::object&>(o) << v; }
+};
+
+
+template <>
+struct object_with_zone<type::fix_uint8> {
+    void operator()(msgpack::object::with_zone& o, type::fix_uint8 v) const
+    { static_cast<msgpack::object&>(o) << v; }
+};
+
+template <>
+struct object_with_zone<type::fix_uint16> {
+    void operator()(msgpack::object::with_zone& o, type::fix_uint16 v) const
+    { static_cast<msgpack::object&>(o) << v; }
+};
+
+template <>
+struct object_with_zone<type::fix_uint32> {
+    void operator()(msgpack::object::with_zone& o, type::fix_uint32 v) const
+    { static_cast<msgpack::object&>(o) << v; }
+};
+
+template <>
+struct object_with_zone<type::fix_uint64> {
+    void operator()(msgpack::object::with_zone& o, type::fix_uint64 v) const
+    { static_cast<msgpack::object&>(o) << v; }
+};
+
+} // namespace adaptor
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+}  // namespace msgpack
+
+#endif /* msgpack/type/fixint.hpp */

include/msgpack/adaptor/float.hpp

@@ -0,0 +1,131 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_TYPE_FLOAT_HPP
+#define MSGPACK_TYPE_FLOAT_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/object_fwd.hpp"
+#include <vector>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+// FIXME check overflow, underflow
+
+namespace adaptor {
+
+template <>
+struct convert<float> {
+    msgpack::object const& operator()(msgpack::object const& o, float& v) const {
+        if(o.type == msgpack::type::FLOAT) {
+            v = static_cast<float>(o.via.f64);
+        }
+        else if (o.type == msgpack::type::POSITIVE_INTEGER) {
+            v = static_cast<float>(o.via.u64);
+        }
+        else if (o.type == msgpack::type::NEGATIVE_INTEGER) {
+            v = static_cast<float>(o.via.i64);
+        }
+        else {
+            throw msgpack::type_error();
+        }
+        return o;
+    }
+};
+
+template <>
+struct pack<float> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const float& v) const {
+        o.pack_float(v);
+        return o;
+    }
+};
+
+
+template <>
+struct convert<double> {
+    msgpack::object const& operator()(msgpack::object const& o, double& v) const {
+        if(o.type == msgpack::type::FLOAT) {
+            v = o.via.f64;
+        }
+        else if (o.type == msgpack::type::POSITIVE_INTEGER) {
+            v = static_cast<double>(o.via.u64);
+        }
+        else if (o.type == msgpack::type::NEGATIVE_INTEGER) {
+            v = static_cast<double>(o.via.i64);
+        }
+        else {
+            throw msgpack::type_error();
+        }
+        return o;
+    }
+};
+
+template <>
+struct pack<double> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const double& v) const {
+        o.pack_double(v);
+        return o;
+    }
+};
+
+
+template <>
+struct object<float> {
+    void operator()(msgpack::object& o, float v) const {
+        o.type = msgpack::type::FLOAT;
+        o.via.f64 = static_cast<double>(v);
+    }
+};
+
+template <>
+struct object<double> {
+    void operator()(msgpack::object& o, double v) const {
+        o.type = msgpack::type::FLOAT;
+        o.via.f64 = v;
+    }
+};
+
+template <>
+struct object_with_zone<float> {
+    void operator()(msgpack::object::with_zone& o, float v) const {
+        static_cast<msgpack::object&>(o) << v;
+    }
+};
+
+template <>
+struct object_with_zone<double> {
+    void operator()(msgpack::object::with_zone& o, double v) const {
+        static_cast<msgpack::object&>(o) << v;
+    }
+};
+
+} // namespace adaptor
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+}  // namespace msgpack
+
+#endif // MSGPACK_TYPE_FLOAT_HPP

include/msgpack/adaptor/int.hpp

@@ -0,0 +1,436 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_TYPE_INT_HPP
+#define MSGPACK_TYPE_INT_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include <limits>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1){
+/// @endcond
+
+namespace type {
+namespace detail {
+    template <typename T, bool Signed>
+    struct convert_integer_sign;
+
+    template <typename T>
+    struct convert_integer_sign<T, true> {
+        static inline T convert(msgpack::object const& o) {
+            if(o.type == msgpack::type::POSITIVE_INTEGER) {
+                if(o.via.u64 > static_cast<uint64_t>(std::numeric_limits<T>::max()))
+                    { throw msgpack::type_error(); }
+                return static_cast<T>(o.via.u64);
+            } else if(o.type == msgpack::type::NEGATIVE_INTEGER) {
+                if(o.via.i64 < static_cast<int64_t>(std::numeric_limits<T>::min()))
+                    { throw msgpack::type_error(); }
+                return static_cast<T>(o.via.i64);
+            }
+            throw msgpack::type_error();
+        }
+    };
+
+    template <typename T>
+    struct convert_integer_sign<T, false> {
+        static inline T convert(msgpack::object const& o) {
+            if(o.type == msgpack::type::POSITIVE_INTEGER) {
+                if(o.via.u64 > static_cast<uint64_t>(std::numeric_limits<T>::max()))
+                    { throw msgpack::type_error(); }
+                return static_cast<T>(o.via.u64);
+            }
+            throw msgpack::type_error();
+        }
+    };
+
+    template <typename T>
+    struct is_signed {
+        static const bool value = std::numeric_limits<T>::is_signed;
+    };
+
+    template <typename T>
+    static inline T convert_integer(msgpack::object const& o)
+    {
+        return detail::convert_integer_sign<T, is_signed<T>::value>::convert(o);
+    }
+
+    template <bool Signed>
+    struct object_char_sign;
+
+    template <>
+    struct object_char_sign<true> {
+        static inline void make(msgpack::object& o, char v) {
+            if (v < 0) {
+                o.type = msgpack::type::NEGATIVE_INTEGER;
+                o.via.i64 = v;
+            }
+            else {
+                o.type = msgpack::type::POSITIVE_INTEGER;
+                o.via.u64 = v;
+            }
+        }
+    };
+
+    template <>
+    struct object_char_sign<false> {
+        static inline void make(msgpack::object& o, char v) {
+            o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v;
+        }
+    };
+
+    static inline void object_char(msgpack::object& o, char v) {
+        return object_char_sign<is_signed<char>::value>::make(o, v);
+    }
+
+}  // namespace detail
+}  // namespace type
+
+namespace adaptor {
+
+template <>
+struct convert<char> {
+    msgpack::object const& operator()(msgpack::object const& o, char& v) const
+    { v = type::detail::convert_integer<char>(o); return o; }
+};
+
+template <>
+struct convert<signed char> {
+    msgpack::object const& operator()(msgpack::object const& o, signed char& v) const
+    { v = type::detail::convert_integer<signed char>(o); return o; }
+};
+
+template <>
+struct convert<signed short> {
+    msgpack::object const& operator()(msgpack::object const& o, signed short& v) const
+    { v = type::detail::convert_integer<signed short>(o); return o; }
+};
+
+template <>
+struct convert<signed int> {
+    msgpack::object const& operator()(msgpack::object const& o, signed int& v) const
+    { v = type::detail::convert_integer<signed int>(o); return o; }
+};
+
+template <>
+struct convert<signed long> {
+    msgpack::object const& operator()(msgpack::object const& o, signed long& v) const
+    { v = type::detail::convert_integer<signed long>(o); return o; }
+};
+
+template <>
+struct convert<signed long long> {
+    msgpack::object const& operator()(msgpack::object const& o, signed long long& v) const
+    { v = type::detail::convert_integer<signed long long>(o); return o; }
+};
+
+
+template <>
+struct convert<unsigned char> {
+    msgpack::object const& operator()(msgpack::object const& o, unsigned char& v) const
+    { v = type::detail::convert_integer<unsigned char>(o); return o; }
+};
+
+template <>
+struct convert<unsigned short> {
+    msgpack::object const& operator()(msgpack::object const& o, unsigned short& v) const
+    { v = type::detail::convert_integer<unsigned short>(o); return o; }
+};
+
+template <>
+struct convert<unsigned int> {
+    msgpack::object const& operator()(msgpack::object const& o, unsigned int& v) const
+    { v = type::detail::convert_integer<unsigned int>(o); return o; }
+};
+
+template <>
+struct convert<unsigned long> {
+    msgpack::object const& operator()(msgpack::object const& o, unsigned long& v) const
+    { v = type::detail::convert_integer<unsigned long>(o); return o; }
+};
+
+template <>
+struct convert<unsigned long long> {
+    msgpack::object const& operator()(msgpack::object const& o, unsigned long long& v) const
+    { v = type::detail::convert_integer<unsigned long long>(o); return o; }
+};
+
+
+template <>
+struct pack<char> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, char v) const
+    { o.pack_char(v); return o; }
+};
+
+template <>
+struct pack<signed char> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, signed char v) const
+    { o.pack_signed_char(v); return o; }
+};
+
+template <>
+struct pack<signed short> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, signed short v) const
+    { o.pack_short(v); return o; }
+};
+
+template <>
+struct pack<signed int> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, signed int v) const
+    { o.pack_int(v); return o; }
+};
+
+template <>
+struct pack<signed long> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, signed long v) const
+    { o.pack_long(v); return o; }
+};
+
+template <>
+struct pack<signed long long> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, signed long long v) const
+    { o.pack_long_long(v); return o; }
+};
+
+
+template <>
+struct pack<unsigned char> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, unsigned char v) const
+    { o.pack_unsigned_char(v); return o; }
+};
+
+template <>
+struct pack<unsigned short> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, unsigned short v) const
+    { o.pack_unsigned_short(v); return o; }
+};
+
+template <>
+struct pack<unsigned int> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, unsigned int v) const
+    { o.pack_unsigned_int(v); return o; }
+};
+
+template <>
+struct pack<unsigned long> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, unsigned long v) const
+    { o.pack_unsigned_long(v); return o; }
+};
+
+template <>
+struct pack<unsigned long long> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, unsigned long long v) const
+    { o.pack_unsigned_long_long(v); return o; }
+};
+
+
+template <>
+struct object<char> {
+    void operator()(msgpack::object& o, char v) const
+    { type::detail::object_char(o, v); }
+};
+
+template <>
+struct object<signed char> {
+    void operator()(msgpack::object& o, signed char v) const {
+        if (v < 0) {
+            o.type = msgpack::type::NEGATIVE_INTEGER;
+            o.via.i64 = v;
+        }
+        else {
+            o.type = msgpack::type::POSITIVE_INTEGER;
+            o.via.u64 = v;
+        }
+    }
+};
+
+template <>
+struct object<signed short> {
+    void operator()(msgpack::object& o, signed short v) const {
+        if (v < 0) {
+            o.type = msgpack::type::NEGATIVE_INTEGER;
+            o.via.i64 = v;
+        }
+        else {
+            o.type = msgpack::type::POSITIVE_INTEGER;
+            o.via.u64 = v;
+        }
+    }
+};
+
+template <>
+struct object<signed int> {
+    void operator()(msgpack::object& o, signed int v) const {
+        if (v < 0) {
+            o.type = msgpack::type::NEGATIVE_INTEGER;
+            o.via.i64 = v;
+        }
+        else {
+            o.type = msgpack::type::POSITIVE_INTEGER;
+            o.via.u64 = v;
+        }
+    }
+};
+
+template <>
+struct object<signed long> {
+    void operator()(msgpack::object& o, signed long v) const {
+        if (v < 0) {
+            o.type = msgpack::type::NEGATIVE_INTEGER;
+            o.via.i64 = v;
+        }
+        else {
+            o.type = msgpack::type::POSITIVE_INTEGER;
+            o.via.u64 = v;
+        }
+    }
+};
+
+template <>
+struct object<signed long long> {
+    void operator()(msgpack::object& o, signed long long v) const {
+        if (v < 0) {
+            o.type = msgpack::type::NEGATIVE_INTEGER;
+            o.via.i64 = v;
+        }
+        else{
+            o.type = msgpack::type::POSITIVE_INTEGER;
+            o.via.u64 = v;
+        }
+    }
+};
+
+template <>
+struct object<unsigned char> {
+    void operator()(msgpack::object& o, unsigned char v) const
+    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; }
+};
+
+template <>
+struct object<unsigned short> {
+    void operator()(msgpack::object& o, unsigned short v) const
+    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; }
+};
+
+template <>
+struct object<unsigned int> {
+    void operator()(msgpack::object& o, unsigned int v) const
+    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; }
+};
+
+template <>
+struct object<unsigned long> {
+    void operator()(msgpack::object& o, unsigned long v) const
+    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; }
+};
+
+template <>
+struct object<unsigned long long> {
+    void operator()(msgpack::object& o, unsigned long long v) const
+    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; }
+};
+
+
+template <>
+struct object_with_zone<char> {
+    void operator()(msgpack::object::with_zone& o, char v) const
+    { static_cast<msgpack::object&>(o) << v; }
+};
+
+template <>
+struct object_with_zone<signed char> {
+    void operator()(msgpack::object::with_zone& o, signed char v) const
+    { static_cast<msgpack::object&>(o) << v; }
+};
+
+template <>
+struct object_with_zone<signed short> {
+    void operator()(msgpack::object::with_zone& o, signed short v) const
+    { static_cast<msgpack::object&>(o) << v; }
+};
+
+template <>
+struct object_with_zone<signed int> {
+    void operator()(msgpack::object::with_zone& o, signed int v) const
+    { static_cast<msgpack::object&>(o) << v; }
+};
+
+template <>
+struct object_with_zone<signed long> {
+    void operator()(msgpack::object::with_zone& o, signed long v) const
+    { static_cast<msgpack::object&>(o) << v; }
+};
+
+template <>
+struct object_with_zone<signed long long> {
+    void operator()(msgpack::object::with_zone& o, const signed long long& v) const
+    { static_cast<msgpack::object&>(o) << v; }
+};
+
+template <>
+struct object_with_zone<unsigned char> {
+    void operator()(msgpack::object::with_zone& o, unsigned char v) const
+    { static_cast<msgpack::object&>(o) << v; }
+};
+
+template <>
+struct object_with_zone<unsigned short> {
+    void operator()(msgpack::object::with_zone& o, unsigned short v) const
+    { static_cast<msgpack::object&>(o) << v; }
+};
+
+template <>
+struct object_with_zone<unsigned int> {
+    void operator()(msgpack::object::with_zone& o, unsigned int v) const
+    { static_cast<msgpack::object&>(o) << v; }
+};
+
+template <>
+struct object_with_zone<unsigned long> {
+    void operator()(msgpack::object::with_zone& o, unsigned long v) const
+    { static_cast<msgpack::object&>(o) << v; }
+};
+
+template <>
+struct object_with_zone<unsigned long long> {
+    void operator()(msgpack::object::with_zone& o, const unsigned long long& v) const
+    { static_cast<msgpack::object&>(o) << v; }
+};
+
+} // namespace adaptor
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+}  // namespace msgpack
+
+#endif /* msgpack/type/int.hpp */

include/msgpack/adaptor/list.hpp

@@ -0,0 +1,114 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2015 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_TYPE_LIST_HPP
+#define MSGPACK_TYPE_LIST_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/adaptor/check_container_size.hpp"
+
+#include <list>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace adaptor {
+
+#if !defined(MSGPACK_USE_CPP03)
+
+template <typename T, typename Alloc>
+struct as<std::list<T, Alloc>, typename std::enable_if<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, Alloc>::iterator it = v.begin();
+        for (; p < pend; ++p, ++it) {
+            p->convert(*it);
+        }
+        return o;
+    }
+};
+
+template <typename T, typename Alloc>
+struct pack<std::list<T, Alloc> > {
+    template <typename Stream>
+    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, Alloc>::const_iterator it(v.begin()), it_end(v.end());
+            it != it_end; ++it) {
+            o.pack(*it);
+        }
+        return o;
+    }
+};
+
+template <typename T, typename Alloc>
+struct object_with_zone<std::list<T, Alloc> > {
+    void operator()(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 {
+            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, Alloc>::const_iterator it(v.begin());
+            do {
+                *p = msgpack::object(*it, o.zone);
+                ++p;
+                ++it;
+            } while(p < pend);
+        }
+    }
+};
+
+} // namespace adaptor
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+}  // namespace msgpack
+
+#endif // MSGPACK_TYPE_LIST_HPP

include/msgpack/adaptor/map.hpp

@@ -0,0 +1,314 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2015 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_TYPE_MAP_HPP
+#define MSGPACK_TYPE_MAP_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/object_fwd.hpp"
+#include "msgpack/adaptor/check_container_size.hpp"
+
+#include <map>
+#include <vector>
+#include <algorithm>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace type {
+
+template <typename K, typename V, typename Compare = std::less<K>, typename Alloc = std::allocator<std::pair<K, V> > >
+class assoc_vector : public std::vector< std::pair<K, V>, Alloc > {
+#if !defined(MSGPACK_USE_CPP03)
+    using std::vector<std::pair<K, V>, Alloc>::vector;
+#endif // !defined(MSGPACK_USE_CPP03)
+};
+
+namespace detail {
+    template <typename K, typename V, typename Compare, typename Alloc>
+    struct pair_first_less {
+        bool operator() (const std::pair<K, V>& x, const std::pair<K, V>& y) const
+            { return Compare()(x.first, y.first); }
+    };
+}
+
+}  //namespace type
+
+namespace adaptor {
+
+#if !defined(MSGPACK_USE_CPP03)
+
+template <typename K, typename V, typename Compare, typename Alloc>
+struct as<
+    type::assoc_vector<K, V, Compare, Alloc>,
+    typename std::enable_if<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;
+        msgpack::object_kv* const pend = o.via.map.ptr + o.via.map.size;
+        std::pair<K, V>* it(&v.front());
+        for (; p < pend; ++p, ++it) {
+            p->key.convert(it->first);
+            p->val.convert(it->second);
+        }
+        std::sort(v.begin(), v.end(), type::detail::pair_first_less<K, V, Compare, Alloc>());
+        return o;
+    }
+};
+
+template <typename K, typename V, typename Compare, typename Alloc>
+struct pack<type::assoc_vector<K, V, Compare, Alloc> > {
+    template <typename Stream>
+    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, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
+            it != it_end; ++it) {
+            o.pack(it->first);
+            o.pack(it->second);
+        }
+        return o;
+    }
+};
+
+template <typename K, typename V, typename Compare, typename Alloc>
+struct object_with_zone<type::assoc_vector<K, V, Compare, Alloc> > {
+    void operator()(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 {
+            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, Compare, Alloc>::const_iterator it(v.begin());
+            do {
+                p->key = msgpack::object(it->first, o.zone);
+                p->val = msgpack::object(it->second, o.zone);
+                ++p;
+                ++it;
+            } while(p < pend);
+        }
+    }
+};
+
+#if !defined(MSGPACK_USE_CPP03)
+
+template <typename K, typename V, typename Compare, typename Alloc>
+struct as<
+    std::map<K, V, Compare, Alloc>,
+    typename std::enable_if<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, 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);
+#if __cplusplus >= 201103L
+            p->val.convert(tmp[std::move(key)]);
+#else
+            p->val.convert(tmp[key]);
+#endif
+        }
+#if __cplusplus >= 201103L
+        v = std::move(tmp);
+#else
+        tmp.swap(v);
+#endif
+        return o;
+    }
+};
+
+template <typename K, typename V, typename Compare, typename Alloc>
+struct pack<std::map<K, V, Compare, Alloc> > {
+    template <typename Stream>
+    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, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
+            it != it_end; ++it) {
+            o.pack(it->first);
+            o.pack(it->second);
+        }
+        return o;
+    }
+};
+
+template <typename K, typename V, typename Compare, typename Alloc>
+struct object_with_zone<std::map<K, V, Compare, Alloc> > {
+    void operator()(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 {
+            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, Compare, Alloc>::const_iterator it(v.begin());
+            do {
+                p->key = msgpack::object(it->first, o.zone);
+                p->val = msgpack::object(it->second, o.zone);
+                ++p;
+                ++it;
+            } while(p < pend);
+        }
+    }
+};
+
+#if !defined(MSGPACK_USE_CPP03)
+
+template <typename K, typename V, typename Compare, typename Alloc>
+struct as<
+    std::multimap<K, V, Compare, Alloc>,
+    typename std::enable_if<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, 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, 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, Compare, Alloc>& v) const {
+        uint32_t size = checked_get_container_size(v.size());
+        o.pack_map(size);
+        for (typename std::multimap<K, V, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
+            it != it_end; ++it) {
+            o.pack(it->first);
+            o.pack(it->second);
+        }
+        return o;
+    }
+};
+
+template <typename K, typename V, typename Compare, typename Alloc>
+struct object_with_zone<std::multimap<K, V, Compare, Alloc> > {
+    void operator()(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 {
+            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, Compare, Alloc>::const_iterator it(v.begin());
+            do {
+                p->key = msgpack::object(it->first, o.zone);
+                p->val = msgpack::object(it->second, o.zone);
+                ++p;
+                ++it;
+            } while(p < pend);
+        }
+    }
+};
+
+} // namespace adaptor
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+}  // namespace msgpack
+
+#endif // MSGPACK_TYPE_MAP_HPP

include/msgpack/adaptor/msgpack_tuple.hpp

@@ -0,0 +1,29 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_MSGPACK_TUPLE_HPP
+#define MSGPACK_MSGPACK_TUPLE_HPP
+
+#include "msgpack/cpp_config.hpp"
+
+#if defined(MSGPACK_USE_CPP03)
+#include "detail/cpp03_msgpack_tuple.hpp"
+#else  // MSGPACK_USE_CPP03
+#include "detail/cpp11_msgpack_tuple.hpp"
+#endif // MSGPACK_USE_CPP03
+
+#endif // MSGPACK_MSGPACK_TUPLE_HPP

include/msgpack/adaptor/nil.hpp

@@ -0,0 +1,92 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_TYPE_NIL_HPP
+#define MSGPACK_TYPE_NIL_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace type {
+
+struct nil { };
+
+inline bool operator<(nil const& lhs, nil const& rhs) {
+    return &lhs < &rhs;
+}
+
+inline bool operator==(nil const& lhs, nil const& rhs) {
+    return &lhs == &rhs;
+}
+
+}  // namespace type
+
+namespace adaptor {
+
+template <>
+struct convert<type::nil> {
+    msgpack::object const& operator()(msgpack::object const& o, type::nil&) const {
+        if(o.type != msgpack::type::NIL) { throw msgpack::type_error(); }
+        return o;
+    }
+};
+
+template <>
+struct pack<type::nil> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const type::nil&) const {
+        o.pack_nil();
+        return o;
+    }
+};
+
+template <>
+struct object<type::nil> {
+    void operator()(msgpack::object& o, type::nil) const {
+        o.type = msgpack::type::NIL;
+    }
+};
+
+template <>
+struct object_with_zone<type::nil> {
+    void operator()(msgpack::object::with_zone& o, type::nil v) const {
+        static_cast<msgpack::object&>(o) << v;
+    }
+};
+
+} // namespace adaptror
+
+template <>
+inline void msgpack::object::as<void>() const
+{
+    msgpack::type::nil v;
+    convert(v);
+}
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+}  // namespace msgpack
+
+#endif // MSGPACK_TYPE_NIL_HPP

include/msgpack/adaptor/pair.hpp

@@ -0,0 +1,91 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_TYPE_PAIR_HPP
+#define MSGPACK_TYPE_PAIR_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/meta.hpp"
+
+#include <utility>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace adaptor {
+
+#if !defined(MSGPACK_USE_CPP03)
+
+template <typename T1, typename T2>
+struct as<std::pair<T1, T2>,
+          typename std::enable_if<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 {
+        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+        if(o.via.array.size != 2) { throw msgpack::type_error(); }
+        o.via.array.ptr[0].convert(v.first);
+        o.via.array.ptr[1].convert(v.second);
+        return o;
+    }
+};
+
+template <typename T1, typename T2>
+struct pack<std::pair<T1, T2> > {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::pair<T1, T2>& v) const {
+        o.pack_array(2);
+        o.pack(v.first);
+        o.pack(v.second);
+        return o;
+    }
+};
+
+template <typename T1, typename T2>
+struct object_with_zone<std::pair<T1, T2> > {
+    void operator()(msgpack::object::with_zone& o, const std::pair<T1, T2>& v) const {
+        o.type = msgpack::type::ARRAY;
+        msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*2));
+        o.via.array.ptr = p;
+        o.via.array.size = 2;
+        p[0] = msgpack::object(v.first, o.zone);
+        p[1] = msgpack::object(v.second, o.zone);
+    }
+};
+
+} // namespace adaptor
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+}  // namespace msgpack
+
+#endif // MSGPACK_TYPE_PAIR_HPP

include/msgpack/adaptor/raw.hpp

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

include/msgpack/adaptor/set.hpp

@@ -0,0 +1,196 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2015 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_TYPE_SET_HPP
+#define MSGPACK_TYPE_SET_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/adaptor/check_container_size.hpp"
+
+#include <set>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace adaptor {
+
+#if !defined(MSGPACK_USE_CPP03)
+
+template <typename T, typename Compare, typename Alloc>
+struct as<std::set<T, Compare, Alloc>, typename std::enable_if<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, 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, 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, Compare, Alloc>& v) const {
+        uint32_t size = checked_get_container_size(v.size());
+        o.pack_array(size);
+        for (typename std::set<T, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
+            it != it_end; ++it) {
+            o.pack(*it);
+        }
+        return o;
+    }
+};
+
+template <typename T, typename Compare, typename Alloc>
+struct object_with_zone<std::set<T, Compare, Alloc> > {
+    void operator()(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 {
+            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, Compare, Alloc>::const_iterator it(v.begin());
+            do {
+                *p = msgpack::object(*it, o.zone);
+                ++p;
+                ++it;
+            } while(p < pend);
+        }
+    }
+};
+
+#if !defined(MSGPACK_USE_CPP03)
+
+template <typename T, typename Compare, typename Alloc>
+struct as<std::multiset<T, Compare, Alloc>, typename std::enable_if<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, 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, 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, Compare, Alloc>& v) const {
+        uint32_t size = checked_get_container_size(v.size());
+        o.pack_array(size);
+        for (typename std::multiset<T, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
+            it != it_end; ++it) {
+            o.pack(*it);
+        }
+        return o;
+    }
+};
+
+template <typename T, typename Compare, typename Alloc>
+struct object_with_zone<std::multiset<T, Compare, Alloc> > {
+    void operator()(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;
+            o.via.array.size = 0;
+        } 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::multiset<T, Compare, Alloc>::const_iterator it(v.begin());
+            do {
+                *p = msgpack::object(*it, o.zone);
+                ++p;
+                ++it;
+            } while(p < pend);
+        }
+    }
+};
+
+} // namespace adaptor
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+}  // namespace msgpack
+
+#endif // MSGPACK_TYPE_SET_HPP

include/msgpack/adaptor/string.hpp

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

include/msgpack/adaptor/tr1/unordered_map.hpp

@@ -0,0 +1,179 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2015 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP
+#define MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/adaptor/check_container_size.hpp"
+
+#if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
+
+#define MSGPACK_HAS_STD_UNORDERED_MAP
+#include <unordered_map>
+#define MSGPACK_STD_TR1 std
+
+#else   // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
+
+#if __GNUC__ >= 4
+
+#define MSGPACK_HAS_STD_TR1_UNORDERED_MAP
+
+#include <tr1/unordered_map>
+#define MSGPACK_STD_TR1 std::tr1
+
+#endif // __GNUC__ >= 4
+
+#endif  // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
+
+#if defined(MSGPACK_STD_TR1)
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace adaptor {
+
+template <typename K, typename V, typename Hash, typename Pred, typename Alloc>
+struct convert<MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc> > {
+    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, Hash, Pred, Alloc> tmp;
+        for(; p != pend; ++p) {
+            K key;
+            p->key.convert(key);
+            p->val.convert(tmp[key]);
+        }
+        tmp.swap(v);
+        return o;
+    }
+};
+
+template <typename K, typename V, typename Hash, typename Pred, typename Alloc>
+struct pack<MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc> > {
+    template <typename Stream>
+    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, Hash, Pred, Alloc>::const_iterator it(v.begin()), it_end(v.end());
+            it != it_end; ++it) {
+            o.pack(it->first);
+            o.pack(it->second);
+        }
+        return o;
+    }
+};
+
+template <typename K, typename V, typename Hash, typename Pred, typename Alloc>
+struct object_with_zone<MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc> > {
+    void operator()(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;
+            o.via.map.size = 0;
+        } 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 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);
+                ++p;
+                ++it;
+            } while(p < pend);
+        }
+    }
+};
+
+template <typename K, typename V, typename Hash, typename Pred, typename Alloc>
+struct convert<MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Alloc> > {
+    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, Hash, Pred, Alloc> tmp;
+        for(; p != pend; ++p) {
+            std::pair<K, V> value;
+            p->key.convert(value.first);
+            p->val.convert(value.second);
+            tmp.insert(value);
+        }
+        tmp.swap(v);
+        return o;
+    }
+};
+
+template <typename K, typename V, typename Hash, typename Pred, typename Alloc>
+struct pack<MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Alloc> > {
+    template <typename Stream>
+    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, Hash, Pred, Alloc>::const_iterator it(v.begin()), it_end(v.end());
+            it != it_end; ++it) {
+            o.pack(it->first);
+            o.pack(it->second);
+        }
+        return o;
+    }
+};
+
+template <typename K, typename V, typename Hash, typename Pred, typename Alloc>
+struct object_with_zone<MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Alloc> > {
+    void operator()(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;
+            o.via.map.size = 0;
+        } 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 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);
+                ++p;
+                ++it;
+            } while(p < pend);
+        }
+    }
+};
+
+} // namespace adaptor
+
+/// @cond
+} // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+} // namespace msgpack
+
+#undef MSGPACK_STD_TR1
+
+#endif // MSGPACK_STD_TR1
+
+#endif // MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP