Merge pull request #723 from redboltz/update_readme

Updated readme.

.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,239 @@
+language: cpp
+sudo: false
+dist: trusty
+
+install:
+ - export BASE=`pwd`
+ - mkdir ${BASE}/usr
+ - if [ "$TRAVIS_OS_NAME" == "linux" ]; then wget --no-check-certificate https://cmake.org/files/v3.7/cmake-3.7.1-Linux-x86_64.sh -O cmake-3.7.1-Linux-x86_64.sh; fi
+ - if [ "$TRAVIS_OS_NAME" == "linux" ]; then chmod a+x cmake-3.7.1-Linux-x86_64.sh; fi
+ - if [ "$TRAVIS_OS_NAME" == "linux" ]; then ./cmake-3.7.1-Linux-x86_64.sh --prefix=${BASE}/usr --skip-license; fi
+ - if [ "$TRAVIS_OS_NAME" == "linux" ]; then export PATH="${BASE}/usr/bin:$PATH"; fi
+ - if [ "$TRAVIS_OS_NAME" == "linux" ]; then export LD_LIBRARY_PATH="${BASE}/usr/lib:$LD_LIBRARY_PATH"; fi
+ - if [ "$CXX" == "g++" ]; then export CXX="g++-7" CC="gcc-7"; fi
+ - if [ "$CXX" == "clang++" ] && [ "$TRAVIS_OS_NAME" == "linux" ]; then export CXX="clang++-5.0" CC="clang-5.0"; fi
+ - if [ "$CXX" == "g++" ] && [ "$TRAVIS_OS_NAME" == "linux" ]; then cd /usr/include/c++/$(g++ -v 2>&1 | grep version | awk '{print $3}')/bits; ln -s ../ext/atomicity.h .; cd ${BASE}/usr; fi
+#gtest
+ - wget https://github.com/google/googletest/archive/release-1.7.0.zip -O googletest-release-1.7.0.zip
+ - unzip -q googletest-release-1.7.0.zip
+ - cd googletest-release-1.7.0
+ - $CXX -m${ARCH} src/gtest-all.cc -I. -Iinclude -c
+ - $CXX -m${ARCH} src/gtest_main.cc -I. -Iinclude -c
+ - ar -rv libgtest.a gtest-all.o
+ - ar -rv libgtest_main.a gtest_main.o
+ - mkdir -p ${BASE}/usr/include
+ - cp -r include/gtest ${BASE}/usr/include
+ - mkdir -p ${BASE}/usr/lib
+ - mv *.a ${BASE}/usr/lib
+ - cd ..
+ # valgrind
+ - if [ "$TRAVIS_OS_NAME" == "linux" ] && [ "$MSGPACK_FUZZ_REGRESSION" != "ON" ]; then wget http://valgrind.org/downloads/valgrind-3.12.0.tar.bz2 && tar xjf valgrind-3.12.0.tar.bz2 && cd valgrind-3.12.0 && ./configure --prefix=${BASE}/usr > /dev/null && make -j3 > /dev/null && make install > /dev/null && cd ..; fi
+ # boost
+ - if [ "$BOOST" == "ON" ] && [ "MSGPACK_FUZZ_REGRESSION" != "ON" ]; then wget http://sourceforge.net/projects/boost/files/boost/1.67.0/boost_1_67_0.zip && unzip -q boost_1_67_0.zip && cd boost_1_67_0 && ./bootstrap.sh && ./b2 -j3 --prefix=${BASE}/usr --with-chrono --with-context --with-system --with-timer address-model=${ARCH} install > /dev/null && cd ..; fi
+ - if [ "$MSGPACK_FUZZ_REGRESSION" == "ON" ]; then wget http://sourceforge.net/projects/boost/files/boost/1.67.0/boost_1_67_0.zip && unzip -q boost_1_67_0.zip && cd boost_1_67_0 && ./bootstrap.sh --with-toolset=clang && ./b2 clean && ./b2 -j$(nproc) --prefix=${BASE}/usr --with-system --with-filesystem address-model=${ARCH} install > /dev/null && cd ..; fi
+ - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo ln -s /usr/include/x86_64-linux-gnu/zconf.h /usr/include; fi
+
+matrix:
+  include:
+    - os: osx
+      compiler: clang
+      env: ACTION="ci/build_cmake.sh"  CXX17="ON" ARCH="64"   BOOST="ON" SHARED="ON"  CHAR_SIGN="unsigned" API_VERSION="1"
+    - os: osx
+      compiler: clang
+      env:  ACTION="ci/build_cmake.sh" CXX17="ON" ARCH="64"   BOOST="ON" SHARED="ON"  CHAR_SIGN="signed"   API_VERSION="3"
+    - os: osx
+      compiler: clang
+      env: ACTION="ci/build_cmake.sh"  CXX17="ON" ARCH="64"              SHARED="ON"  CHAR_SIGN="signed"   API_VERSION="2"
+    - os: osx
+      compiler: clang
+      env: ACTION="ci/build_cmake.sh"             ARCH="64"              SHARED="ON"  CHAR_SIGN="unsigned" API_VERSION="2"
+    - os: linux
+      compiler: clang
+      env: ACTION="ci/build_cmake.sh"             ARCH="64"   BOOST="ON" SHARED="ON"  CHAR_SIGN="unsigned" API_VERSION="1"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-5.0
+          packages:
+            - g++-multilib
+            - gcc-multilib
+            - gcc-7-multilib
+            - g++-7-multilib
+            - bzip2
+            - clang-5.0
+            - libc6-dbg
+    - os: linux
+      compiler: clang
+      env: ACTION="ci/build_cmake.sh"             ARCH="32"              SHARED="ON"  CHAR_SIGN="signed"   API_VERSION="2"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-5.0
+          packages:
+            - g++-multilib
+            - gcc-multilib
+            - gcc-7-multilib
+            - g++-7-multilib
+            - lib32stdc++6-6-dbg
+            - lib32gcc1
+            - libc6-i386
+            - lib32z1-dev
+            - zlib1g-dev
+            - bzip2
+            - clang-5.0
+            - libc6-dbg
+    - os: linux
+      compiler: clang
+      env: ACTION="ci/build_cmake.sh"  CXX17="ON" ARCH="64"   BOOST="ON" SHARED="ON"  CHAR_SIGN="signed"   API_VERSION="3" X3_PARSE="ON"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-5.0
+          packages:
+            - g++-multilib
+            - gcc-multilib
+            - gcc-7-multilib
+            - g++-7-multilib
+            - bzip2
+            - clang-5.0
+            - libc6-dbg
+    - os: linux
+      compiler: clang
+      env: ACTION="ci/build_cmake.sh"  CXX17="ON" ARCH="32"              SHARED="OFF" CHAR_SIGN="unsigned" API_VERSION="2"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-5.0
+          packages:
+            - g++-multilib
+            - gcc-multilib
+            - gcc-7-multilib
+            - g++-7-multilib
+            - lib32stdc++6-6-dbg
+            - lib32gcc1
+            - libc6-i386
+            - lib32z1-dev
+            - zlib1g-dev
+            - bzip2
+            - clang-5.0
+            - libc6-dbg
+    - os: linux
+      compiler: gcc
+      env: ACTION="ci/build_cmake.sh"  CXX17="ON" ARCH="64"              SHARED="ON"  CHAR_SIGN="signed"   API_VERSION="2"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-multilib
+            - gcc-multilib
+            - gcc-7-multilib
+            - g++-7-multilib
+            - bzip2
+            - libc6-dbg
+    - os: linux
+      compiler: gcc
+      env: ACTION="ci/build_cmake.sh"  CXX17="ON" ARCH="32"   BOOST="ON" SHARED="ON"  CHAR_SIGN="unsigned" API_VERSION="3" X3_PARSE="ON"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-multilib
+            - gcc-multilib
+            - gcc-7-multilib
+            - g++-7-multilib
+            - lib32stdc++6-6-dbg
+            - lib32gcc1
+            - libc6-i386
+            - lib32z1-dev
+            - zlib1g-dev
+            - bzip2
+            - libc6-dbg
+    - os: linux
+      compiler: gcc
+      env: ACTION="ci/build_cmake.sh"             ARCH="64"              SHARED="ON"  CHAR_SIGN="unsigned" API_VERSION="2"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-multilib
+            - gcc-multilib
+            - gcc-7-multilib
+            - g++-7-multilib
+            - bzip2
+            - libc6-dbg
+    - os: linux
+      compiler: gcc
+      env: ACTION="ci/build_cmake.sh"             ARCH="32"   BOOST="ON" SHARED="OFF" CHAR_SIGN="signed"   API_VERSION="1"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-multilib
+            - gcc-multilib
+            - gcc-7-multilib
+            - g++-7-multilib
+            - lib32stdc++6-6-dbg
+            - lib32gcc1
+            - libc6-i386
+            - lib32z1-dev
+            - zlib1g-dev
+            - bzip2
+            - libc6-dbg
+    - os: linux
+      compiler: gcc
+      env: ACTION="ci/build_cmake.sh"             ARCH="32"   BOOST="ON" SHARED="OFF" CHAR_SIGN="signed"   API_VERSION="2"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-multilib
+            - gcc-multilib
+            - gcc-7-multilib
+            - g++-7-multilib
+            - lib32stdc++6-6-dbg
+            - lib32gcc1
+            - libc6-i386
+            - lib32z1-dev
+            - zlib1g-dev
+            - bzip2
+            - libc6-dbg
+    - os: linux
+      compiler: clang
+      env: ACTION="ci/build_regression.sh"         ARCH="64" SAN="UBSAN" MSGPACK_FUZZ_REGRESSION="ON"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-5.0
+          packages:
+            - bzip2
+            - clang-5.0
+      script:
+        - CMAKE_CXX_COMPILER="${CXX}" CMAKE_C_COMPILER="${CC}" CMAKE_LIBRARY_PATH="${BASE}" GTEST_ROOT="${BASE}/gtest" BOOST_ROOT="${BASE}/boost" CTEST_OUTPUT_ON_FAILURE=1 MSGPACK_SAN="${SAN}" ci/build_regression.sh
+    - os: linux
+      compiler: clang
+      env: ACTION="ci/build_regression.sh"         ARCH="64" SAN="ASAN" MSGPACK_FUZZ_REGRESSION="ON"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-5.0
+          packages:
+            - bzip2
+            - clang-5.0
+      script:
+        - CMAKE_CXX_COMPILER="${CXX}" CMAKE_C_COMPILER="${CC}" CMAKE_LIBRARY_PATH="${BASE}" GTEST_ROOT="${BASE}/gtest" BOOST_ROOT="${BASE}/boost" CTEST_OUTPUT_ON_FAILURE=1 MSGPACK_SAN="${SAN}" ci/build_regression.sh
+
+
+script:
+  - CMAKE_CXX_COMPILER="${CXX}" CMAKE_C_COMPILER="${CC}" CMAKE_LIBRARY_PATH="${BASE}/usr/lib:${BASE}/build" GTEST_ROOT="${BASE}/usr" BOOST_ROOT="${BASE}/usr" CFLAGS="-Werror -g" CXXFLAGS="-Werror -g" ${ACTION}
+  - cat Files.cmake| grep ".*\.[h|hpp]" | perl -pe 's/ //g' | sort > tmp1  && find include -name "*.h" -o -name "*.hpp" | sort > tmp2 && diff tmp1 tmp2

AUTHORS

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

CHANGELOG.md

@@ -0,0 +1,367 @@
+# 2018-08-10 version 3.1.0
+
+  * Improve documents (#687, #718)
+  * Add fuzzer support (#689)
+  * Fix msgpack::object union member access bug (#694)
+  * Improve cross platform configuration (#704)
+  * Fix out of range dereference bug of EXT (#705)
+  * Add timestamp support. std::chrono::system_clock::time_point is mapped to TIMESTAMP (#706)
+  * Add minimal timestamp support for C. The type `msgpack_timestamp` and the function `msgpack_object_to_timestamp()` are introduced (#707)
+  * Improve MSGPACK_DEFINE family name confliction probability (#710)
+  * Add no static-library build option (BUILD_SHARED_LIBS=ON) (#713, #717, #722)
+  * Add header only cmake target (#721)
+  * Add `std::byte` adaptor (#719)
+  * Remove some warnings (#720)
+
+# 2018-05-12 version 3.0.1
+
+  * Add fuzz directory to release tar ball (#686)
+  * Add include file checking for X-Code (#683)
+
+# 2018-05-09 version 3.0.0
+
+## << breaking changes >>
+
+  * Change offset parameter updating rule. If parse error happens, offset is updated to the error position. (#639, #666)
+
+## << other updates >>
+
+  * Improve cross platform configuration (#655, #677)
+  * Improve build system (#647)
+  * Improve user class adaptor (#645, #673)
+  * Improve msgpack::object visitation logic (#676)
+  * Remove some warnings (#641, 659)
+  * Add `->` and `*` operators to object_handle (#635)
+  * Improve CI environment (#631, #634, #643, #657, #662, #668)
+  * Improve documents (#630, #661)
+  * Refactoring (#670)
+  * Add OSS-Fuzz support (#672, #674, #675, #678)
+
+# 2017-08-04 version 2.1.5
+  * Improve cross platform configuration (#624)
+  * Add boost asio examples (including zlib) (#610)
+  * Remove some warnings (#611)
+  * Fix unpack visitor to treat float32/64 correctly (#613)
+  * Improve documents (#616)
+  * Fix alignment problem on some platform (#617, #518)
+  * Fix conflict std::tuple, std::pair, and boost::fusion::sequence problem (#619)
+
+# 2017-08-03 version 2.1.4 (Invalid)
+  * See https://github.com/msgpack/msgpack-c/issues/623
+
+# 2017-06-15 version 2.1.3
+  * Improve build system (#603)
+  * Add C++17 adaptors `std::optional` and `std::string_view`. (#607, #608)
+  * Improve cross platform configuration (#601)
+  * Remove some warnings (#599, #602, #605)
+
+# 2017-06-07 version 2.1.2
+
+* Improve documents (#565)
+  * Fix empty map parse bug (#568)
+  * Improve build system (#569, #570, #572, #579, #591, #592)
+  * Remove some warnings (#574, #578, #586, #588)
+  * Improve cross platform configuration (#577, #582)
+  * Add cmake package config support (#580)
+  * Fix streaming unpack bug (#585)
+
+# 2017-02-04 version 2.1.1
+
+  * Fix unpacker's buffer management bug (#561)
+  * Add boost string_view adaptor (#558)
+  * Remove some warnings (#557, #559)
+  * Improve coding style (#556)
+
+# 2017-01-10 version 2.1.0
+
+## << breaking changes >>
+
+  * Fix object internal data type is float if msgpack format is float32 (#531)
+
+## << recommended changes >>
+
+  * Add `FLOAT64` type. Please use it instead of `DOUBLE` (#531)
+  * Add `FLOAT32` type. Please use it instead of `FLOAT` (#531)
+
+## << other updates >>
+
+  * Add iterator based parse/unpack function(experimental) (#553)
+  * Add `[[deprecated]]` attribute for C++14 (#552)
+  * Fix `msgpack_unpack()` return code (#548)
+  * Fix integer overflow (#547, #549, #550)
+  * Add example codes (#542)
+  * Add MSGPACK_NVP. You can use not only variable name but also any strings (#535)
+  * Fix and Improve build system (#532, #545)
+  * Fix `gcc_atomic.hpp` include path (#529, #530)
+  * Improve CI environment (#526)
+  * Improve documents (#524)
+  * Add msgpack_unpacker_next_with_size() function (#515)
+  * Fix `as()` applying condition (#511)
+  * Fix fbuffer write (#504)
+  * Add gcc bug workaround (#499)
+  * Improve object print (#497, #500, #505, #533)
+  * Remove some warnings (#495, #506, #508, #513, #528, #538, #545)
+
+# 2016-06-25 version 2.0.0
+
+## << breaking changes >>
+
+  * Removed autotools support. Use cmake instead (#476, #479)
+  * Removed pointer version of msgpack::unpack APIs. Use reference version instead (#453)
+  * Removed MSGPACK_DISABLE_LEGACY_CONVERT. msgpack::object::convert(T*) is removed by default. Use msgpack::object::convert(T&) instead (#451)
+  * Removed msgpacl::type::nil. Use nil_t or define MSGPACK_USE_LECACY_NIL (#444)
+  * Removed std::string to msgpack::object conversion (#434)
+
+## << recommended changes >>
+
+  * Replaced msgpack::unpacked with msgpack::object_handle. msgpack::unpacked is kept as a typedef of msgpack::object_handle. (#448)
+
+## << other updates >>
+
+  * Add strict size checking adaptor. Relaxed tuple conversion (#489)
+  * Fix and Improve example codes (#487)
+  * Add C++/CLI support for nullptr (#481)
+  * Update the boost libraries that are contained by msgpack-c (#475)
+  * Fix gcc_atomic.hpp location (#474)
+  * Add C-Style array support (#466, #488)
+  * Fix include file dependency (#464)
+  * Add a visitor version of unpack API (#461)
+  * Fix JSON string conversion from "nil" to "null" (#458)
+  * Fix and Improve build system (#455, #471, #473, #486, #491)
+  * Fix comments (#452)
+  * Fix unintentional msgpack::zone moving problem (#447)
+  * Fix operator>> and << for msgpack::object (#443)
+  * Fix C++03 msgpack::zone::clear() memory access violation bug (#441)
+  * Fix TARGET_OS_IPHONE checking (#436)
+  * Fix invalid front() call for empty container (#435)
+  * Fix compile error on g++6 (C++11 only) (#426, #430)
+  * Fix zone size expansion logic (#423)
+  * Fix wrong hader file dependency (#421)
+  * Fix msvc specific problem (#420)
+  * Add v2 API support (#415)
+
+# 2016-01-22 version 1.4.0
+
+## << recommended changes >>
+
+  * Define [MSGPACK_DISABLE_LEGACY_NIL](https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_configure#msgpack_disable_legacy_nil-since-140), then `msgpack::type::nil` is replaced by with `msgpack::type::nil_t` (#408, #411, #412).
+    Replace `msgpack::type::nil` with `msgpack::type::nil_t` in client codes.
+    `msgpack::type::nil` will be removed on the version 2.0.0.
+  * Define [MSGPACK_DISABLE_LEGACY_CONVERT](https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_configure#msgpack_disable_legacy_convert-since-140), then `msgpack::object::convert(T*)` is removed (#410).
+    Replace calling `msgpack::bojectconvert(T*)` with `msgpack::bojectconvert(T&)` in client codes as follows:
+
+    ```C++
+     int i;
+     obj.convert(&i); // before
+     ```
+
+    ```C++
+     int i;
+     obj.convert(i);  // after
+     ```
+
+    `msgpack::object::convert(T*)` will be removed on the version 2.0.0.
+
+Define the macros above as follows when you compile C++ codes that use msgpack-c:
+
+```
+g++ -Ipath_to_msgpack/include -DMSGPACK_DISABLE_LEGACY_NIL -DMSGPACK_DISABLE_LEGACY_CONVERT your_code.cpp
+
+```
+
+You can compile existing codes without defining macros above but I recommend defining them and updating your codes to fix the issues #408, #411, #412, #399, and #410. It is also a good preparation for the version 2.0.0.
+
+## << other updates >>
+
+  * Improve documents (#387, #407)
+  * Remove C++ version library (#394, #402)
+  * Add Doxyfile and ChangeLog to the distribution package (#397)
+  * Add signed/unsigned char test to travis-ci (#398)
+  * Remove some warnings (#400, #401, #409)
+  * Fix endian checking. (#404)
+
+# 2015-11-21 version 1.3.0
+
+  * Change the license from the Apache License Version 2.0 to the
+    Boost Software License, Version 1.0.(#386)
+  * Remove some warnings (#365)
+  * Add std::reference_wrapper support(#373, #384)
+  * Improve tests (#375, #378, #379, #380)
+  * Fix msvc specific problem (#376, #383)
+  * Fix typos (#381)
+
+# 2015-09-04 version 1.2.0
+
+## << breaking changes >>
+
+  * Change std::vector<unsigned char> and std::array<unsigned char>
+    mapped to BIN instead of ARRAY (#243)
+  * Remove redundant copy (#285)
+
+
+## << other updates >>
+
+  * 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 changes >>
+
+  * 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
+
+
+## << other updates >>
+
+  * 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,448 @@
+CMAKE_MINIMUM_REQUIRED (VERSION 2.8.12)
+
+IF ((CMAKE_VERSION VERSION_GREATER 3.1) OR
+    (CMAKE_VERSION VERSION_EQUAL 3.1))
+    CMAKE_POLICY(SET CMP0054 NEW)
+ENDIF ()
+
+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")
+SET (GNUCXX_STD_SUPPORT_VERSION "4.3")
+
+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_USE_X3_PARSE)
+   IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+      SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_X3_PARSE -std=c++14 ${CMAKE_CXX_FLAGS}")
+   ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+      SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_X3_PARSE -std=c++14 ${CMAKE_CXX_FLAGS}")
+   ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+      SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_X3_PARSE ${CMAKE_CXX_FLAGS}")
+      IF (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19)
+          MESSAGE ( FATAL_ERROR "MSVC doesn't support C++14.")
+      ENDIF ()
+   ENDIF ()
+ELSE ()
+   IF (MSGPACK_CXX17)
+      IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+         SET (CMAKE_CXX_FLAGS "-std=c++17 ${CMAKE_CXX_FLAGS}")
+      ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+         SET (CMAKE_CXX_FLAGS "-std=c++17 ${CMAKE_CXX_FLAGS}")
+      ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+         MESSAGE ( FATAL_ERROR "MSVC doesn't support C++17.")
+      ENDIF ()
+   ELSEIF (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")
+         IF ((CMAKE_CXX_COMPILER_VERSION VERSION_GREATER ${GNUCXX_STD_SUPPORT_VERSION}) OR
+             (CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL   ${GNUCXX_STD_SUPPORT_VERSION}))
+             SET (CMAKE_CXX_FLAGS "-std=c++98 ${CMAKE_CXX_FLAGS}")
+         ENDIF ()
+      ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+         SET (CMAKE_CXX_FLAGS "-std=c++98 ${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 ()
+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 ()
+
+OPTION (MSGPACK_BUILD_EXAMPLES "Build msgpack examples." ON)
+
+IF (MSGPACK_BOOST)
+   SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_BOOST ${CMAKE_CXX_FLAGS}")
+   SET (Boost_USE_MULTITHREADED      ON)
+   SET (Boost_USE_STATIC_RUNTIME    OFF)
+   FIND_PACKAGE (Boost REQUIRED COMPONENTS chrono context system timer)
+   INCLUDE_DIRECTORIES (
+      ${Boost_INCLUDE_DIRS}
+   )
+   LINK_DIRECTORIES (
+      ${Boost_LIBRARY_DIRS}
+   )
+   IF (MSGPACK_BOOST_DIR)
+      INCLUDE_DIRECTORIES (
+         ${MSGPACK_BOOST_DIR}
+      )
+   ENDIF ()
+ENDIF ()
+
+IF (MSGPACK_CHAR_SIGN)
+   SET (CMAKE_C_FLAGS "-f${MSGPACK_CHAR_SIGN}-char ${CMAKE_C_FLAGS}")
+   SET (CMAKE_CXX_FLAGS "-f${MSGPACK_CHAR_SIGN}-char ${CMAKE_CXX_FLAGS}")
+ENDIF ()
+
+IF (MSGPACK_DEFAULT_API_VERSION)
+   SET (CMAKE_CXX_FLAGS "-DMSGPACK_DEFAULT_API_VERSION=${MSGPACK_DEFAULT_API_VERSION} ${CMAKE_CXX_FLAGS}")
+ELSE ()
+   SET (CMAKE_CXX_FLAGS "-DMSGPACK_DEFAULT_API_VERSION=3 ${CMAKE_CXX_FLAGS}")
+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 (GENERATE OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/${F} CONTENT ${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 (GENERATE OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/${F} CONTENT ${CONTENT})
+ENDFOREACH ()
+
+FIND_PACKAGE (GTest)
+FIND_PACKAGE (ZLIB)
+FIND_PACKAGE (Threads)
+IF (GTEST_FOUND AND ZLIB_FOUND AND THREADS_FOUND AND NOT "${MSGPACK_FUZZ_REGRESSION}" STREQUAL "ON")
+    OPTION (MSGPACK_BUILD_TESTS "Build msgpack tests." ON)
+ENDIF ()
+
+IF (DEFINED BUILD_SHARED_LIBS)
+    IF (BUILD_SHARED_LIBS)
+        IF (DEFINED MSGPACK_ENABLE_SHARED AND NOT MSGPACK_ENABLE_SHARED)
+            MESSAGE(WARNING "MSGPACK_ENABLE_SHARED is overridden to ON by BUILD_SHARED_LIBS")
+        ENDIF ()
+        SET (MSGPACK_ENABLE_SHARED ON)
+        IF (DEFINED MSGPACK_ENABLE_STATIC AND MSGPACK_ENABLE_STATIC)
+            MESSAGE(WARNING "MSGPACK_ENABLE_STATIC is overridden to OFF by BUILD_SHARED_LIBS")
+        ENDIF ()
+        SET (MSGPACK_ENABLE_STATIC OFF)
+    ELSE ()
+        IF (DEFINED MSGPACK_ENABLE_SHARED AND MSGPACK_ENABLE_SHARED)
+            MESSAGE(WARNING "MSGPACK_ENABLE_SHARED is overridden to OFF by BUILD_SHARED_LIBS")
+        ENDIF ()
+        SET (MSGPACK_ENABLE_SHARED OFF)
+        IF (DEFINED MSGPACK_ENABLE_STATIC AND NOT MSGPACK_ENABLE_STATIC)
+            MESSAGE(WARNING "MSGPACK_ENABLE_STATIC is overridden to ON by BUILD_SHARED_LIBS")
+        ENDIF ()
+        SET (MSGPACK_ENABLE_STATIC ON)
+    ENDIF ()
+ELSE ()
+    IF (NOT DEFINED MSGPACK_ENABLE_SHARED)
+        SET (MSGPACK_ENABLE_SHARED ON)
+    ENDIF ()
+    IF (NOT DEFINED MSGPACK_ENABLE_STATIC)
+        SET (MSGPACK_ENABLE_STATIC ON)
+    ENDIF ()
+ENDIF ()
+
+OPTION (MSGPACK_ENABLE_CXX "Enable C++ interface." 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)
+
+INCLUDE (Files.cmake)
+
+EXECUTE_PROCESS (
+    COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/src/msgpack
+)
+
+CONFIGURE_FILE (
+    msgpack.pc.in
+    msgpack.pc
+    @ONLY
+)
+
+IF (MSGPACK_ENABLE_SHARED)
+    ADD_LIBRARY (msgpackc SHARED
+        ${msgpackc_SOURCES}
+        ${msgpackc_HEADERS}
+    )
+
+    SET_TARGET_PROPERTIES (msgpackc PROPERTIES SOVERSION 2 VERSION 2.0.0)
+
+    TARGET_INCLUDE_DIRECTORIES (msgpackc
+        PUBLIC
+            $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+            $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
+            $<INSTALL_INTERFACE:include>
+        PRIVATE
+            ${CMAKE_CURRENT_SOURCE_DIR}
+    )
+ENDIF ()
+
+IF (MSGPACK_ENABLE_CXX AND ((CMAKE_VERSION VERSION_GREATER 3.0) OR (CMAKE_VERSION VERSION_EQUAL 3.0)))
+    ADD_LIBRARY (msgpackc-cxx INTERFACE)
+
+    TARGET_INCLUDE_DIRECTORIES (msgpackc-cxx
+        INTERFACE
+            $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+            $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
+            $<INSTALL_INTERFACE:include>
+    )
+ENDIF ()
+
+IF (MSGPACK_ENABLE_STATIC)
+    ADD_LIBRARY (msgpackc-static STATIC
+        ${msgpackc_SOURCES}
+        ${msgpackc_HEADERS}
+    )
+
+    TARGET_INCLUDE_DIRECTORIES (msgpackc-static
+        PUBLIC
+            $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+            $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
+            $<INSTALL_INTERFACE:include>
+        PRIVATE
+            ${CMAKE_CURRENT_SOURCE_DIR}
+    )
+
+    IF (NOT MSGPACK_ENABLE_SHARED)
+        # Add alias for subdirectories
+        ADD_LIBRARY (msgpackc ALIAS msgpackc-static)
+    ENDIF ()
+
+    SET_TARGET_PROPERTIES (msgpackc-static PROPERTIES OUTPUT_NAME "msgpackc")
+
+    IF (MSGPACK_ENABLE_SHARED)
+        IF (MSVC)
+            SET_TARGET_PROPERTIES (msgpackc PROPERTIES IMPORT_SUFFIX "_import.lib")
+        ELSEIF (MINGW)
+            SET_TARGET_PROPERTIES (msgpackc PROPERTIES IMPORT_SUFFIX ".dll.a")
+        ENDIF ()
+    ENDIF ()
+ENDIF ()
+
+# enable regression testing
+IF ("${MSGPACK_FUZZ_REGRESSION}" STREQUAL "ON" AND "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+   SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_BOOST ${CMAKE_CXX_FLAGS}")
+   SET (Boost_USE_MULTITHREADED      ON)
+   SET (Boost_USE_STATIC_RUNTIME    OFF)
+
+   enable_testing ()
+   ADD_SUBDIRECTORY (fuzz)
+   SET (MSGPACK_BUILD_EXAMPLES OFF)
+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 msgpackc APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra -DPIC")
+    ENDIF ()
+    IF (MSGPACK_ENABLE_STATIC)
+       SET_PROPERTY (TARGET msgpackc-static APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra" )
+    ENDIF ()
+ENDIF ()
+
+IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+    IF (MSGPACK_ENABLE_SHARED)
+        SET_PROPERTY (TARGET msgpackc APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
+    ENDIF ()
+    IF (MSGPACK_ENABLE_STATIC)
+        SET_PROPERTY (TARGET msgpackc-static APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
+    ENDIF ()
+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(${msgpackc_SOURCES} PROPERTIES LANGUAGE CXX)
+ENDIF ()
+
+IF ("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "sparc")
+    SET (CMAKE_C_FLAGS   "-DMSGPACK_ZONE_ALIGN=8 ${CMAKE_C_FLAGS}")
+    SET (CMAKE_CXX_FLAGS "-DMSGPACK_ZONE_ALIGN=8 ${CMAKE_CXX_FLAGS}")
+ENDIF ()
+
+IF (NOT DEFINED CMAKE_INSTALL_BINDIR)
+    SET(CMAKE_INSTALL_BINDIR bin)
+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 msgpackc)
+ENDIF ()
+
+IF (MSGPACK_ENABLE_CXX AND ((CMAKE_VERSION VERSION_GREATER 3.0) OR (CMAKE_VERSION VERSION_EQUAL 3.0)))
+    LIST (APPEND MSGPACK_INSTALLTARGETS msgpackc-cxx)
+ENDIF ()
+
+IF (MSGPACK_ENABLE_STATIC)
+    LIST (APPEND MSGPACK_INSTALLTARGETS msgpackc-static)
+ENDIF ()
+
+INSTALL (TARGETS ${MSGPACK_INSTALLTARGETS} EXPORT msgpack-targets
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+)
+FOREACH (file ${msgpackc_HEADERS})
+    GET_FILENAME_COMPONENT (dir ${file} PATH)
+    INSTALL (FILES ${file} DESTINATION ${CMAKE_INSTALL_PREFIX}/${dir})
+ENDFOREACH ()
+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
+        COMMAND ${CMAKE_COMMAND} -E echo "STRIP_FROM_PATH    = ${CMAKE_CURRENT_SOURCE_DIR}/include" >> ${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
+        COMMAND ${CMAKE_COMMAND} -E echo "STRIP_FROM_PATH    = ${CMAKE_CURRENT_SOURCE_DIR}/include" >> ${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 ()
+
+INCLUDE (CMakePackageConfigHelpers)
+
+SET (CMAKE_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/msgpack")
+
+WRITE_BASIC_PACKAGE_VERSION_FILE (
+    msgpack-config-version.cmake
+    VERSION ${VERSION}
+    COMPATIBILITY SameMajorVersion
+)
+
+IF (NOT CMAKE_VERSION VERSION_LESS 3.0)
+    EXPORT (EXPORT msgpack-targets
+        FILE "${CMAKE_CURRENT_BINARY_DIR}/msgpack-targets.cmake"
+    )
+ENDIF ()
+
+CONFIGURE_PACKAGE_CONFIG_FILE (msgpack-config.cmake.in
+    msgpack-config.cmake
+    INSTALL_DESTINATION "${CMAKE_INSTALL_CMAKEDIR}"
+)
+
+INSTALL (EXPORT msgpack-targets
+    FILE
+        msgpack-targets.cmake
+    DESTINATION
+        "${CMAKE_INSTALL_CMAKEDIR}"
+)
+
+INSTALL (
+    FILES
+        "${CMAKE_CURRENT_BINARY_DIR}/msgpack-config.cmake"
+        "${CMAKE_CURRENT_BINARY_DIR}/msgpack-config-version.cmake"
+    DESTINATION
+        "${CMAKE_INSTALL_CMAKEDIR}"
+)

COPYING

@@ -1,14 +1,5 @@
-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.
+Copyright (C) 2008-2015 FURUHASHI Sadayuki
 
+   Distributed under the Boost Software License, Version 1.0.
+   (See accompanying file LICENSE_1_0.txt or copy at
+   http://www.boost.org/LICENSE_1_0.txt)

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

Doxyfile

@@ -281,7 +281,7 @@ TYPEDEF_HIDES_STRUCT   = NO
 # causing a significant performance penality.
 # If the system has enough physical memory increasing the cache will improve the
 # performance by keeping more symbols in memory. Note that the value works on
-# a logarithmic scale so increasing the size by one will rougly double the
+# a logarithmic scale so increasing the size by one will roughly double the
 # memory usage. The cache size is given by this formula:
 # 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0,
 # corresponding to a cache size of 2^16 = 65536 symbols

Files.cmake

@@ -0,0 +1,735 @@
+LIST (APPEND msgpackc_SOURCES
+    src/objectc.c
+    src/unpack.c
+    src/version.c
+    src/vrefbuffer.c
+    src/zone.c
+)
+LIST (APPEND msgpackc_HEADERS
+    include/msgpack.h
+    include/msgpack/fbuffer.h
+    include/msgpack/gcc_atomic.h
+    include/msgpack/object.h
+    include/msgpack/pack.h
+    include/msgpack/pack_define.h
+    include/msgpack/pack_template.h
+    include/msgpack/predef.h
+    include/msgpack/predef/architecture.h
+    include/msgpack/predef/architecture/alpha.h
+    include/msgpack/predef/architecture/arm.h
+    include/msgpack/predef/architecture/blackfin.h
+    include/msgpack/predef/architecture/convex.h
+    include/msgpack/predef/architecture/ia64.h
+    include/msgpack/predef/architecture/m68k.h
+    include/msgpack/predef/architecture/mips.h
+    include/msgpack/predef/architecture/parisc.h
+    include/msgpack/predef/architecture/ppc.h
+    include/msgpack/predef/architecture/pyramid.h
+    include/msgpack/predef/architecture/rs6k.h
+    include/msgpack/predef/architecture/sparc.h
+    include/msgpack/predef/architecture/superh.h
+    include/msgpack/predef/architecture/sys370.h
+    include/msgpack/predef/architecture/sys390.h
+    include/msgpack/predef/architecture/x86.h
+    include/msgpack/predef/architecture/x86/32.h
+    include/msgpack/predef/architecture/x86/64.h
+    include/msgpack/predef/architecture/z.h
+    include/msgpack/predef/compiler.h
+    include/msgpack/predef/compiler/borland.h
+    include/msgpack/predef/compiler/clang.h
+    include/msgpack/predef/compiler/comeau.h
+    include/msgpack/predef/compiler/compaq.h
+    include/msgpack/predef/compiler/diab.h
+    include/msgpack/predef/compiler/digitalmars.h
+    include/msgpack/predef/compiler/dignus.h
+    include/msgpack/predef/compiler/edg.h
+    include/msgpack/predef/compiler/ekopath.h
+    include/msgpack/predef/compiler/gcc.h
+    include/msgpack/predef/compiler/gcc_xml.h
+    include/msgpack/predef/compiler/greenhills.h
+    include/msgpack/predef/compiler/hp_acc.h
+    include/msgpack/predef/compiler/iar.h
+    include/msgpack/predef/compiler/ibm.h
+    include/msgpack/predef/compiler/intel.h
+    include/msgpack/predef/compiler/kai.h
+    include/msgpack/predef/compiler/llvm.h
+    include/msgpack/predef/compiler/metaware.h
+    include/msgpack/predef/compiler/metrowerks.h
+    include/msgpack/predef/compiler/microtec.h
+    include/msgpack/predef/compiler/mpw.h
+    include/msgpack/predef/compiler/palm.h
+    include/msgpack/predef/compiler/pgi.h
+    include/msgpack/predef/compiler/sgi_mipspro.h
+    include/msgpack/predef/compiler/sunpro.h
+    include/msgpack/predef/compiler/tendra.h
+    include/msgpack/predef/compiler/visualc.h
+    include/msgpack/predef/compiler/watcom.h
+    include/msgpack/predef/detail/_cassert.h
+    include/msgpack/predef/detail/_exception.h
+    include/msgpack/predef/detail/comp_detected.h
+    include/msgpack/predef/detail/endian_compat.h
+    include/msgpack/predef/detail/os_detected.h
+    include/msgpack/predef/detail/platform_detected.h
+    include/msgpack/predef/detail/test.h
+    include/msgpack/predef/detail/test_def.h
+    include/msgpack/predef/hardware.h
+    include/msgpack/predef/hardware/simd.h
+    include/msgpack/predef/hardware/simd/arm.h
+    include/msgpack/predef/hardware/simd/arm/versions.h
+    include/msgpack/predef/hardware/simd/ppc.h
+    include/msgpack/predef/hardware/simd/ppc/versions.h
+    include/msgpack/predef/hardware/simd/x86.h
+    include/msgpack/predef/hardware/simd/x86/versions.h
+    include/msgpack/predef/hardware/simd/x86_amd.h
+    include/msgpack/predef/hardware/simd/x86_amd/versions.h
+    include/msgpack/predef/language.h
+    include/msgpack/predef/language/objc.h
+    include/msgpack/predef/language/stdc.h
+    include/msgpack/predef/language/stdcpp.h
+    include/msgpack/predef/library.h
+    include/msgpack/predef/library/c.h
+    include/msgpack/predef/library/c/_prefix.h
+    include/msgpack/predef/library/c/gnu.h
+    include/msgpack/predef/library/c/uc.h
+    include/msgpack/predef/library/c/vms.h
+    include/msgpack/predef/library/c/zos.h
+    include/msgpack/predef/library/std.h
+    include/msgpack/predef/library/std/_prefix.h
+    include/msgpack/predef/library/std/cxx.h
+    include/msgpack/predef/library/std/dinkumware.h
+    include/msgpack/predef/library/std/libcomo.h
+    include/msgpack/predef/library/std/modena.h
+    include/msgpack/predef/library/std/msl.h
+    include/msgpack/predef/library/std/roguewave.h
+    include/msgpack/predef/library/std/sgi.h
+    include/msgpack/predef/library/std/stdcpp3.h
+    include/msgpack/predef/library/std/stlport.h
+    include/msgpack/predef/library/std/vacpp.h
+    include/msgpack/predef/make.h
+    include/msgpack/predef/os.h
+    include/msgpack/predef/os/aix.h
+    include/msgpack/predef/os/amigaos.h
+    include/msgpack/predef/os/android.h
+    include/msgpack/predef/os/beos.h
+    include/msgpack/predef/os/bsd.h
+    include/msgpack/predef/os/bsd/bsdi.h
+    include/msgpack/predef/os/bsd/dragonfly.h
+    include/msgpack/predef/os/bsd/free.h
+    include/msgpack/predef/os/bsd/net.h
+    include/msgpack/predef/os/bsd/open.h
+    include/msgpack/predef/os/cygwin.h
+    include/msgpack/predef/os/haiku.h
+    include/msgpack/predef/os/hpux.h
+    include/msgpack/predef/os/ios.h
+    include/msgpack/predef/os/irix.h
+    include/msgpack/predef/os/linux.h
+    include/msgpack/predef/os/macos.h
+    include/msgpack/predef/os/os400.h
+    include/msgpack/predef/os/qnxnto.h
+    include/msgpack/predef/os/solaris.h
+    include/msgpack/predef/os/unix.h
+    include/msgpack/predef/os/vms.h
+    include/msgpack/predef/os/windows.h
+    include/msgpack/predef/other.h
+    include/msgpack/predef/other/endian.h
+    include/msgpack/predef/platform.h
+    include/msgpack/predef/platform/mingw.h
+    include/msgpack/predef/platform/windows_desktop.h
+    include/msgpack/predef/platform/windows_phone.h
+    include/msgpack/predef/platform/windows_runtime.h
+    include/msgpack/predef/platform/windows_store.h
+    include/msgpack/predef/version.h
+    include/msgpack/predef/version_number.h
+    include/msgpack/sbuffer.h
+    include/msgpack/sysdep.h
+    include/msgpack/timestamp.h
+    include/msgpack/unpack.h
+    include/msgpack/unpack_define.h
+    include/msgpack/unpack_template.h
+    include/msgpack/util.h
+    include/msgpack/version.h
+    include/msgpack/version_master.h
+    include/msgpack/vrefbuffer.h
+    include/msgpack/zbuffer.h
+    include/msgpack/zone.h
+)
+IF (MSGPACK_ENABLE_CXX)
+    LIST (APPEND msgpackc_HEADERS
+        include/msgpack.hpp
+        include/msgpack/adaptor/adaptor_base.hpp
+        include/msgpack/adaptor/adaptor_base_decl.hpp
+        include/msgpack/adaptor/array_ref.hpp
+        include/msgpack/adaptor/array_ref_decl.hpp
+        include/msgpack/adaptor/bool.hpp
+        include/msgpack/adaptor/boost/fusion.hpp
+        include/msgpack/adaptor/boost/msgpack_variant.hpp
+        include/msgpack/adaptor/boost/msgpack_variant_decl.hpp
+        include/msgpack/adaptor/boost/optional.hpp
+        include/msgpack/adaptor/boost/string_ref.hpp
+        include/msgpack/adaptor/boost/string_view.hpp
+        include/msgpack/adaptor/carray.hpp
+        include/msgpack/adaptor/char_ptr.hpp
+        include/msgpack/adaptor/check_container_size.hpp
+        include/msgpack/adaptor/check_container_size_decl.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/chrono.hpp
+        include/msgpack/adaptor/cpp11/forward_list.hpp
+        include/msgpack/adaptor/cpp11/reference_wrapper.hpp
+        include/msgpack/adaptor/cpp11/shared_ptr.hpp
+        include/msgpack/adaptor/cpp11/tuple.hpp
+        include/msgpack/adaptor/cpp11/unique_ptr.hpp
+        include/msgpack/adaptor/cpp11/unordered_map.hpp
+        include/msgpack/adaptor/cpp11/unordered_set.hpp
+        include/msgpack/adaptor/cpp17/byte.hpp
+        include/msgpack/adaptor/cpp17/carray_byte.hpp
+        include/msgpack/adaptor/cpp17/optional.hpp
+        include/msgpack/adaptor/cpp17/string_view.hpp
+        include/msgpack/adaptor/cpp17/vector_byte.hpp
+        include/msgpack/adaptor/define.hpp
+        include/msgpack/adaptor/define_decl.hpp
+        include/msgpack/adaptor/deque.hpp
+        include/msgpack/adaptor/ext.hpp
+        include/msgpack/adaptor/ext_decl.hpp
+        include/msgpack/adaptor/fixint.hpp
+        include/msgpack/adaptor/fixint_decl.hpp
+        include/msgpack/adaptor/float.hpp
+        include/msgpack/adaptor/int.hpp
+        include/msgpack/adaptor/int_decl.hpp
+        include/msgpack/adaptor/list.hpp
+        include/msgpack/adaptor/map.hpp
+        include/msgpack/adaptor/map_decl.hpp
+        include/msgpack/adaptor/msgpack_tuple.hpp
+        include/msgpack/adaptor/msgpack_tuple_decl.hpp
+        include/msgpack/adaptor/nil.hpp
+        include/msgpack/adaptor/nil_decl.hpp
+        include/msgpack/adaptor/pair.hpp
+        include/msgpack/adaptor/raw.hpp
+        include/msgpack/adaptor/raw_decl.hpp
+        include/msgpack/adaptor/set.hpp
+        include/msgpack/adaptor/size_equal_only.hpp
+        include/msgpack/adaptor/size_equal_only_decl.hpp
+        include/msgpack/adaptor/string.hpp
+        include/msgpack/adaptor/tr1/unordered_map.hpp
+        include/msgpack/adaptor/tr1/unordered_set.hpp
+        include/msgpack/adaptor/v4raw.hpp
+        include/msgpack/adaptor/v4raw_decl.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/cpp_config_decl.hpp
+        include/msgpack/create_object_visitor.hpp
+        include/msgpack/create_object_visitor_decl.hpp
+        include/msgpack/fbuffer.hpp
+        include/msgpack/fbuffer_decl.hpp
+        include/msgpack/gcc_atomic.hpp
+        include/msgpack/iterator.hpp
+        include/msgpack/iterator_decl.hpp
+        include/msgpack/meta.hpp
+        include/msgpack/meta_decl.hpp
+        include/msgpack/null_visitor.hpp
+        include/msgpack/null_visitor_decl.hpp
+        include/msgpack/object.hpp
+        include/msgpack/object_decl.hpp
+        include/msgpack/object_fwd.hpp
+        include/msgpack/object_fwd_decl.hpp
+        include/msgpack/pack.hpp
+        include/msgpack/pack_decl.hpp
+        include/msgpack/parse.hpp
+        include/msgpack/parse_decl.hpp
+        include/msgpack/parse_return.hpp
+        include/msgpack/preprocessor.hpp
+        include/msgpack/preprocessor/arithmetic.hpp
+        include/msgpack/preprocessor/arithmetic/add.hpp
+        include/msgpack/preprocessor/arithmetic/dec.hpp
+        include/msgpack/preprocessor/arithmetic/detail/div_base.hpp
+        include/msgpack/preprocessor/arithmetic/div.hpp
+        include/msgpack/preprocessor/arithmetic/inc.hpp
+        include/msgpack/preprocessor/arithmetic/mod.hpp
+        include/msgpack/preprocessor/arithmetic/mul.hpp
+        include/msgpack/preprocessor/arithmetic/sub.hpp
+        include/msgpack/preprocessor/array.hpp
+        include/msgpack/preprocessor/array/data.hpp
+        include/msgpack/preprocessor/array/detail/get_data.hpp
+        include/msgpack/preprocessor/array/elem.hpp
+        include/msgpack/preprocessor/array/enum.hpp
+        include/msgpack/preprocessor/array/insert.hpp
+        include/msgpack/preprocessor/array/pop_back.hpp
+        include/msgpack/preprocessor/array/pop_front.hpp
+        include/msgpack/preprocessor/array/push_back.hpp
+        include/msgpack/preprocessor/array/push_front.hpp
+        include/msgpack/preprocessor/array/remove.hpp
+        include/msgpack/preprocessor/array/replace.hpp
+        include/msgpack/preprocessor/array/reverse.hpp
+        include/msgpack/preprocessor/array/size.hpp
+        include/msgpack/preprocessor/array/to_list.hpp
+        include/msgpack/preprocessor/array/to_seq.hpp
+        include/msgpack/preprocessor/array/to_tuple.hpp
+        include/msgpack/preprocessor/assert_msg.hpp
+        include/msgpack/preprocessor/cat.hpp
+        include/msgpack/preprocessor/comma.hpp
+        include/msgpack/preprocessor/comma_if.hpp
+        include/msgpack/preprocessor/comparison.hpp
+        include/msgpack/preprocessor/comparison/equal.hpp
+        include/msgpack/preprocessor/comparison/greater.hpp
+        include/msgpack/preprocessor/comparison/greater_equal.hpp
+        include/msgpack/preprocessor/comparison/less.hpp
+        include/msgpack/preprocessor/comparison/less_equal.hpp
+        include/msgpack/preprocessor/comparison/not_equal.hpp
+        include/msgpack/preprocessor/config/config.hpp
+        include/msgpack/preprocessor/config/limits.hpp
+        include/msgpack/preprocessor/control.hpp
+        include/msgpack/preprocessor/control/deduce_d.hpp
+        include/msgpack/preprocessor/control/detail/dmc/while.hpp
+        include/msgpack/preprocessor/control/detail/edg/while.hpp
+        include/msgpack/preprocessor/control/detail/msvc/while.hpp
+        include/msgpack/preprocessor/control/detail/while.hpp
+        include/msgpack/preprocessor/control/expr_if.hpp
+        include/msgpack/preprocessor/control/expr_iif.hpp
+        include/msgpack/preprocessor/control/if.hpp
+        include/msgpack/preprocessor/control/iif.hpp
+        include/msgpack/preprocessor/control/while.hpp
+        include/msgpack/preprocessor/debug.hpp
+        include/msgpack/preprocessor/debug/assert.hpp
+        include/msgpack/preprocessor/debug/error.hpp
+        include/msgpack/preprocessor/debug/line.hpp
+        include/msgpack/preprocessor/dec.hpp
+        include/msgpack/preprocessor/detail/auto_rec.hpp
+        include/msgpack/preprocessor/detail/check.hpp
+        include/msgpack/preprocessor/detail/dmc/auto_rec.hpp
+        include/msgpack/preprocessor/detail/is_binary.hpp
+        include/msgpack/preprocessor/detail/is_nullary.hpp
+        include/msgpack/preprocessor/detail/is_unary.hpp
+        include/msgpack/preprocessor/detail/null.hpp
+        include/msgpack/preprocessor/detail/split.hpp
+        include/msgpack/preprocessor/empty.hpp
+        include/msgpack/preprocessor/enum.hpp
+        include/msgpack/preprocessor/enum_params.hpp
+        include/msgpack/preprocessor/enum_params_with_a_default.hpp
+        include/msgpack/preprocessor/enum_params_with_defaults.hpp
+        include/msgpack/preprocessor/enum_shifted.hpp
+        include/msgpack/preprocessor/enum_shifted_params.hpp
+        include/msgpack/preprocessor/expand.hpp
+        include/msgpack/preprocessor/expr_if.hpp
+        include/msgpack/preprocessor/facilities.hpp
+        include/msgpack/preprocessor/facilities/apply.hpp
+        include/msgpack/preprocessor/facilities/detail/is_empty.hpp
+        include/msgpack/preprocessor/facilities/empty.hpp
+        include/msgpack/preprocessor/facilities/expand.hpp
+        include/msgpack/preprocessor/facilities/identity.hpp
+        include/msgpack/preprocessor/facilities/intercept.hpp
+        include/msgpack/preprocessor/facilities/is_1.hpp
+        include/msgpack/preprocessor/facilities/is_empty.hpp
+        include/msgpack/preprocessor/facilities/is_empty_or_1.hpp
+        include/msgpack/preprocessor/facilities/is_empty_variadic.hpp
+        include/msgpack/preprocessor/facilities/overload.hpp
+        include/msgpack/preprocessor/for.hpp
+        include/msgpack/preprocessor/identity.hpp
+        include/msgpack/preprocessor/if.hpp
+        include/msgpack/preprocessor/inc.hpp
+        include/msgpack/preprocessor/iterate.hpp
+        include/msgpack/preprocessor/iteration.hpp
+        include/msgpack/preprocessor/iteration/detail/bounds/lower1.hpp
+        include/msgpack/preprocessor/iteration/detail/bounds/lower2.hpp
+        include/msgpack/preprocessor/iteration/detail/bounds/lower3.hpp
+        include/msgpack/preprocessor/iteration/detail/bounds/lower4.hpp
+        include/msgpack/preprocessor/iteration/detail/bounds/lower5.hpp
+        include/msgpack/preprocessor/iteration/detail/bounds/upper1.hpp
+        include/msgpack/preprocessor/iteration/detail/bounds/upper2.hpp
+        include/msgpack/preprocessor/iteration/detail/bounds/upper3.hpp
+        include/msgpack/preprocessor/iteration/detail/bounds/upper4.hpp
+        include/msgpack/preprocessor/iteration/detail/bounds/upper5.hpp
+        include/msgpack/preprocessor/iteration/detail/finish.hpp
+        include/msgpack/preprocessor/iteration/detail/iter/forward1.hpp
+        include/msgpack/preprocessor/iteration/detail/iter/forward2.hpp
+        include/msgpack/preprocessor/iteration/detail/iter/forward3.hpp
+        include/msgpack/preprocessor/iteration/detail/iter/forward4.hpp
+        include/msgpack/preprocessor/iteration/detail/iter/forward5.hpp
+        include/msgpack/preprocessor/iteration/detail/iter/reverse1.hpp
+        include/msgpack/preprocessor/iteration/detail/iter/reverse2.hpp
+        include/msgpack/preprocessor/iteration/detail/iter/reverse3.hpp
+        include/msgpack/preprocessor/iteration/detail/iter/reverse4.hpp
+        include/msgpack/preprocessor/iteration/detail/iter/reverse5.hpp
+        include/msgpack/preprocessor/iteration/detail/local.hpp
+        include/msgpack/preprocessor/iteration/detail/rlocal.hpp
+        include/msgpack/preprocessor/iteration/detail/self.hpp
+        include/msgpack/preprocessor/iteration/detail/start.hpp
+        include/msgpack/preprocessor/iteration/iterate.hpp
+        include/msgpack/preprocessor/iteration/local.hpp
+        include/msgpack/preprocessor/iteration/self.hpp
+        include/msgpack/preprocessor/library.hpp
+        include/msgpack/preprocessor/limits.hpp
+        include/msgpack/preprocessor/list.hpp
+        include/msgpack/preprocessor/list/adt.hpp
+        include/msgpack/preprocessor/list/append.hpp
+        include/msgpack/preprocessor/list/at.hpp
+        include/msgpack/preprocessor/list/cat.hpp
+        include/msgpack/preprocessor/list/detail/dmc/fold_left.hpp
+        include/msgpack/preprocessor/list/detail/edg/fold_left.hpp
+        include/msgpack/preprocessor/list/detail/edg/fold_right.hpp
+        include/msgpack/preprocessor/list/detail/fold_left.hpp
+        include/msgpack/preprocessor/list/detail/fold_right.hpp
+        include/msgpack/preprocessor/list/enum.hpp
+        include/msgpack/preprocessor/list/filter.hpp
+        include/msgpack/preprocessor/list/first_n.hpp
+        include/msgpack/preprocessor/list/fold_left.hpp
+        include/msgpack/preprocessor/list/fold_right.hpp
+        include/msgpack/preprocessor/list/for_each.hpp
+        include/msgpack/preprocessor/list/for_each_i.hpp
+        include/msgpack/preprocessor/list/for_each_product.hpp
+        include/msgpack/preprocessor/list/rest_n.hpp
+        include/msgpack/preprocessor/list/reverse.hpp
+        include/msgpack/preprocessor/list/size.hpp
+        include/msgpack/preprocessor/list/to_array.hpp
+        include/msgpack/preprocessor/list/to_seq.hpp
+        include/msgpack/preprocessor/list/to_tuple.hpp
+        include/msgpack/preprocessor/list/transform.hpp
+        include/msgpack/preprocessor/logical.hpp
+        include/msgpack/preprocessor/logical/and.hpp
+        include/msgpack/preprocessor/logical/bitand.hpp
+        include/msgpack/preprocessor/logical/bitnor.hpp
+        include/msgpack/preprocessor/logical/bitor.hpp
+        include/msgpack/preprocessor/logical/bitxor.hpp
+        include/msgpack/preprocessor/logical/bool.hpp
+        include/msgpack/preprocessor/logical/compl.hpp
+        include/msgpack/preprocessor/logical/nor.hpp
+        include/msgpack/preprocessor/logical/not.hpp
+        include/msgpack/preprocessor/logical/or.hpp
+        include/msgpack/preprocessor/logical/xor.hpp
+        include/msgpack/preprocessor/max.hpp
+        include/msgpack/preprocessor/min.hpp
+        include/msgpack/preprocessor/punctuation.hpp
+        include/msgpack/preprocessor/punctuation/comma.hpp
+        include/msgpack/preprocessor/punctuation/comma_if.hpp
+        include/msgpack/preprocessor/punctuation/detail/is_begin_parens.hpp
+        include/msgpack/preprocessor/punctuation/is_begin_parens.hpp
+        include/msgpack/preprocessor/punctuation/paren.hpp
+        include/msgpack/preprocessor/punctuation/paren_if.hpp
+        include/msgpack/preprocessor/punctuation/remove_parens.hpp
+        include/msgpack/preprocessor/repeat.hpp
+        include/msgpack/preprocessor/repeat_2nd.hpp
+        include/msgpack/preprocessor/repeat_3rd.hpp
+        include/msgpack/preprocessor/repeat_from_to.hpp
+        include/msgpack/preprocessor/repeat_from_to_2nd.hpp
+        include/msgpack/preprocessor/repeat_from_to_3rd.hpp
+        include/msgpack/preprocessor/repetition.hpp
+        include/msgpack/preprocessor/repetition/deduce_r.hpp
+        include/msgpack/preprocessor/repetition/deduce_z.hpp
+        include/msgpack/preprocessor/repetition/detail/dmc/for.hpp
+        include/msgpack/preprocessor/repetition/detail/edg/for.hpp
+        include/msgpack/preprocessor/repetition/detail/for.hpp
+        include/msgpack/preprocessor/repetition/detail/msvc/for.hpp
+        include/msgpack/preprocessor/repetition/enum.hpp
+        include/msgpack/preprocessor/repetition/enum_binary_params.hpp
+        include/msgpack/preprocessor/repetition/enum_params.hpp
+        include/msgpack/preprocessor/repetition/enum_params_with_a_default.hpp
+        include/msgpack/preprocessor/repetition/enum_params_with_defaults.hpp
+        include/msgpack/preprocessor/repetition/enum_shifted.hpp
+        include/msgpack/preprocessor/repetition/enum_shifted_binary_params.hpp
+        include/msgpack/preprocessor/repetition/enum_shifted_params.hpp
+        include/msgpack/preprocessor/repetition/enum_trailing.hpp
+        include/msgpack/preprocessor/repetition/enum_trailing_binary_params.hpp
+        include/msgpack/preprocessor/repetition/enum_trailing_params.hpp
+        include/msgpack/preprocessor/repetition/for.hpp
+        include/msgpack/preprocessor/repetition/repeat.hpp
+        include/msgpack/preprocessor/repetition/repeat_from_to.hpp
+        include/msgpack/preprocessor/selection.hpp
+        include/msgpack/preprocessor/selection/max.hpp
+        include/msgpack/preprocessor/selection/min.hpp
+        include/msgpack/preprocessor/seq.hpp
+        include/msgpack/preprocessor/seq/cat.hpp
+        include/msgpack/preprocessor/seq/detail/binary_transform.hpp
+        include/msgpack/preprocessor/seq/detail/is_empty.hpp
+        include/msgpack/preprocessor/seq/detail/split.hpp
+        include/msgpack/preprocessor/seq/elem.hpp
+        include/msgpack/preprocessor/seq/enum.hpp
+        include/msgpack/preprocessor/seq/filter.hpp
+        include/msgpack/preprocessor/seq/first_n.hpp
+        include/msgpack/preprocessor/seq/fold_left.hpp
+        include/msgpack/preprocessor/seq/fold_right.hpp
+        include/msgpack/preprocessor/seq/for_each.hpp
+        include/msgpack/preprocessor/seq/for_each_i.hpp
+        include/msgpack/preprocessor/seq/for_each_product.hpp
+        include/msgpack/preprocessor/seq/insert.hpp
+        include/msgpack/preprocessor/seq/pop_back.hpp
+        include/msgpack/preprocessor/seq/pop_front.hpp
+        include/msgpack/preprocessor/seq/push_back.hpp
+        include/msgpack/preprocessor/seq/push_front.hpp
+        include/msgpack/preprocessor/seq/remove.hpp
+        include/msgpack/preprocessor/seq/replace.hpp
+        include/msgpack/preprocessor/seq/rest_n.hpp
+        include/msgpack/preprocessor/seq/reverse.hpp
+        include/msgpack/preprocessor/seq/seq.hpp
+        include/msgpack/preprocessor/seq/size.hpp
+        include/msgpack/preprocessor/seq/subseq.hpp
+        include/msgpack/preprocessor/seq/to_array.hpp
+        include/msgpack/preprocessor/seq/to_list.hpp
+        include/msgpack/preprocessor/seq/to_tuple.hpp
+        include/msgpack/preprocessor/seq/transform.hpp
+        include/msgpack/preprocessor/seq/variadic_seq_to_seq.hpp
+        include/msgpack/preprocessor/slot.hpp
+        include/msgpack/preprocessor/slot/counter.hpp
+        include/msgpack/preprocessor/slot/detail/counter.hpp
+        include/msgpack/preprocessor/slot/detail/def.hpp
+        include/msgpack/preprocessor/slot/detail/shared.hpp
+        include/msgpack/preprocessor/slot/detail/slot1.hpp
+        include/msgpack/preprocessor/slot/detail/slot2.hpp
+        include/msgpack/preprocessor/slot/detail/slot3.hpp
+        include/msgpack/preprocessor/slot/detail/slot4.hpp
+        include/msgpack/preprocessor/slot/detail/slot5.hpp
+        include/msgpack/preprocessor/slot/slot.hpp
+        include/msgpack/preprocessor/stringize.hpp
+        include/msgpack/preprocessor/tuple.hpp
+        include/msgpack/preprocessor/tuple/detail/is_single_return.hpp
+        include/msgpack/preprocessor/tuple/eat.hpp
+        include/msgpack/preprocessor/tuple/elem.hpp
+        include/msgpack/preprocessor/tuple/enum.hpp
+        include/msgpack/preprocessor/tuple/insert.hpp
+        include/msgpack/preprocessor/tuple/pop_back.hpp
+        include/msgpack/preprocessor/tuple/pop_front.hpp
+        include/msgpack/preprocessor/tuple/push_back.hpp
+        include/msgpack/preprocessor/tuple/push_front.hpp
+        include/msgpack/preprocessor/tuple/rem.hpp
+        include/msgpack/preprocessor/tuple/remove.hpp
+        include/msgpack/preprocessor/tuple/replace.hpp
+        include/msgpack/preprocessor/tuple/reverse.hpp
+        include/msgpack/preprocessor/tuple/size.hpp
+        include/msgpack/preprocessor/tuple/to_array.hpp
+        include/msgpack/preprocessor/tuple/to_list.hpp
+        include/msgpack/preprocessor/tuple/to_seq.hpp
+        include/msgpack/preprocessor/variadic.hpp
+        include/msgpack/preprocessor/variadic/detail/is_single_return.hpp
+        include/msgpack/preprocessor/variadic/elem.hpp
+        include/msgpack/preprocessor/variadic/size.hpp
+        include/msgpack/preprocessor/variadic/to_array.hpp
+        include/msgpack/preprocessor/variadic/to_list.hpp
+        include/msgpack/preprocessor/variadic/to_seq.hpp
+        include/msgpack/preprocessor/variadic/to_tuple.hpp
+        include/msgpack/preprocessor/while.hpp
+        include/msgpack/preprocessor/wstringize.hpp
+        include/msgpack/sbuffer.hpp
+        include/msgpack/sbuffer_decl.hpp
+        include/msgpack/type.hpp
+        include/msgpack/unpack.hpp
+        include/msgpack/unpack_decl.hpp
+        include/msgpack/unpack_exception.hpp
+        include/msgpack/v1/adaptor/adaptor_base.hpp
+        include/msgpack/v1/adaptor/adaptor_base_decl.hpp
+        include/msgpack/v1/adaptor/array_ref.hpp
+        include/msgpack/v1/adaptor/array_ref_decl.hpp
+        include/msgpack/v1/adaptor/bool.hpp
+        include/msgpack/v1/adaptor/boost/fusion.hpp
+        include/msgpack/v1/adaptor/boost/msgpack_variant.hpp
+        include/msgpack/v1/adaptor/boost/msgpack_variant_decl.hpp
+        include/msgpack/v1/adaptor/boost/optional.hpp
+        include/msgpack/v1/adaptor/boost/string_ref.hpp
+        include/msgpack/v1/adaptor/boost/string_view.hpp
+        include/msgpack/v1/adaptor/carray.hpp
+        include/msgpack/v1/adaptor/char_ptr.hpp
+        include/msgpack/v1/adaptor/check_container_size.hpp
+        include/msgpack/v1/adaptor/check_container_size_decl.hpp
+        include/msgpack/v1/adaptor/cpp11/array.hpp
+        include/msgpack/v1/adaptor/cpp11/array_char.hpp
+        include/msgpack/v1/adaptor/cpp11/array_unsigned_char.hpp
+        include/msgpack/v1/adaptor/cpp11/chrono.hpp
+        include/msgpack/v1/adaptor/cpp11/forward_list.hpp
+        include/msgpack/v1/adaptor/cpp11/reference_wrapper.hpp
+        include/msgpack/v1/adaptor/cpp11/shared_ptr.hpp
+        include/msgpack/v1/adaptor/cpp11/tuple.hpp
+        include/msgpack/v1/adaptor/cpp11/unique_ptr.hpp
+        include/msgpack/v1/adaptor/cpp11/unordered_map.hpp
+        include/msgpack/v1/adaptor/cpp11/unordered_set.hpp
+        include/msgpack/v1/adaptor/cpp17/byte.hpp
+        include/msgpack/v1/adaptor/cpp17/carray_byte.hpp
+        include/msgpack/v1/adaptor/cpp17/optional.hpp
+        include/msgpack/v1/adaptor/cpp17/string_view.hpp
+        include/msgpack/v1/adaptor/cpp17/vector_byte.hpp
+        include/msgpack/v1/adaptor/define.hpp
+        include/msgpack/v1/adaptor/define_decl.hpp
+        include/msgpack/v1/adaptor/deque.hpp
+        include/msgpack/v1/adaptor/detail/cpp03_define_array.hpp
+        include/msgpack/v1/adaptor/detail/cpp03_define_array_decl.hpp
+        include/msgpack/v1/adaptor/detail/cpp03_define_map.hpp
+        include/msgpack/v1/adaptor/detail/cpp03_define_map_decl.hpp
+        include/msgpack/v1/adaptor/detail/cpp03_msgpack_tuple.hpp
+        include/msgpack/v1/adaptor/detail/cpp03_msgpack_tuple_decl.hpp
+        include/msgpack/v1/adaptor/detail/cpp11_convert_helper.hpp
+        include/msgpack/v1/adaptor/detail/cpp11_define_array.hpp
+        include/msgpack/v1/adaptor/detail/cpp11_define_array_decl.hpp
+        include/msgpack/v1/adaptor/detail/cpp11_define_map.hpp
+        include/msgpack/v1/adaptor/detail/cpp11_define_map_decl.hpp
+        include/msgpack/v1/adaptor/detail/cpp11_msgpack_tuple.hpp
+        include/msgpack/v1/adaptor/detail/cpp11_msgpack_tuple_decl.hpp
+        include/msgpack/v1/adaptor/ext.hpp
+        include/msgpack/v1/adaptor/ext_decl.hpp
+        include/msgpack/v1/adaptor/fixint.hpp
+        include/msgpack/v1/adaptor/fixint_decl.hpp
+        include/msgpack/v1/adaptor/float.hpp
+        include/msgpack/v1/adaptor/int.hpp
+        include/msgpack/v1/adaptor/int_decl.hpp
+        include/msgpack/v1/adaptor/list.hpp
+        include/msgpack/v1/adaptor/map.hpp
+        include/msgpack/v1/adaptor/map_decl.hpp
+        include/msgpack/v1/adaptor/msgpack_tuple.hpp
+        include/msgpack/v1/adaptor/msgpack_tuple_decl.hpp
+        include/msgpack/v1/adaptor/nil.hpp
+        include/msgpack/v1/adaptor/nil_decl.hpp
+        include/msgpack/v1/adaptor/pair.hpp
+        include/msgpack/v1/adaptor/raw.hpp
+        include/msgpack/v1/adaptor/raw_decl.hpp
+        include/msgpack/v1/adaptor/set.hpp
+        include/msgpack/v1/adaptor/size_equal_only.hpp
+        include/msgpack/v1/adaptor/size_equal_only_decl.hpp
+        include/msgpack/v1/adaptor/string.hpp
+        include/msgpack/v1/adaptor/tr1/unordered_map.hpp
+        include/msgpack/v1/adaptor/tr1/unordered_set.hpp
+        include/msgpack/v1/adaptor/v4raw.hpp
+        include/msgpack/v1/adaptor/v4raw_decl.hpp
+        include/msgpack/v1/adaptor/vector.hpp
+        include/msgpack/v1/adaptor/vector_bool.hpp
+        include/msgpack/v1/adaptor/vector_char.hpp
+        include/msgpack/v1/adaptor/vector_unsigned_char.hpp
+        include/msgpack/v1/cpp_config.hpp
+        include/msgpack/v1/cpp_config_decl.hpp
+        include/msgpack/v1/detail/cpp03_zone.hpp
+        include/msgpack/v1/detail/cpp03_zone_decl.hpp
+        include/msgpack/v1/detail/cpp11_zone.hpp
+        include/msgpack/v1/detail/cpp11_zone_decl.hpp
+        include/msgpack/v1/fbuffer.hpp
+        include/msgpack/v1/fbuffer_decl.hpp
+        include/msgpack/v1/iterator.hpp
+        include/msgpack/v1/iterator_decl.hpp
+        include/msgpack/v1/meta.hpp
+        include/msgpack/v1/meta_decl.hpp
+        include/msgpack/v1/object.hpp
+        include/msgpack/v1/object_decl.hpp
+        include/msgpack/v1/object_fwd.hpp
+        include/msgpack/v1/object_fwd_decl.hpp
+        include/msgpack/v1/pack.hpp
+        include/msgpack/v1/pack_decl.hpp
+        include/msgpack/v1/parse_return.hpp
+        include/msgpack/v1/preprocessor.hpp
+        include/msgpack/v1/sbuffer.hpp
+        include/msgpack/v1/sbuffer_decl.hpp
+        include/msgpack/v1/unpack.hpp
+        include/msgpack/v1/unpack_decl.hpp
+        include/msgpack/v1/unpack_exception.hpp
+        include/msgpack/v1/version.hpp
+        include/msgpack/v1/versioning.hpp
+        include/msgpack/v1/vrefbuffer.hpp
+        include/msgpack/v1/vrefbuffer_decl.hpp
+        include/msgpack/v1/zbuffer.hpp
+        include/msgpack/v1/zbuffer_decl.hpp
+        include/msgpack/v1/zone.hpp
+        include/msgpack/v1/zone_decl.hpp
+        include/msgpack/v2/adaptor/adaptor_base.hpp
+        include/msgpack/v2/adaptor/adaptor_base_decl.hpp
+        include/msgpack/v2/adaptor/array_ref_decl.hpp
+        include/msgpack/v2/adaptor/boost/msgpack_variant_decl.hpp
+        include/msgpack/v2/adaptor/check_container_size_decl.hpp
+        include/msgpack/v2/adaptor/define_decl.hpp
+        include/msgpack/v2/adaptor/detail/cpp03_define_array_decl.hpp
+        include/msgpack/v2/adaptor/detail/cpp03_define_map_decl.hpp
+        include/msgpack/v2/adaptor/detail/cpp03_msgpack_tuple_decl.hpp
+        include/msgpack/v2/adaptor/detail/cpp11_define_array_decl.hpp
+        include/msgpack/v2/adaptor/detail/cpp11_define_map_decl.hpp
+        include/msgpack/v2/adaptor/detail/cpp11_msgpack_tuple_decl.hpp
+        include/msgpack/v2/adaptor/ext_decl.hpp
+        include/msgpack/v2/adaptor/fixint_decl.hpp
+        include/msgpack/v2/adaptor/int_decl.hpp
+        include/msgpack/v2/adaptor/map_decl.hpp
+        include/msgpack/v2/adaptor/msgpack_tuple_decl.hpp
+        include/msgpack/v2/adaptor/nil_decl.hpp
+        include/msgpack/v2/adaptor/raw_decl.hpp
+        include/msgpack/v2/adaptor/size_equal_only_decl.hpp
+        include/msgpack/v2/adaptor/v4raw_decl.hpp
+        include/msgpack/v2/cpp_config_decl.hpp
+        include/msgpack/v2/create_object_visitor.hpp
+        include/msgpack/v2/create_object_visitor_decl.hpp
+        include/msgpack/v2/detail/cpp03_zone_decl.hpp
+        include/msgpack/v2/detail/cpp11_zone_decl.hpp
+        include/msgpack/v2/fbuffer_decl.hpp
+        include/msgpack/v2/iterator_decl.hpp
+        include/msgpack/v2/meta_decl.hpp
+        include/msgpack/v2/null_visitor.hpp
+        include/msgpack/v2/null_visitor_decl.hpp
+        include/msgpack/v2/object.hpp
+        include/msgpack/v2/object_decl.hpp
+        include/msgpack/v2/object_fwd.hpp
+        include/msgpack/v2/object_fwd_decl.hpp
+        include/msgpack/v2/pack_decl.hpp
+        include/msgpack/v2/parse.hpp
+        include/msgpack/v2/parse_decl.hpp
+        include/msgpack/v2/parse_return.hpp
+        include/msgpack/v2/sbuffer_decl.hpp
+        include/msgpack/v2/unpack.hpp
+        include/msgpack/v2/unpack_decl.hpp
+        include/msgpack/v2/vrefbuffer_decl.hpp
+        include/msgpack/v2/x3_parse.hpp
+        include/msgpack/v2/x3_parse_decl.hpp
+        include/msgpack/v2/x3_unpack.hpp
+        include/msgpack/v2/x3_unpack_decl.hpp
+        include/msgpack/v2/zbuffer_decl.hpp
+        include/msgpack/v2/zone_decl.hpp
+        include/msgpack/v3/adaptor/adaptor_base.hpp
+        include/msgpack/v3/adaptor/adaptor_base_decl.hpp
+        include/msgpack/v3/adaptor/array_ref_decl.hpp
+        include/msgpack/v3/adaptor/boost/msgpack_variant_decl.hpp
+        include/msgpack/v3/adaptor/check_container_size_decl.hpp
+        include/msgpack/v3/adaptor/define_decl.hpp
+        include/msgpack/v3/adaptor/detail/cpp03_define_array_decl.hpp
+        include/msgpack/v3/adaptor/detail/cpp03_define_map_decl.hpp
+        include/msgpack/v3/adaptor/detail/cpp03_msgpack_tuple_decl.hpp
+        include/msgpack/v3/adaptor/detail/cpp11_define_array_decl.hpp
+        include/msgpack/v3/adaptor/detail/cpp11_define_map_decl.hpp
+        include/msgpack/v3/adaptor/detail/cpp11_msgpack_tuple_decl.hpp
+        include/msgpack/v3/adaptor/ext_decl.hpp
+        include/msgpack/v3/adaptor/fixint_decl.hpp
+        include/msgpack/v3/adaptor/int_decl.hpp
+        include/msgpack/v3/adaptor/map_decl.hpp
+        include/msgpack/v3/adaptor/msgpack_tuple_decl.hpp
+        include/msgpack/v3/adaptor/nil_decl.hpp
+        include/msgpack/v3/adaptor/raw_decl.hpp
+        include/msgpack/v3/adaptor/size_equal_only_decl.hpp
+        include/msgpack/v3/adaptor/v4raw_decl.hpp
+        include/msgpack/v3/cpp_config_decl.hpp
+        include/msgpack/v3/create_object_visitor_decl.hpp
+        include/msgpack/v3/detail/cpp03_zone_decl.hpp
+        include/msgpack/v3/detail/cpp11_zone_decl.hpp
+        include/msgpack/v3/fbuffer_decl.hpp
+        include/msgpack/v3/iterator_decl.hpp
+        include/msgpack/v3/meta_decl.hpp
+        include/msgpack/v3/null_visitor_decl.hpp
+        include/msgpack/v3/object_decl.hpp
+        include/msgpack/v3/object_fwd.hpp
+        include/msgpack/v3/object_fwd_decl.hpp
+        include/msgpack/v3/pack_decl.hpp
+        include/msgpack/v3/parse.hpp
+        include/msgpack/v3/parse_decl.hpp
+        include/msgpack/v3/parse_return.hpp
+        include/msgpack/v3/sbuffer_decl.hpp
+        include/msgpack/v3/unpack.hpp
+        include/msgpack/v3/unpack_decl.hpp
+        include/msgpack/v3/vrefbuffer_decl.hpp
+        include/msgpack/v3/x3_parse_decl.hpp
+        include/msgpack/v3/x3_unpack.hpp
+        include/msgpack/v3/x3_unpack_decl.hpp
+        include/msgpack/v3/zbuffer_decl.hpp
+        include/msgpack/v3/zone_decl.hpp
+        include/msgpack/version.hpp
+        include/msgpack/versioning.hpp
+        include/msgpack/vrefbuffer.hpp
+        include/msgpack/vrefbuffer_decl.hpp
+        include/msgpack/x3_parse.hpp
+        include/msgpack/x3_parse_decl.hpp
+        include/msgpack/x3_unpack.hpp
+        include/msgpack/x3_unpack_decl.hpp
+        include/msgpack/zbuffer.hpp
+        include/msgpack/zbuffer_decl.hpp
+        include/msgpack/zone.hpp
+        include/msgpack/zone_decl.hpp
+    )
+ENDIF ()

LICENSE

@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   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.

LICENSE_1_0.txt

@@ -0,0 +1,23 @@
+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.

Makefile.am

@@ -1,23 +0,0 @@
-SUBDIRS = src test
-
-DOC_FILES = \
-		README.md \
-		LICENSE \
-		NOTICE \
-		msgpack_vc8.vcproj \
-		msgpack_vc8.sln \
-		msgpack_vc2008.vcproj \
-		msgpack_vc2008.sln \
-		msgpack_vc.postbuild.bat
-
-EXTRA_DIST = \
-		$(DOC_FILES)
-
-pkgconfigdir = $(libdir)/pkgconfig
-pkgconfig_DATA = msgpack.pc
-
-doxygen:
-	./preprocess clean
-	cd src && $(MAKE) doxygen
-	./preprocess
-

NOTICE

@@ -1,4 +1,14 @@
-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 and Boost Preprocessor.
+They are distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
 
+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/*

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
 
@@ -20,7 +20,7 @@ You might need to run `sudo port selfupdate` before installing to update the pac
 You can also install via Homebrew.
 
 ```
-$ sudo brew install msgpack
+$ brew install msgpack
 ```
 
 ## FreeBSD with Ports Collection
@@ -36,9 +36,9 @@ On Gentoo Linux, you can use emerge. Install [dev-libs/msgpack|http://gentoo-por
 On the other UNIX-like platforms, download source package from [Releases|http://msgpack.org/releases/cpp/] and run `./configure && make && make install`.
 
 ```
-$ wget http://msgpack.org/releases/cpp/msgpack-0.5.5.tar.gz
-$ tar zxvf msgpack-0.5.5.tar.gz
-$ cd msgpack-0.5.5
+$ wget http://msgpack.org/releases/cpp/msgpack-1.3.0.tar.gz
+$ tar zxvf msgpack-1.3.0.tar.gz
+$ cd msgpack-1.3.0
 $ ./configure
 $ make
 $ sudo make install
@@ -88,15 +88,15 @@ int main(void) {
 
         /* serializes ["Hello", "MessagePack"]. */
         msgpack_pack_array(pk, 2);
-        msgpack_pack_raw(pk, 5);
-        msgpack_pack_raw_body(pk, "Hello", 5);
-        msgpack_pack_raw(pk, 11);
-        msgpack_pack_raw_body(pk, "MessagePack", 11);
+        msgpack_pack_bin(pk, 5);
+        msgpack_pack_bin_body(pk, "Hello", 5);
+        msgpack_pack_bin(pk, 11);
+        msgpack_pack_bin_body(pk, "MessagePack", 11);
 
         /* deserializes it. */
         msgpack_unpacked msg;
         msgpack_unpacked_init(&msg);
-        bool success = msgpack_unpack_next(&msg, buffer->data, buffer->size, NULL);
+        msgpack_unpack_return ret = msgpack_unpack_next(&msg, buffer->data, buffer->size, NULL);
 
         /* prints the deserialized object. */
         msgpack_object obj = msg.data;
@@ -119,7 +119,7 @@ int main(void) {
         /* creates buffer and serializer instance. */
         msgpack_sbuffer* buffer = msgpack_sbuffer_new();
         msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write);
-        
+
         int j;
 
         for(j = 0; j<23; j++) {
@@ -128,16 +128,16 @@ int main(void) {
 
            /* serializes ["Hello", "MessagePack"]. */
            msgpack_pack_array(pk, 3);
-           msgpack_pack_raw(pk, 5);
-           msgpack_pack_raw_body(pk, "Hello", 5);
-           msgpack_pack_raw(pk, 11);
-           msgpack_pack_raw_body(pk, "MessagePack", 11);
+           msgpack_pack_bin(pk, 5);
+           msgpack_pack_bin_body(pk, "Hello", 5);
+           msgpack_pack_bin(pk, 11);
+           msgpack_pack_bin_body(pk, "MessagePack", 11);
            msgpack_pack_int(pk, j);
 
            /* deserializes it. */
            msgpack_unpacked msg;
            msgpack_unpacked_init(&msg);
-           bool success = msgpack_unpack_next(&msg, buffer->data, buffer->size, NULL);
+           msgpack_unpack_return ret = msgpack_unpack_next(&msg, buffer->data, buffer->size, NULL);
 
            /* prints the deserialized object. */
            msgpack_object obj = msg.data;
@@ -184,7 +184,7 @@ int main(void) {
         }
 
         /* results:
-         * $ gcc stream.cc -lmsgpack -o stream
+         * $ gcc stream.cc -lmsgpackc -o stream
          * $ ./stream
          * 1
          * 2

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
 
@@ -31,23 +31,23 @@ int main(void) {
         msgpack::pack(sbuf, vec);
 
         // deserialize it.
-        msgpack::unpacked msg;
-        msgpack::unpack(&msg, sbuf.data(), sbuf.size());
+        msgpack::object_handle oh =
+            msgpack::unpack(sbuf.data(), sbuf.size());
 
         // print the deserialized object.
-        msgpack::object obj = msg.get();
+        msgpack::object obj = oh.get();
         std::cout << obj << std::endl;  //=> ["Hello", "MessagePack"]
 
         // convert it into statically typed object.
         std::vector<std::string> rvec;
-        obj.convert(&rvec);
+        obj.convert(rvec);
 }
 ```
 
 Compile it as follows:
 
 ```
-$ g++ hello.cc -lmsgpack -o hello
+$ g++ -Ipath_to_msgpack/include hello.cc -o hello
 $ ./hello
 ["Hello", "MessagePack"]
 ```
@@ -77,13 +77,13 @@ int main(void) {
         pac.buffer_consumed(buffer.size());
 
         // now starts streaming deserialization.
-        msgpack::unpacked result;
-        while(pac.next(&result)) {
-            std::cout << result.get() << std::endl;
+        msgpack::object_handle oh;
+        while(pac.next(oh)) {
+            std::cout << oh.get() << std::endl;
         }
 
         // results:
-        // $ g++ stream.cc -lmsgpack -o stream
+        // $ g++ -Ipath_to_msgpack/include stream.cc -o stream
         // $ ./stream
         // "Log message ... 1"
         // "Log message ... 2"
@@ -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>
@@ -147,13 +147,13 @@ int main(void) {
         msgpack::sbuffer sbuf;
         msgpack::pack(sbuf, vec);
 
-        msgpack::unpacked msg;
-        msgpack::unpack(&msg, sbuf.data(), sbuf.size());
+        msgpack::object_handle oh =
+            msgpack::unpack(sbuf.data(), sbuf.size());
 
-        msgpack::object obj = msg.get();
+        msgpack::object obj = oh.get();
 
         // you can convert object to myclass directly
         std::vector<myclass> rvec;
-        obj.convert(&rvec);
+        obj.convert(rvec);
 }
 ```

README.md

@@ -1,73 +1,197 @@
-MessagePack for C/C++
-=====================
-Binary-based efficient object serialization library.
+`msgpack` for C/C++
+===================
 
+Version 3.1.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 smaller and faster.
 
-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 and 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::object_handle oh =
+        msgpack::unpack(str.data(), str.size());
+
+    // deserialized object is valid during the msgpack::object_handle instance is alive.
+    msgpack::object deserialized = oh.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);
+
+    // or create the new instance
+    msgpack::type::tuple<int, bool, std::string> dst2 =
+        deserialized.as<msgpack::type::tuple<int, bool, std::string> >();
+
+    return 0;
+}
+```
+
+See [`QUICKSTART-CPP.md`](./QUICKSTART-CPP.md) for more details.
+
+Usage
+-----
+
+### C++ Header Only Library
+
+When you use msgpack on C++, 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 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 or C++17 version of msgpack instead,
+execute the following commands:
+
+    $ git clone https://github.com/msgpack/msgpack-c.git
+    $ cd msgpack-c
+    $ cmake -DMSGPACK_CXX[11|17]=ON .
+    $ sudo make install
+
+`MSGPACK_CXX[11|17]` flags are not affected to installing files. Just switching test cases. All files are installed in every settings.
+
+When you use the C part of `msgpack-c`, you need to build and link the library. By default, both static/shared libraries are built. If you want to build only static library, set `BUILD_SHARED_LIBS=OFF` to cmake. If you want to build only shared library, set `BUILD_SHARED_L
+
+#### 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 additional information including the tutorial 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 Boost Software License, Version 1.0. See
+the [`LICENSE_1_0.txt`](./LICENSE_1_0.txt) file for details.

README_crosslang.md

@@ -1,38 +0,0 @@
-MessagePack cross-language test cases
-=====================================
-
-## cases
-
-Valid serialized data are stored in "cases.mpac" and "cases_compact.mpac".
-These files describe same objects. And "cases.json" describes an array of the described objects.
-
-Thus you can verify your implementations as comparing the objects.
-
-
-## crosslang
-
-The *crosslang* tool reads serialized data from stdin and writes re-serialize data to stdout.
-
-There are C++ and Ruby implementation of crosslang tool. You can verify your implementation
-as comparing that implementations.
-
-### C++ version
-
-    $ cd ../cpp && ./configure && make && make install
-    or
-    $ port install msgpack  # MacPorts
-    
-    $ g++ -Wall -lmsgpack crosslang.cc -o crosslang
-
-    $ ./crosslang
-    Usage: ./crosslang [in-file] [out-file]
-
-### Ruby version
-
-    $ gem install msgpack
-    or
-    $ port install rb_msgpack   # MacPorts
-
-    $ ruby crosslang.rb
-    Usage: crosslang.rb [in-file] [out-file]
-

appveyor.yml

@@ -0,0 +1,58 @@
+version: 3.1.0.{build}
+
+image:
+- Visual Studio 2015
+environment:
+  global:
+    BOOST_ROOT: C:\Libraries\boost_1_60_0
+  matrix:
+    - cpp11: -DMSGPACK_CXX11=OFF
+      boost: -DMSGPACK_BOOST=OFF
+      msvc: '"Visual Studio 10 2010"'
+    - cpp11: -DMSGPACK_CXX11=OFF
+      boost: -DMSGPACK_BOOST=OFF
+      msvc: '"Visual Studio 11 2012"'
+    - cpp11: -DMSGPACK_CXX11=OFF
+      boost: -DMSGPACK_BOOST=OFF
+      msvc: '"Visual Studio 12 2013"'
+    - cpp11: -DMSGPACK_CXX11=ON
+      boost: -DMSGPACK_BOOST=ON
+      msvc: '"Visual Studio 14 2015"'
+    - cpp11: -DMSGPACK_CXX11=OFF
+      boost: -DMSGPACK_BOOST=ON
+      msvc: '"Visual Studio 14 2015"'
+    - cpp11: -DMSGPACK_CXX11=ON
+      boost: -DMSGPACK_BOOST=OFF
+      msvc: '"Visual Studio 14 2015"'
+    - cpp11: -DMSGPACK_CXX11=OFF
+      boost: -DMSGPACK_BOOST=OFF
+      msvc: '"Visual Studio 14 2015"'
+build_script:
+- appveyor DownloadFile https://github.com/google/googletest/archive/release-1.7.0.zip -FileName googletest-release-1.7.0.zip
+- 7z x googletest-release-1.7.0.zip > NUL
+- cd googletest-release-1.7.0
+- md build
+- cd build
+- cmake -G %msvc% -DBUILD_SHARED_LIBS=ON -DCMAKE_CXX_FLAGS=/D_VARIADIC_MAX=10 ..
+- cmake --build . --config Release
+- cd ..
+- cd ..
+- appveyor DownloadFile http://zlib.net/zlib-1.2.11.tar.gz -FileName zlib-1.2.11.tar.gz
+- 7z x zlib-1.2.11.tar.gz > NUL
+- 7z x zlib-1.2.11.tar > NUL
+- cd zlib-1.2.11
+- md build
+- cd build
+- cmake -G %msvc% ..
+- cmake --build . --config Release
+- copy zconf.h ..
+- cd ..
+- cd ..
+- md build
+- cd build
+- cmake -G %msvc% %cpp11% %boost% %x3_parse% -DGTEST_LIBRARY=%APPVEYOR_BUILD_FOLDER%\googletest-release-1.7.0\build\Release\gtest.lib -DGTEST_MAIN_LIBRARY=%APPVEYOR_BUILD_FOLDER%\googletest-release-1.7.0\build\Release\gtest_main.lib -DGTEST_INCLUDE_DIR=%APPVEYOR_BUILD_FOLDER%\googletest-release-1.7.0\include -DZLIB_LIBRARY=%APPVEYOR_BUILD_FOLDER%\zlib-1.2.11\build\Release\zlib.lib -DZLIB_INCLUDE_DIR=%APPVEYOR_BUILD_FOLDER%\zlib-1.2.11 -DCMAKE_CXX_FLAGS='"/D_VARIADIC_MAX=10 /EHsc"' ..
+- cmake --build . --config Release
+
+test_script:
+- set PATH=%PATH%;%APPVEYOR_BUILD_FOLDER%\googletest-release-1.7.0\build\Release;%APPVEYOR_BUILD_FOLDER%\zlib-1.2.11\build\Release;%APPVEYOR_BUILD_FOLDER%\build\release
+- ctest -V

bootstrap

@@ -1,127 +0,0 @@
-#!/bin/sh
-# vim:ts=4:sw=4
-# Calls autotools to build configure script and Makefile.in.
-# Generated automatically using bootstrapper 0.2.1
-# http://bootstrapper.sourceforge.net/
-#
-# Copyright (C) 2002 Anthony Ventimiglia
-#
-# This bootstrap script is free software; you can redistribute 
-# it and/or modify it under the terms of the GNU General Public 
-# License as published by the Free Software Foundation; either 
-# version 2 of the License, or (at your option) any later version.
-#
-#
-# Calls proper programs to create configure script and Makefile.in files.
-# if run with the --clean option, bootstrap removes files it generates. To
-# clean all autogenerated files (eg: for cvs imports) first run 
-# make distclean, then bootstrap --clean
-# see bootstrapper(1) for more infor
-
-
-if test x"$1" = x"--help"; then
-	echo "$0: automatic bootstrapping utility for GNU Autotools"
-	echo "		cleans up old autogenerated files and runs autoconf,"
-	echo "		automake and aclocal on local directory"
-	echo 
-	echo "		--clean		clean up auto-generated files without"
-	echo "					creating new scripts"
-	echo 
-	exit 0
-fi
-
-
-mkdir -p ac
-test -f AUTHORS   || touch AUTHORS
-test -f COPYING   || touch COPYING
-test -f ChangeLog || touch ChangeLog
-test -f NEWS      || touch NEWS
-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"
-AUTOCONF="autoconf"
-AUTOCONF_FILES="configure"
-AUTOHEADER="autoheader"
-AUTOHEADER_FILES=""
-AUTOMAKE="automake --add-missing --copy"
-AUTOMAKE_FILES="config.sub stamp-h.in ltmain.sh missing mkinstalldirs install-sh config.guess"
-CONFIG_AUX_DIR="."
-CONFIG_FILES="stamp-h ltconfig"
-CONFIG_HEADER=""
-if [ x`uname` = x"Darwin" ]; then
-	LIBTOOLIZE="glibtoolize --force --copy"
-else
-	LIBTOOLIZE="libtoolize --force --copy"
-fi
-LIBTOOLIZE_FILES="config.sub ltmain.sh config.guess"
-RM="rm"
-SUBDIRS="[]"
-
-
-# These are files created by configure, so we'll always clean them
-for i in $ALWAYS_CLEAN; do
-	test -f $i && \
-	$RM $i
-done
-
-if test x"$1" = x"--clean"; then
-	#
-	#Clean Files left by previous bootstrap run
-	#
-	if test -n "$CONFIG_AUX_DIR"; 
-		then CONFIG_AUX_DIR="$CONFIG_AUX_DIR/"
-	fi
-	# Clean Libtoolize generated files
-	for cf in $LIBTOOLIZE_FILES; do
-		cf="$CONFIG_AUX_DIR$cf"
-		test -f $cf && \
-		$RM $cf
-	done
-	#aclocal.m4 created by aclocal
-	test -f $ACLOCAL_FILES && $RM $ACLOCAL_FILES
-	#Clean Autoheader Generated files
-	for cf in $AUTOHEADER_FILES; do
-		cf=$CONFIG_AUX_DIR$cf
-		test -f $cf && \
-		$RM $cf
-	done
-	# remove config header (Usaually config.h)
-	test -n "$CONFIG_HEADER" && test -f $CONFIG_HEADER && $RM $CONFIG_HEADER
-	#Clean Automake generated files
-	for cf in $AUTOMAKE_FILES; do
-		cf=$CONFIG_AUX_DIR$cf
-		test -f $cf && \
-		$RM $cf
-	done
-	for i in $SUBDIRS; do
-		test -f $i/Makefile.in && \
-		$RM $i/Makefile.in
-	done
-	#Autoconf generated files
-	for cf in $AUTOCONF_FILES; do
-		test -f $cf && \
-		$RM $cf
-	done
-	for cf in $CONFIG_FILES; do
-		cf="$CONFIG_AUX_DIR$cf"
-		test -f $cf && \
-		$RM $cf
-	done
-else
-	$LIBTOOLIZE
-	$ACLOCAL
-	$AUTOHEADER
-	$AUTOMAKE
-	$AUTOCONF
-fi
-
-

cases.json

@@ -1 +0,0 @@
-[false,true,null,0,0,0,0,0,0,0,0,0,-1,-1,-1,-1,-1,127,127,255,65535,4294967295,-32,-32,-128,-32768,-2147483648,0.0,-0.0,1.0,-1.0,"a","a","a","","","",[0],[0],[0],[],[],[],{},{},{},{"a":97},{"a":97},{"a":97},[[]],[["a"]]]

cases_gen.rb

@@ -1,99 +0,0 @@
-#
-# MessagePack format test case
-#
-begin
-require 'rubygems'
-rescue LoadError
-end
-require 'msgpack'
-require 'json'
-
-source = <<EOF
-c2                          # false
-c3                          # true
-c0                          # nil
-00                          # 0 Positive FixNum
-cc 00                       # 0 uint8
-cd 00 00                    # 0 uint16
-ce 00 00 00 00              # 0 uint32
-cf 00 00 00 00 00 00 00 00  # 0 uint64
-d0 00                       # 0 int8
-d1 00 00                    # 0 int16
-d2 00 00 00 00              # 0 int32
-d3 00 00 00 00 00 00 00 00  # 0 int64
-ff                          # -1 Negative FixNum
-d0 ff                       # -1 int8
-d1 ff ff                    # -1 int16
-d2 ff ff ff ff              # -1 int32
-d3 ff ff ff ff ff ff ff ff  # -1 int64
-7f                          # 127 Positive FixNum
-cc 7f                       # 127 uint8
-cd 00 ff                    # 255 uint16
-ce 00 00 ff ff              # 65535 uint32
-cf 00 00 00 00 ff ff ff ff  # 4294967295 uint64
-e0                          # -32 Negative FixNum
-d0 e0                       # -32 int8
-d1 ff 80                    # -128 int16
-d2 ff ff 80 00              # -32768 int32
-d3 ff ff ff ff 80 00 00 00  # -2147483648 int64
-#ca 00 00 00 00              # 0.0 float
-cb 00 00 00 00 00 00 00 00  # 0.0 double
-#ca 80 00 00 00              # -0.0 float
-cb 80 00 00 00 00 00 00 00  # -0.0 double
-cb 3f f0 00 00 00 00 00 00  # 1.0 double
-cb bf f0 00 00 00 00 00 00  # -1.0 double
-a1 61                       # "a" FixRaw
-da 00 01 61                 # "a" raw 16
-db 00 00 00 01 61           # "a" raw 32
-a0                          # "" FixRaw
-da 00 00                    # "" raw 16
-db 00 00 00 00              # "" raw 32
-91 00                       # [0] FixArray
-dc 00 01 00                 # [0] array 16
-dd 00 00 00 01 00           # [0] array 32
-90                          # [] FixArray
-dc 00 00                    # [] array 16
-dd 00 00 00 00              # [] array 32
-80                          # {} FixMap
-de 00 00                    # {} map 16
-df 00 00 00 00              # {} map 32
-81 a1 61 61                 # {"a"=>97} FixMap
-de 00 01 a1 61 61           # {"a"=>97} map 16
-df 00 00 00 01 a1 61 61     # {"a"=>97} map 32
-91 90                       # [[]]
-91 91 a1 61                 # [["a"]]
-EOF
-
-source.gsub!(/\#.+$/,'')
-bytes = source.strip.split(/\s+/).map {|x| x.to_i(16) }.pack('C*')
-
-objs = []
-compact_bytes = ""
-
-pac = MessagePack::Unpacker.new
-pac.feed(bytes)
-pac.each {|obj|
-	p obj
-	objs << obj
-	compact_bytes << obj.to_msgpack
-}
-
-json = objs.to_json
-
-# self check
-cpac = MessagePack::Unpacker.new
-cpac.feed(compact_bytes)
-cpac.each {|cobj|
-	obj = objs.shift
-	if obj != cobj
-		puts "** SELF CHECK FAILED **"
-		puts "expected: #{obj.inspect}"
-		puts "actual: #{cobj.inspect}"
-		exit 1
-	end
-}
-
-File.open("cases.mpac","w") {|f| f.write(bytes) }
-File.open("cases_compact.mpac","w") {|f| f.write(compact_bytes) }
-File.open("cases.json","w") {|f| f.write(json) }
-

ci/build_cmake.sh

@@ -0,0 +1,75 @@
+#!/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 [ "${ARCH}" == "32" ]
+then
+    export BIT32="ON"
+else
+    export BIT32="OFF"
+fi
+
+cmake -DMSGPACK_CXX11=${CXX11} -DMSGPACK_CXX17=${CXX17} -DMSGPACK_32BIT=${BIT32} -DMSGPACK_BOOST=${BOOST} -DBUILD_SHARED_LIBS=${SHARED} -DMSGPACK_CHAR_SIGN=${CHAR_SIGN} -DMSGPACK_DEFAULT_API_VERSION=${API_VERSION} -DMSGPACK_USE_X3_PARSE=${X3_PARSE} ..
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+make
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+ctest -VV
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+make install DESTDIR=`pwd`/install
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+if [ "${ARCH}" != "32" ] && [ `uname` = "Linux" ]
+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

ci/build_regression.sh

@@ -0,0 +1,49 @@
+#!/bin/bash
+
+mkdir -p build
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+cd build
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+if [ "${ARCH}" == "32" ]
+then
+    echo "64 bit support required for regressions"
+    exit 1
+fi
+
+cmake -DMSGPACK_FUZZ_REGRESSION="ON" -DMSGPACK_CXX11="ON" -DMSGPACK_BOOST=${BOOST} -DMSGPACK_SAN=${MSGPACK_SAN} -v ..
+
+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
+
+exit 0

configure.in

@@ -1,100 +0,0 @@
-AC_INIT(src/object.cpp)
-AC_CONFIG_AUX_DIR(ac)
-AM_INIT_AUTOMAKE(msgpack, 0.5.8)
-AC_CONFIG_HEADER(config.h)
-
-AC_SUBST(CFLAGS)
-CFLAGS="-O3 -Wall $CFLAGS"
-
-AC_SUBST(CXXFLAGS)
-CXXFLAGS="-O3 -Wall $CXXFLAGS"
-
-
-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]) )   #'
-AC_MSG_RESULT([$enable_cxx])
-if test "$enable_cxx" != "no"; then
-	AC_PROG_CXX
-	AM_PROG_CC_C_O
-fi
-AM_CONDITIONAL(ENABLE_CXX, test "$enable_cxx" != "no")
-
-
-AC_PROG_LIBTOOL
-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]) )
-AC_MSG_RESULT([$enable_debug])
-if test "$enable_debug" != "no"; then
-	CXXFLAGS="$CXXFLAGS -g"
-	CFLAGS="$CFLAGS -g"
-else
-	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"
-])
-
-	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/'`
-AC_SUBST(VERSION_MAJOR, $major)
-AC_SUBST(VERSION_MINOR, $minor)
-
-
-AC_OUTPUT([Makefile
-		   msgpack.pc
-		   src/Makefile
-		   src/msgpack/version.h
-		   test/Makefile])
-

crosslang.cc

@@ -1,133 +0,0 @@
-//
-// MessagePack cross-language test tool
-//
-// $ cd ../cpp && ./configure && make && make install
-// or
-// $ port install msgpack  # MacPorts
-//
-// $ g++ -Wall -lmsgpack crosslang.cc
-//
-#include <msgpack.hpp>
-#include <iostream>
-#include <unistd.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <string.h>
-#include <stdlib.h>
-
-static int run(int infd, int outfd)
-try {
-	msgpack::unpacker pac;
-
-	while(true) {
-		pac.reserve_buffer(32*1024);
-
-		ssize_t count =
-			read(infd, pac.buffer(), pac.buffer_capacity());
-
-		if(count <= 0) {
-			if(count == 0) {
-				return 0;
-			}
-			if(errno == EAGAIN || errno == EINTR) {
-				continue;
-			}
-			return 1;
-		}
-
-		pac.buffer_consumed(count);
-
-		msgpack::unpacked result;
-		while(pac.next(&result)) {
-			msgpack::sbuffer sbuf;
-			msgpack::pack(sbuf, result.get());
-
-			const char* p = sbuf.data();
-			const char* const pend = p + sbuf.size();
-			while(p < pend) {
-				ssize_t bytes = write(outfd, p, pend-p);
-
-				if(bytes <= 0) {
-					if(count == 0) {
-						return 0;
-					}
-					if(errno == EAGAIN || errno == EINTR) {
-						continue;
-					}
-					return 1;
-				}
-
-				p += bytes;
-			}
-
-		}
-	}
-
-	return 0;
-
-} catch (std::exception& e) {
-	std::cerr << e.what() << std::endl;
-	return 1;
-}
-
-static void usage(const char* prog)
-{
-	printf(
-		"Usage: %s [in-file] [out-file]\n"
-		"\n"
-		"This tool is for testing of MessagePack implementation.\n"
-		"This does following behavior:\n"
-		"\n"
-		"  1. Reads objects serialized by MessagePack from <in-file> (default: stdin)\n"
-		"  2. Re-serializes the objects using C++ implementation of MessagePack (Note that C++ implementation is considered valid)\n"
-		"  3. Writes the re-serialized objects into <out-file> (default: stdout)\n"
-		"\n"
-		, prog);
-	exit(1);
-}
-
-int main(int argc, char* argv[])
-{
-	int infd = 0;
-	int outfd = 1;
-
-	if(argc < 1 || argc > 3) {
-		usage(argv[0]);
-	}
-
-	for(int i=1; i < argc; ++i) {
-		if(strlen(argv[i]) > 1 && argv[i][0] == '-') {
-			usage(argv[0]);
-		}
-	}
-
-	if(argc >= 2) {
-		const char* fname = argv[1];
-		if(strcmp(fname, "-") != 0) {
-			infd = open(fname, O_RDONLY);
-			if(infd < 0) {
-				perror("can't open input file");
-				exit(1);
-			}
-		}
-	}
-
-	if(argc >= 3) {
-		const char* fname = argv[2];
-		if(strcmp(fname, "-") != 0) {
-			outfd = open(fname, O_WRONLY | O_CREAT| O_TRUNC, 0666);
-			if(outfd < 0) {
-				perror("can't open output file");
-				exit(1);
-			}
-		}
-	}
-
-	int code = run(infd, outfd);
-
-	close(infd);
-	close(outfd);
-
-	return code;
-}
-

crosslang.rb

@@ -1,88 +0,0 @@
-#
-# MessagePack cross-language test tool
-#
-# $ gem install msgpack
-# or
-# $ port install rb_msgpack   # MacPorts
-#
-begin
-require 'rubygems'
-rescue LoadError
-end
-require 'msgpack'
-
-def run(inio, outio)
-	pac = MessagePack::Unpacker.new(inio)
-
-	begin
-		pac.each {|obj|
-			outio.write MessagePack.pack(obj)
-			outio.flush
-		}
-	rescue EOFError
-		return 0
-	rescue
-		$stderr.puts $!
-		return 1
-	end
-
-	return 0
-end
-
-def usage
-	puts <<EOF
-Usage: #{$0} [in-file] [out-file]
-
-This tool is for testing of MessagePack implementation.
-This does following behavior:
-
-  1. Reads objects serialized by MessagePack from <in-file> (default: stdin)
-  2. Re-serializes the objects using Ruby implementation of MessagePack (Note that Ruby implementation is considered valid)
-  3. Writes the re-serialized objects into <out-file> (default: stdout)
-
-EOF
-	exit 1
-end
-
-inio = $stdin
-outio = $stdout
-
-if ARGV.length > 2
-	usage
-end
-
-ARGV.each {|str|
-	if str.size > 1 && str[0] == ?-
-		usage
-	end
-}
-
-if fname = ARGV[0]
-	unless fname == "-"
-		begin
-			inio = File.open(fname)
-		rescue
-			puts "can't open output file: #{$!}"
-			exit 1
-		end
-	end
-end
-
-if fname = ARGV[1]
-	unless fname == "-"
-		begin
-			outio = File.open(fname, "w")
-		rescue
-			puts "can't open output file: #{$!}"
-			exit 1
-		end
-	end
-end
-
-code = run(inio, outio)
-
-inio.close
-outio.close
-
-exit code
-

erb/v1/cpp03_define_array.hpp.erb

@@ -0,0 +1,110 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_V1_CPP03_DEFINE_ARRAY_HPP
+#define MSGPACK_V1_CPP03_DEFINE_ARRAY_HPP
+
+#include "msgpack/v1/adaptor/detail/cpp03_define_array_decl.hpp"
+#include "msgpack/adaptor/msgpack_tuple.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/object_fwd.hpp"
+
+namespace msgpack {
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+namespace type {
+
+<% GENERATION_LIMIT = 31 %>
+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 = MSGPACK_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%>);
+            // fallthrough
+<%}%>
+            }
+        }
+    }
+    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%>, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
+        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_V1_CPP03_DEFINE_ARRAY_HPP

erb/v1/cpp03_define_array_decl.hpp.erb

@@ -0,0 +1,42 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_V1_CPP03_DEFINE_ARRAY_DECL_HPP
+#define MSGPACK_V1_CPP03_DEFINE_ARRAY_DECL_HPP
+
+#include "msgpack/versioning.hpp"
+
+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
+
+define_array<> make_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%><%}%>);
+<%}%>
+/// @endcond
+
+}  // namespace type
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+}  // namespace msgpack
+
+#endif // MSGPACK_V1_CPP03_DEFINE_ARRAY_DECL_HPP

erb/v1/cpp03_define_map.hpp.erb

@@ -0,0 +1,120 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2015-2016 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_V1_CPP03_DEFINE_MAP_HPP
+#define MSGPACK_V1_CPP03_DEFINE_MAP_HPP
+
+#include "msgpack/v1/adaptor/detail/cpp03_define_map_decl.hpp"
+#include "msgpack/adaptor/msgpack_tuple.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/object_fwd.hpp"
+
+#include <map>
+
+namespace msgpack {
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+namespace type {
+
+<% GENERATION_LIMIT = 31 %>
+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 = MSGPACK_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) {
+            if (o.via.map.ptr[i].key.type != msgpack::type::STR) { throw msgpack::type_error(); }
+            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%>, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
+        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_V1_CPP03_DEFINE_MAP_HPP

erb/v1/cpp03_define_map_decl.hpp.erb

@@ -0,0 +1,42 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2015-2016 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_V1_CPP03_DEFINE_MAP_DECL_HPP
+#define MSGPACK_V1_CPP03_DEFINE_MAP_DECL_HPP
+
+#include "msgpack/versioning.hpp"
+
+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
+
+define_map<> make_define_map();
+
+/// @cond
+<%0.upto(GENERATION_LIMIT) {|i|%>
+template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
+define_map<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_define_map(A0& a0<%1.upto(i) {|j|%>, A<%=j%>& a<%=j%><%}%>);
+<%}%>
+/// @endcond
+
+}  // namespace type
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+}  // namespace msgpack
+
+#endif // MSGPACK_V1_CPP03_DEFINE_MAP_DECL_HPP

erb/v1/cpp03_msgpack_tuple.hpp.erb

@@ -0,0 +1,227 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_V1_CPP03_MSGPACK_TUPLE_HPP
+#define MSGPACK_V1_CPP03_MSGPACK_TUPLE_HPP
+
+#include "msgpack/v1/adaptor/msgpack_tuple_decl.hpp"
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace type {
+
+// FIXME operator==
+// FIXME operator!=
+<% GENERATION_LIMIT = 31 %>
+
+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;
+    std::size_t size() const { return 0; }
+};
+
+/// @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;
+    std::size_t size() const { return <%=i+1%>; }
+    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(); }
+        <%0.upto(i) {|j|%>
+        // In order to avoid clang++'s invalid warning, msgpack::object:: has been added.
+        if(o.via.array.size > <%=j%>)
+            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 = MSGPACK_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%>, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
+        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_V1_CPP03_MSGPACK_TUPLE_HPP

erb/v1/cpp03_msgpack_tuple_decl.hpp.erb

@@ -0,0 +1,69 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_V1_CPP03_MSGPACK_TUPLE_DECL_HPP
+#define MSGPACK_V1_CPP03_MSGPACK_TUPLE_DECL_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;
+
+/// @cond
+<%0.upto(GENERATION_LIMIT) {|i|%>
+template <int N, typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
+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);
+template <int N, typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
+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);
+<%}%>
+/// @endcond
+
+tuple<> make_tuple();
+
+/// @cond
+<%0.upto(GENERATION_LIMIT) {|i|%>
+template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
+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%><%}%>);
+<%}%>
+/// @endcond
+
+}  // namespace type
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+}  // namespace msgpack
+
+#endif // MSGPACK_V1_CPP03_MSGPACK_TUPLE_DECL_HPP

erb/v1/cpp03_zone.hpp.erb

@@ -0,0 +1,334 @@
+//
+// MessagePack for C++ memory pool
+//
+// Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_V1_CPP03_ZONE_HPP
+#define MSGPACK_V1_CPP03_ZONE_HPP
+
+#include "msgpack/zone_decl.hpp"
+
+<% 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(MSGPACK_NULLPTR), m_end(MSGPACK_NULLPTR), m_array(MSGPACK_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 = MSGPACK_NULLPTR;
+        }
+        ~chunk_list()
+        {
+            chunk* c = m_head;
+            while(c) {
+                chunk* n = c->m_next;
+                ::free(c);
+                c = n;
+            }
+        }
+        void clear(size_t chunk_size)
+        {
+            chunk* c = m_head;
+            while(true) {
+                chunk* n = c->m_next;
+                if(n) {
+                    ::free(c);
+                    c = n;
+                } else {
+                    m_head = c;
+                    break;
+                }
+            }
+            m_head->m_next = MSGPACK_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);
+
+    static char* get_aligned(char* ptr, size_t align);
+
+    char* 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 char* zone::get_aligned(char* ptr, size_t align)
+{
+    return
+        reinterpret_cast<char*>(
+            reinterpret_cast<size_t>(
+            (ptr + (align - 1))) / align * align);
+}
+
+inline void* zone::allocate_align(size_t size, size_t align)
+{
+    char* aligned = get_aligned(m_chunk_list.m_ptr, align);
+    size_t adjusted_size = size + (aligned - m_chunk_list.m_ptr);
+    if (m_chunk_list.m_free < adjusted_size) {
+        size_t enough_size = size + align - 1;
+        char* ptr = allocate_expand(enough_size);
+        aligned = get_aligned(ptr, align);
+        adjusted_size = size + (aligned - m_chunk_list.m_ptr);
+    }
+    m_chunk_list.m_free -= adjusted_size;
+    m_chunk_list.m_ptr  += adjusted_size;
+    return aligned;
+}
+
+inline void* zone::allocate_no_align(size_t size)
+{
+    char* ptr = m_chunk_list.m_ptr;
+    if(m_chunk_list.m_free < size) {
+        ptr = allocate_expand(size);
+    }
+    m_chunk_list.m_free -= size;
+    m_chunk_list.m_ptr  += size;
+
+    return ptr;
+}
+
+inline char* 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;
+    cl->m_ptr  = ptr;
+
+    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) {
+    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), MSGPACK_ZONE_ALIGNOF(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_V1_CPP03_ZONE_HPP

erb/v1/cpp03_zone_decl.hpp.erb

@@ -0,0 +1,54 @@
+//
+// MessagePack for C++ memory pool
+//
+// Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_V1_CPP03_ZONE_DECL_HPP
+#define MSGPACK_V1_CPP03_ZONE_DECL_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
+
+#if defined(_MSC_VER)
+#define MSGPACK_ZONE_ALIGNOF(type) __alignof(type)
+#else
+#define MSGPACK_ZONE_ALIGNOF(type) __alignof__(type)
+#endif
+// For a compiler that doesn't support __alignof__:
+// #define MSGPACK_ZONE_ALIGNOF(type) MSGPACK_ZONE_ALIGN
+
+<% GENERATION_LIMIT = 15 %>
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+class zone;
+
+std::size_t aligned_size(
+    std::size_t size,
+    std::size_t align = MSGPACK_ZONE_ALIGN);
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+}  // namespace msgpack
+
+#endif // MSGPACK_V1_CPP03_ZONE_DECL_HPP

example/CMakeLists.txt

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

example/boost/CMakeLists.txt

@@ -0,0 +1,56 @@
+IF (MSGPACK_BOOST)
+    LIST (APPEND exec_PROGRAMS
+        msgpack_variant_capitalize.cpp
+        msgpack_variant_mapbased.cpp
+    )
+    IF (MSGPACK_CXX11 OR MSGPACK_CXX17)
+        FIND_PACKAGE (Threads REQUIRED)
+        LIST (APPEND exec_PROGRAMS
+            asio_send_recv.cpp
+        )
+        IF (ZLIB_FOUND)
+            INCLUDE_DIRECTORIES (
+                ${ZLIB_INCLUDE_DIRS}
+            )
+            LIST (APPEND exec_PROGRAMS
+                asio_send_recv_zlib.cpp
+            )
+        ENDIF ()
+    ENDIF ()
+ENDIF ()
+
+FOREACH (source_file ${exec_PROGRAMS})
+    GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
+    ADD_EXECUTABLE (
+        ${source_file_we}
+        ${source_file}
+    )
+    TARGET_INCLUDE_DIRECTORIES (${source_file_we}
+        PRIVATE
+            $<TARGET_PROPERTY:msgpackc,INTERFACE_INCLUDE_DIRECTORIES>
+    )
+    TARGET_LINK_LIBRARIES (${source_file_we}
+        ${Boost_SYSTEM_LIBRARY}
+        ${CMAKE_THREAD_LIBS_INIT}
+    )
+    IF (ZLIB_FOUND)
+        TARGET_LINK_LIBRARIES (${source_file_we}
+            ${ZLIB_LIBRARIES}
+        )
+    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")
+    ENDIF ()
+
+    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+        SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
+    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/asio_send_recv.cpp

@@ -0,0 +1,104 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2017 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <string>
+#include <sstream>
+#include <iostream>
+
+#include <boost/asio.hpp>
+#include <boost/lexical_cast.hpp>
+
+#include <msgpack.hpp>
+
+int main() {
+    boost::asio::io_service ios;
+    std::uint16_t const port = 12345;
+
+    // Server
+    std::size_t const window_size = 10;
+    boost::asio::ip::tcp::acceptor ac(ios, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port));
+    boost::asio::ip::tcp::socket ss(ios);
+    std::function<void()> do_accept;
+    std::function<void()> do_async_read_some;
+
+    msgpack::unpacker unp;
+
+    do_accept = [&] {
+        ac.async_accept(
+            ss,
+            [&]
+            (boost::system::error_code const& e) {
+                if (e) {
+                    std::cout << __LINE__ << ":" << e.message() << std::endl;
+                    return;
+                }
+                unp.reserve_buffer(window_size);
+                do_async_read_some = [&] {
+                    ss.async_read_some(
+                        boost::asio::buffer(unp.buffer(), window_size),
+                        [&](boost::system::error_code const& e, std::size_t bytes_transferred) {
+                            if (e) {
+                                std::cout << __LINE__ << ":" << e.message() << std::endl;
+                                return;
+                            }
+                            std::cout << bytes_transferred << " bytes read." << std::endl;
+                            unp.buffer_consumed(bytes_transferred);
+                            msgpack::object_handle oh;
+                            while (unp.next(oh)) {
+                                std::cout << oh.get() << std::endl;
+                                // In order to finish the program,
+                                // return if one complete msgpack is processed.
+                                // In actual server, don't return here.
+                                return;
+                            }
+                            do_async_read_some();
+                        }
+                    );
+                };
+                do_async_read_some();
+            }
+        );
+    };
+    do_accept();
+
+    // Client
+    auto host = "localhost";
+    boost::asio::ip::tcp::resolver r(ios);
+
+#if BOOST_VERSION < 106600
+    boost::asio::ip::tcp::resolver::query q(host, boost::lexical_cast<std::string>(port));
+    auto it = r.resolve(q);
+    boost::asio::ip::tcp::resolver::iterator end;
+#else  // BOOST_VERSION < 106600
+    auto eps = r.resolve(host, boost::lexical_cast<std::string>(port));
+    auto it = eps.begin();
+    auto end = eps.end();
+#endif // BOOST_VERSION < 106600
+
+    boost::asio::ip::tcp::socket cs(ios);
+    boost::asio::async_connect(
+        cs,
+        it,
+        end,
+        [&]
+        (boost::system::error_code const& e, boost::asio::ip::tcp::resolver::iterator) {
+            if (e) {
+                std::cout << __LINE__ << ":" << e.message() << std::endl;
+                return;
+            }
+            std::cout << __LINE__ << ":client connected" << std::endl;
+            msgpack::sbuffer sb;
+            msgpack::pack(sb, std::make_tuple(42, false, "hello world", 12.3456));
+            write(cs, boost::asio::buffer(sb.data(), sb.size()));
+        }
+    );
+
+    // Start
+    ios.run();
+}

example/boost/asio_send_recv_zlib.cpp

@@ -0,0 +1,176 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2017 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <string>
+#include <sstream>
+#include <iostream>
+
+#include <boost/asio.hpp>
+#include <boost/lexical_cast.hpp>
+
+#include <msgpack.hpp>
+#include <msgpack/zbuffer.hpp>
+
+#include <zlib.h>
+
+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() {
+    boost::asio::io_service ios;
+    std::uint16_t const port = 12345;
+
+    int num_of_zlib_data = 2;
+    int idx_zlib_data = 0;
+
+    // Server
+    std::size_t const window_size = 11;
+    boost::asio::ip::tcp::acceptor ac(ios, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port));
+    boost::asio::ip::tcp::socket ss(ios);
+    std::function<void()> do_accept;
+    std::function<void()> do_async_read_some;
+
+    // zlib for decompress
+    z_stream strm;
+    auto zlib_init = [&] {
+        strm.zalloc = Z_NULL;
+        strm.zfree = Z_NULL;
+        strm.opaque = Z_NULL;
+        strm.next_in = Z_NULL;
+        {
+            int zret = inflateInit(&strm);
+            if (zret != Z_OK) {
+                std::cout << "Zlib inflateInit() error = " << zret << std::endl;
+            }
+        }
+    };
+    zlib_init();
+    std::vector<char> buf(4); // buf size
+
+    msgpack::unpacker unp;
+
+    do_accept = [&] {
+        ac.async_accept(
+            ss,
+            [&]
+            (boost::system::error_code const& e) {
+                if (e) {
+                    std::cout << __LINE__ << ":" << e.message() << std::endl;
+                    return;
+                }
+                do_async_read_some = [&] {
+                    ss.async_read_some(
+                        boost::asio::buffer(buf),
+                        [&](boost::system::error_code const& e, std::size_t bytes_transferred) {
+                            if (e) {
+                                std::cout << __LINE__ << ":" << e.message() << std::endl;
+                                return;
+                            }
+                            std::cout << bytes_transferred << " bytes read." << std::endl;
+                            print(std::string(std::string(&buf[0], buf.size())));
+                            strm.avail_in = bytes_transferred;
+                            do {
+                                strm.next_in = reinterpret_cast<unsigned char*>(&buf[0]) + (bytes_transferred - strm.avail_in);
+                                int zret;
+                                unp.reserve_buffer(window_size);
+                                strm.avail_out = window_size;
+                                strm.next_out = reinterpret_cast<unsigned char*>(unp.buffer());
+                                do {
+                                    zret = inflate(&strm, Z_NO_FLUSH);
+                                    assert(zret != Z_STREAM_ERROR);
+                                    switch (zret) {
+                                    case Z_NEED_DICT:
+                                        zret = Z_DATA_ERROR;
+                                        // fall through
+                                    case Z_DATA_ERROR:
+                                    case Z_MEM_ERROR:
+                                        inflateEnd(&strm);
+                                        std::cout << "Zlib inflate() error = " << zret << std::endl;
+                                        std::exit(-1);
+                                    }
+                                    std::size_t decompressed_size = window_size - strm.avail_out;
+                                    std::cout << decompressed_size << " bytes decompressed." << std::endl;
+                                    unp.buffer_consumed(decompressed_size);
+                                    msgpack::object_handle oh;
+                                    while (unp.next(oh)) {
+                                        std::cout << oh.get() << std::endl;
+                                    }
+                                } while (strm.avail_out == 0);
+                                if (zret == Z_STREAM_END) {
+                                    inflateEnd(&strm);
+                                    std::cout << "Zlib decompress finished." << std::endl;
+                                    ++idx_zlib_data;
+                                    if (idx_zlib_data == num_of_zlib_data) {
+                                        std::cout << "All zlib decompress finished." << std::endl;
+                                        return;
+                                    }
+                                    zlib_init();
+                                }
+                            } while (strm.avail_in != 0);
+                            do_async_read_some();
+                        }
+                    );
+                };
+                do_async_read_some();
+            }
+        );
+    };
+    do_accept();
+
+    // Client
+    auto host = "localhost";
+
+    boost::asio::ip::tcp::resolver r(ios);
+
+#if BOOST_VERSION < 106600
+    boost::asio::ip::tcp::resolver::query q(host, boost::lexical_cast<std::string>(port));
+    auto it = r.resolve(q);
+    boost::asio::ip::tcp::resolver::iterator end;
+#else  // BOOST_VERSION < 106600
+    auto eps = r.resolve(host, boost::lexical_cast<std::string>(port));
+    auto it = eps.begin();
+    auto end = eps.end();
+#endif // BOOST_VERSION < 106600
+
+    boost::asio::ip::tcp::socket cs(ios);
+    boost::asio::async_connect(
+        cs,
+        it,
+        end,
+        [&]
+        (boost::system::error_code const& e, boost::asio::ip::tcp::resolver::iterator) {
+            if (e) {
+                std::cout << __LINE__ << ":" << e.message() << std::endl;
+                return;
+            }
+            std::cout << __LINE__ << ":client connected" << std::endl;
+            for (int i = 0; i != num_of_zlib_data; ++i) {
+                msgpack::zbuffer zb;
+                msgpack::pack(zb, std::make_tuple(i, false, "hello world", 12.3456));
+                zb.flush(); // finalize zbuffer (don't forget it)
+                print(std::string(zb.data(), zb.size()));
+                write(cs, boost::asio::buffer(zb.data(), zb.size()));
+            }
+        }
+    );
+
+    // Start
+    ios.run();
+}

example/boost/msgpack_variant_capitalize.cpp

@@ -0,0 +1,94 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2015 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#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::object_handle oh1 = msgpack::unpack(ss1.str().data(), ss1.str().size());
+    msgpack::object const& obj1 = oh1.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::object_handle oh2 = msgpack::unpack(ss2.str().data(), ss2.str().size());
+    msgpack::object const& obj2 = oh2.get();
+    std::cout << "Modified msgpack object." << std::endl;
+    std::cout << obj2 << std::endl;
+}

example/boost/msgpack_variant_mapbased.cpp

@@ -0,0 +1,96 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2015 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#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)
+#  if MSGPACK_LIB_STD_CXX
+                v.erase(std::multimap<msgpack::type::variant_ref, msgpack::type::variant_ref>::const_iterator(it++));
+#  else  // MSGPACK_LIB_STD_CXX
+                v.erase(it++);
+#  endif // MSGPACK_LIB_STD_CXX
+#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::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    msgpack::object const& obj = oh.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,42 @@
+IF (MSGPACK_ENABLE_SHARED)
+    SET (MSGPACK_LIB msgpackc)
+ENDIF ()
+
+IF (MSGPACK_ENABLE_STATIC)
+    SET (MSGPACK_LIB msgpackc-static)
+ENDIF ()
+
+
+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_LIB}
+    )
+    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")
+    ENDIF ()
+
+    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+        SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
+    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,127 @@
+#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)
+{
+    size_t recv_len;
+    // 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);
+    }
+    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)
+#if defined(_MSC_VER) || defined(__MINGW32__)
+        printf("receive count: %d %Id bytes received.\n", recv_count++, recv_len);
+#else // defined(_MSC_VER) || defined(__MINGW32__)
+        printf("receive count: %d %zd bytes received.\n", recv_count++, recv_len);
+#endif // defined(_MSC_VER) || defined(__MINGW32__)
+        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_UNPACK_SUCCESS) {
+    }
+
+    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_UNPACK_SUCCESS) {
+    }
+
+    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,81 @@
+#include <msgpack.h>
+#include <stdio.h>
+#include <assert.h>
+
+#define UNPACKED_BUFFER_SIZE 2048
+
+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;
+    char unpacked_buffer[UNPACKED_BUFFER_SIZE];
+    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");
+        msgpack_object_print_buffer(unpacked_buffer, UNPACKED_BUFFER_SIZE, obj);
+        printf("%s\n", unpacked_buffer);
+        /* 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,120 @@
+LIST (APPEND exec_PROGRAMS
+    class_intrusive.cpp
+    class_intrusive_map.cpp
+    class_non_intrusive.cpp
+    custom.cpp
+    enum.cpp
+    map_based_versionup.cpp
+    protocol_new.cpp
+    reuse_zone.cpp
+    simple.cpp
+)
+
+IF (MSGPACK_DEFAULT_API_VERSION EQUAL 1)
+    LIST (APPEND exec_PROGRAMS
+        protocol.cpp
+    )
+ENDIF ()
+
+IF (NOT MSVC)
+    LIST (APPEND with_pthread_PROGRAMS
+        stream.cpp
+    )
+ENDIF ()
+
+IF (MSGPACK_BOOST)
+    LIST (APPEND with_boost_lib_PROGRAMS
+        speed_test.cpp
+        speed_test_nested_array.cpp
+    )
+ENDIF ()
+
+FOREACH (source_file ${exec_PROGRAMS})
+    GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
+    ADD_EXECUTABLE (
+        ${source_file_we}
+        ${source_file}
+    )
+    TARGET_INCLUDE_DIRECTORIES (${source_file_we}
+        PRIVATE
+            $<TARGET_PROPERTY:msgpackc,INTERFACE_INCLUDE_DIRECTORIES>
+    )
+    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")
+    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_INCLUDE_DIRECTORIES (${source_file_we}
+        PRIVATE
+            $<TARGET_PROPERTY:msgpackc,INTERFACE_INCLUDE_DIRECTORIES>
+    )
+    TARGET_LINK_LIBRARIES (${source_file_we}
+        ${CMAKE_THREAD_LIBS_INIT}
+    )
+    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")
+    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}
+    )
+    TARGET_INCLUDE_DIRECTORIES (${source_file_we}
+        PRIVATE
+            $<TARGET_PROPERTY:msgpackc,INTERFACE_INCLUDE_DIRECTORIES>
+    )
+    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 -O3")
+    ENDIF ()
+
+    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+        SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
+    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,103 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#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::object_handle oh =
+            msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::object obj = oh.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,75 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2015 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#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::object_handle oh =
+            msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::object obj = oh.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,118 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#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, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
+        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::object_handle oh =
+            msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::object obj = oh.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,67 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#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::object_handle oh =
+            msgpack::unpack(sbuf.str().data(), sbuf.str().size());
+        msgpack::object obj = oh.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::object_handle oh =
+            msgpack::unpack(sbuf.str().data(), sbuf.str().size());
+        msgpack::object obj = oh.get();
+
+        obj.convert(oc);
+
+        std::cout << obj << " value=" << oc.value << std::endl;
+    }
+}

example/cpp03/enum.cpp

@@ -0,0 +1,59 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2015 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#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::object_handle oh;
+        std::size_t off = 0;
+
+        msgpack::unpack(oh, sbuf.str().data(), sbuf.str().size(), off);
+        std::cout << oh.get().as<my_enum>() << std::endl;
+        assert(oh.get().as<my_enum>() == elem1);
+
+        msgpack::unpack(oh, sbuf.str().data(), sbuf.str().size(), off);
+        std::cout << oh.get().as<my_enum>() << std::endl;
+        assert(oh.get().as<my_enum>() == elem2);
+
+        msgpack::unpack(oh, sbuf.str().data(), sbuf.str().size(), off);
+        std::cout << oh.get().as<my_enum>() << std::endl;
+        assert(oh.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,111 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2015 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#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::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+
+        msgpack::object obj = oh.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,97 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#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::object_handle oh =
+            msgpack::unpack(buffer.data(), buffer.size());
+        msgpack::object o = oh.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::object_handle oh =
+            msgpack::unpack(buffer.data(), buffer.size());
+        msgpack::object o = oh.get();
+
+
+        myprotocol::MultiGet req;
+        o.convert(req);
+        std::cout << "received: " << o << std::endl;
+    }
+}

example/cpp03/protocol_new.cpp

@@ -0,0 +1,84 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2015 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#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::object_handle oh =
+            msgpack::unpack(buffer.data(), buffer.size());
+        msgpack::object o = oh.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::object_handle oh =
+            msgpack::unpack(buffer.data(), buffer.size());
+        msgpack::object o = oh.get();
+
+
+        myprotocol::MultiGet req;
+        o.convert(req);
+        std::cout << "received: " << o << std::endl;
+    }
+}

example/cpp03/reuse_zone.cpp

@@ -0,0 +1,42 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2015 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#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,44 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#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::object_handle oh = msgpack::unpack(str.data(), str.size());
+
+    // deserialized object is valid during the msgpack::object_handle instance alive.
+    msgpack::object deserialized = oh.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,63 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2013-2015 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// 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::object_handle oh;
+    std::cout << "Start unpacking...by void unpack(object_handle& oh, const char* data, size_t len)" << std::endl;
+    {
+        boost::timer::cpu_timer timer;
+        msgpack::unpack(oh, 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;
+        oh.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,86 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2013-2015 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// 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::object_handle oh;
+    std::cout << "Start unpacking...by void unpack(object_handle& oh, const char* data, size_t len)" << std::endl;
+    {
+        boost::timer::cpu_timer timer;
+        msgpack::unpack(oh, 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;
+        oh.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,148 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <msgpack.hpp>
+#include <iostream>
+#include <stdexcept>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <pthread.h>
+
+#if defined(_MSC_VER) || defined(__MINGW32__)
+#include <io.h>
+#include <fcntl.h>
+#define pipe(fds) _pipe(fds, 4096, _O_BINARY)
+#endif // _MSC_VER || __MINGW32__
+
+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::object_handle oh;
+        while (m_pac.next(oh)) {
+            msgpack::object msg = oh.get();
+            unique_zone& life = oh.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,43 @@
+IF (MSGPACK_CXX11)
+    INCLUDE_DIRECTORIES (
+        ../include
+    )
+
+    LIST (APPEND exec_PROGRAMS
+        container.cpp
+        non_def_con_class.cpp
+    )
+
+    IF ("${MSGPACK_DEFAULT_API_VERSION}" GREATER "1")
+        LIST (APPEND exec_PROGRAMS
+            socket_stream_example.cpp
+        )
+    ENDIF ()
+
+    FOREACH (source_file ${exec_PROGRAMS})
+        GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
+        ADD_EXECUTABLE (
+            ${source_file_we}
+            ${source_file}
+        )
+        TARGET_INCLUDE_DIRECTORIES (${source_file_we}
+            PRIVATE
+                $<TARGET_PROPERTY:msgpackc,INTERFACE_INCLUDE_DIRECTORIES>
+        )
+        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")
+        ENDIF ()
+
+        IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+            SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
+        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,149 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2015 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#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::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    msgpack::object obj = oh.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 oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    auto obj = oh.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 oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    msgpack::object obj = oh.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 oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    auto obj = oh.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 oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    auto obj = oh.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 oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
+        auto obj = oh.get();
+
+        std::cout << obj << std::endl;
+        assert(obj.as<decltype(a)>() == a);
+    }
+    std::cout << "offset: " << offset << std::endl;
+    {
+        auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
+        auto obj = oh.get();
+
+        std::cout << obj << std::endl;
+        assert(obj.as<decltype(t)>() == t);
+    }
+    std::cout << "offset: " << offset << std::endl;
+    {
+        auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
+        auto obj = oh.get();
+
+        std::cout << obj << std::endl;
+        assert(obj.as<decltype(m)>() == m);
+    }
+    std::cout << "offset: " << offset << std::endl;
+    {
+        auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
+        auto obj = oh.get();
+
+        std::cout << obj << std::endl;
+        assert(obj.as<decltype(s)>() == s);
+    }
+    std::cout << "offset: " << offset << std::endl;
+    {
+        auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
+        auto obj = oh.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,51 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2015 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#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/cpp11/socket_stream_example.cpp

@@ -0,0 +1,157 @@
+#include <iostream>
+#include <sstream>
+#include <msgpack.hpp>
+
+struct json_like_visitor : msgpack::v2::null_visitor {
+    json_like_visitor(std::string& s):m_s(s), m_ref(false) {} // m_ref is false by default
+
+    bool visit_nil() {
+        m_s += "null";
+        return true;
+    }
+    bool visit_boolean(bool v) {
+        if (v) m_s += "true";
+        else m_s += "false";
+        return true;
+    }
+    bool visit_positive_integer(uint64_t v) {
+        std::stringstream ss;
+        ss << v;
+        m_s += ss.str();
+        return true;
+    }
+    bool visit_negative_integer(int64_t v) {
+        std::stringstream ss;
+        ss << v;
+        m_s += ss.str();
+        return true;
+    }
+    bool visit_str(const char* v, uint32_t size) {
+        // I omit escape process.
+        m_s += '"' + std::string(v, size) + '"';
+        return true;
+    }
+    bool start_array(uint32_t /*num_elements*/) {
+        m_s += "[";
+        return true;
+    }
+    bool end_array_item() {
+        m_s += ",";
+        return true;
+    }
+    bool end_array() {
+        m_s.erase(m_s.size() - 1, 1); // remove the last ','
+        m_s += "]";
+        return true;
+    }
+    bool start_map(uint32_t /*num_kv_pairs*/) {
+        m_s += "{";
+        return true;
+    }
+    bool end_map_key() {
+        m_s += ":";
+        return true;
+    }
+    bool end_map_value() {
+        m_s += ",";
+        return true;
+    }
+    bool end_map() {
+        m_s.erase(m_s.size() - 1, 1); // remove the last ','
+        m_s += "}";
+        return true;
+    }
+    void parse_error(size_t /*parsed_offset*/, size_t /*error_offset*/) {
+        std::cerr << "parse error"<<std::endl;
+    }
+    void insufficient_bytes(size_t /*parsed_offset*/, size_t /*error_offset*/) {
+        std::cout << "insufficient bytes"<<std::endl;
+    }
+    std::string& m_s;
+
+    // These two functions are required by parser.
+    void set_referenced(bool ref) { m_ref = ref; }
+    bool referenced() const { return m_ref; }
+    bool m_ref;
+};
+
+struct do_nothing {
+    void operator()(char* /*buffer*/) {
+    }
+};
+
+class json_like_printer : public msgpack::parser<json_like_printer, do_nothing>,
+                          public json_like_visitor {
+    typedef parser<json_like_printer, do_nothing> parser_t;
+public:
+    json_like_printer(std::size_t initial_buffer_size = MSGPACK_UNPACKER_INIT_BUFFER_SIZE)
+        :parser_t(do_nothing_, initial_buffer_size),
+         json_like_visitor(json_str_) {
+    }
+
+    json_like_visitor& visitor() { return *this; }
+    void print() { std::cout << json_str_ << std::endl; json_str_.clear();}
+private:
+    do_nothing do_nothing_;
+    std::string json_str_;
+};
+
+template <typename T>
+struct ref_buffer {
+    ref_buffer(T& t):t(t) {}
+    void write(char const* ptr, std::size_t len) {
+        if (len > t.buffer_capacity()) {
+            t.reserve_buffer(len - t.buffer_capacity());
+        }
+        std::memcpy(t.buffer(), ptr, len);
+        t.buffer_consumed(len);
+    }
+    T& t;
+};
+
+#define BUFFERING_SIZE_MAX 100
+
+//simulates streamed content (a socket for example)
+bool produce( std::stringstream & ss, char* buff, std::size_t& size)
+{
+    ss.read(buff, BUFFERING_SIZE_MAX);
+    size = static_cast<std::size_t>(ss.gcount());
+    return (size > 0);
+}
+
+//shows how you can treat data 
+void consume( const char* buff, const std::size_t size, 
+    ref_buffer<json_like_printer> & rb,
+    json_like_printer & jp
+    )
+{
+    rb.write(buff,size);
+    while( jp.next() )
+    {
+        //here we print the data, you could do any wanted processing
+        jp.print();
+    }  
+}
+
+int main() {
+
+    std::vector<std::vector<int>> vvi1 { { 1,2,3,4,5}, { 6,7,8,9,10} }; 
+    std::vector<std::vector<int>> vvi2 { { 11,12,13,14,15}, { 16,17,18,19,20} };
+
+    std::stringstream ss;
+    
+    msgpack::pack(ss, vvi1);
+    msgpack::pack(ss, vvi2);
+
+    char buffer[BUFFERING_SIZE_MAX];
+    std::size_t size = 0;
+
+    json_like_printer jp(1); // set initial buffer size explicitly
+    ref_buffer<json_like_printer> rb(jp);
+
+    while( produce(ss,buffer,size) )
+    {
+        consume(buffer, size, rb, jp);
+    }
+
+}

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

example/x3/CMakeLists.txt

@@ -0,0 +1,72 @@
+IF (MSGPACK_USE_X3_PARSE AND MSGPACK_DEFAULT_API_VERSION VERSION_GREATER 1)
+    INCLUDE_DIRECTORIES (
+        ../include
+    )
+
+    LIST (APPEND exec_PROGRAMS
+        unpack.cpp
+        parse.cpp
+    )
+    IF (MSGPACK_BOOST)
+        LIST (APPEND with_boost_PROGRAMS
+            stream_unpack.cpp
+        )
+    ENDIF ()
+    FOREACH (source_file ${exec_PROGRAMS})
+        GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
+        ADD_EXECUTABLE (
+            ${source_file_we}
+            ${source_file}
+        )
+        TARGET_INCLUDE_DIRECTORIES (${source_file_we}
+            PRIVATE
+                $<TARGET_PROPERTY:msgpackc,INTERFACE_INCLUDE_DIRECTORIES>
+        )
+        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")
+        ENDIF ()
+
+        IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+            SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
+        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_PROGRAMS})
+        GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
+        ADD_EXECUTABLE (
+            ${source_file_we}
+            ${source_file}
+        )
+        TARGET_INCLUDE_DIRECTORIES (${source_file_we}
+            PRIVATE
+                $<TARGET_PROPERTY:msgpackc,INTERFACE_INCLUDE_DIRECTORIES>
+        )
+        TARGET_LINK_LIBRARIES (${source_file_we}
+            ${Boost_CONTEXT_LIBRARY}
+            ${Boost_SYSTEM_LIBRARY}
+            ${CMAKE_THREAD_LIBS_INIT}
+        )
+        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")
+        ENDIF ()
+
+        IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+            SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
+        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/x3/parse.cpp

@@ -0,0 +1,125 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2017 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <iostream>
+#include <sstream>
+#include <cassert>
+
+// MSGPACK_USE_X3_PARSE should be defined before including msgpack.hpp
+// It usually defined as a compiler option as -DMSGPACK_USE_X3_PARSE.
+
+#include <msgpack.hpp>
+
+struct json_like_visitor : msgpack::v2::null_visitor {
+    json_like_visitor(std::string& s):m_s(s) {}
+
+    bool visit_nil() {
+        m_s += "null";
+        return true;
+    }
+    bool visit_boolean(bool v) {
+        if (v) m_s += "true";
+        else m_s += "false";
+        return true;
+    }
+    bool visit_positive_integer(uint64_t v) {
+        std::stringstream ss;
+        ss << v;
+        m_s += ss.str();
+        return true;
+    }
+    bool visit_negative_integer(int64_t v) {
+        std::stringstream ss;
+        ss << v;
+        m_s += ss.str();
+        return true;
+    }
+    bool visit_float32(float v) {
+        std::stringstream ss;
+        ss << v;
+        m_s += ss.str();
+        return true;
+    }
+    bool visit_float64(double v) {
+        std::stringstream ss;
+        ss << v;
+        m_s += ss.str();
+        return true;
+    }
+    bool visit_str(const char* v, uint32_t size) {
+        m_s += '"' + std::string(v, size) + '"';
+        return true;
+    }
+    bool start_array(uint32_t /*num_elements*/) {
+        m_s += "[";
+        return true;
+    }
+    bool end_array_item() {
+        m_s += ",";
+        return true;
+    }
+    bool end_array() {
+        m_s.erase(m_s.size() - 1, 1); // remove the last ','
+        m_s += "]";
+        return true;
+    }
+    bool start_map(uint32_t /*num_kv_pairs*/) {
+        m_s += "{";
+        return true;
+    }
+    bool end_map_key() {
+        m_s += ":";
+        return true;
+    }
+    bool end_map_value() {
+        m_s += ",";
+        return true;
+    }
+    bool end_map() {
+        m_s.erase(m_s.size() - 1, 1); // remove the last ','
+        m_s += "}";
+        return true;
+    }
+    void parse_error(size_t /*parsed_offset*/, size_t /*error_offset*/) {
+    }
+    void insufficient_bytes(size_t /*parsed_offset*/, size_t /*error_offset*/) {
+    }
+    std::string& m_s;
+};
+
+int main() {
+    std::stringstream ss;
+    std::map<std::string, std::vector<int>> v1 {
+        { "ABC", { 1, 2, 3 } },
+        { "DEFG", { 4, 5 } }
+    };
+    std::vector<std::string> v2 {
+        "HIJ", "KLM", "NOP"
+    };
+    msgpack::pack(ss, v1);
+    msgpack::pack(ss, v2);
+
+    std::string const& buf = ss.str();
+    auto it = buf.begin();
+    auto end = buf.end();
+    {
+        std::string str;
+        bool ret = msgpack::parse(it, end, json_like_visitor(str));
+        // it is updated here.
+        assert(ret);
+        std::cout << str << std::endl;
+    }
+    {
+        std::string str;
+        bool ret = msgpack::parse(it, end, json_like_visitor(str));
+        // it is updated here.
+        assert(ret);
+        std::cout << str << std::endl;
+    }
+}

example/x3/stream_unpack.cpp

@@ -0,0 +1,248 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2017 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <iostream>
+#include <sstream>
+#include <cassert>
+#include <thread>
+
+// MSGPACK_USE_X3_PARSE should be defined before including msgpack.hpp
+// It usually defined as a compiler option as -DMSGPACK_USE_X3_PARSE.
+
+//#define MSGPACK_USE_X3_PARSE
+
+#include <msgpack.hpp>
+
+#include <boost/asio.hpp>
+#include <boost/coroutine2/all.hpp>
+
+#if defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif // defined(__clang__)
+
+#include <boost/spirit/home/support/multi_pass.hpp>
+
+#if defined(__clang__)
+#pragma GCC diagnostic pop
+#endif // defined(__clang__)
+
+namespace as = boost::asio;
+namespace x3 = boost::spirit::x3;
+namespace coro2 = boost::coroutines2;
+
+using pull_type = coro2::asymmetric_coroutine<std::shared_ptr<std::vector<char>>>::pull_type;
+
+// iterator fetching data from coroutine2.
+class buffered_iterator : public std::iterator<std::input_iterator_tag, char> {
+public:
+    using pointer_t = typename iterator::pointer;
+    using reference_t = typename iterator::reference;
+
+    explicit buffered_iterator(pull_type& source) noexcept
+        : source_{ &source } {
+        fetch_();
+    }
+    buffered_iterator() = default;
+
+    bool operator==(buffered_iterator const& other) const noexcept {
+        if (!other.source_ && !source_ && !other.buf_ && !buf_) return true;
+        return other.it_ == it_;
+    }
+
+    bool operator!=(buffered_iterator const& other) const noexcept {
+        return !(other == *this);
+    }
+
+    buffered_iterator & operator++() {
+        increment_();
+        return * this;
+    }
+
+    buffered_iterator operator++(int) = delete;
+
+    reference_t operator*() noexcept {
+        return *it_;
+    }
+
+    pointer_t operator->() noexcept {
+        return std::addressof(*it_);
+    }
+
+private:
+    void fetch_() noexcept {
+        BOOST_ASSERT( nullptr != source_);
+        if (*source_) {
+            buf_ = source_->get();
+            it_ = buf_->begin();
+        }
+        else {
+            source_ = nullptr;
+            buf_.reset();
+        }
+    }
+
+    void increment_() {
+        BOOST_ASSERT( nullptr != source_);
+        BOOST_ASSERT(*source_);
+        if (++it_ == buf_->end()) {
+            (*source_)();
+            fetch_();
+        }
+    }
+
+private:
+    pull_type* source_{ nullptr };
+    std::shared_ptr<std::vector<char>> buf_;
+    std::vector<char>::iterator it_;
+};
+
+// session class that corresponding to each client
+class session : public std::enable_shared_from_this<session> {
+public:
+    session(as::ip::tcp::socket socket)
+        : socket_(std::move(socket)) {
+    }
+
+    void start() {
+        sink_ = std::make_shared<coro2::asymmetric_coroutine<std::shared_ptr<std::vector<char>>>::push_type>(
+            [&, this](pull_type& source) {
+                // *1 is started when the first sink is called.
+
+                std::cout << "session started" << std::endl;
+                do_read();
+                source();
+
+                // use buffered_iterator here
+                // b is incremented in msgpack::unpack() and fetch data from sink
+                // via coroutine2 mechanism
+                auto b = boost::spirit::make_default_multi_pass(buffered_iterator(source));
+                auto e = boost::spirit::make_default_multi_pass(buffered_iterator());
+
+                // This is usually an infinity look, but for test, loop is finished when
+                // two message pack data is processed.
+                for (int i = 0; i != 2; ++i) {
+                    auto oh = msgpack::unpack(b, e);
+                    std::cout << oh.get() << std::endl;
+                }
+            }
+        );
+        // send dummy data to start *1
+        (*sink_)({});
+    }
+
+private:
+    void do_read() {
+        std::cout << "session do_read() is called" << std::endl;
+        auto self(shared_from_this());
+        auto data = std::make_shared<std::vector<char>>(static_cast<std::size_t>(max_length));
+        socket_.async_read_some(
+            boost::asio::buffer(*data),
+            [this, self, data]
+            (boost::system::error_code ec, std::size_t length) {
+                if (!ec) {
+                    data->resize(length);
+                    (*sink_)(data);
+                    do_read();
+                }
+            }
+        );
+    }
+
+    as::ip::tcp::socket socket_;
+    static constexpr std::size_t const max_length = 1024;
+    std::shared_ptr<coro2::asymmetric_coroutine<std::shared_ptr<std::vector<char>>>::push_type> sink_;
+};
+
+class server {
+public:
+    server(
+        as::io_service& ios,
+        std::uint16_t port)
+        : acceptor_(ios, as::ip::tcp::endpoint(as::ip::tcp::v4(), port)),
+          socket_(ios) {
+        do_accept();
+        std::cout << "server start accept" << std::endl;
+        ios.run();
+    }
+
+private:
+    void do_accept() {
+        acceptor_.async_accept(
+            socket_,
+            [this](boost::system::error_code ec) {
+                if (!ec) {
+                    std::make_shared<session>(std::move(socket_))->start();
+                }
+                // for test, only one session is accepted.
+                // do_accept();
+            }
+        );
+    }
+
+    as::ip::tcp::acceptor acceptor_;
+    as::ip::tcp::socket socket_;
+};
+
+int main() {
+    std::thread srv(
+        []{
+            boost::asio::io_service ios;
+            server s(ios, 12345);
+        }
+    );
+
+    std::thread cli(
+        []{
+            std::this_thread::sleep_for(std::chrono::seconds(1));
+            std::cout << "client start" << std::endl;
+
+            std::stringstream ss;
+            std::map<std::string, std::vector<int>> v1 {
+                { "ABC", { 1, 2, 3 } },
+                { "DEFG", { 4, 5 } }
+            };
+            std::vector<std::string> v2 {
+                "HIJ", "KLM", "NOP"
+                    };
+            msgpack::pack(ss, v1);
+            msgpack::pack(ss, v2);
+
+            auto send_data = ss.str();
+
+            boost::asio::io_service ios;
+            as::ip::tcp::resolver::query q("127.0.0.1", "12345");
+            as::ip::tcp::resolver r(ios);
+            auto it = r.resolve(q);
+
+            std::cout << "client connect" << std::endl;
+            as::ip::tcp::socket s(ios);
+            as::connect(s, it);
+
+
+            std::size_t const size = 5;
+            std::size_t rest = send_data.size();
+            std::size_t index = 0;
+            while (rest != 0) {
+                std::cout << "client send data" << std::endl;
+                auto send_size = size < rest ? size : rest;
+                as::write(s, as::buffer(&send_data[index], send_size));
+                rest -= send_size;
+                index += send_size;
+                std::cout << "client wait" << std::endl;
+                std::this_thread::sleep_for(std::chrono::seconds(1));
+            }
+        }
+    );
+
+    cli.join();
+    std::cout << "client joinded" << std::endl;
+    srv.join();
+    std::cout << "server joinded" << std::endl;
+}

example/x3/unpack.cpp

@@ -0,0 +1,43 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2017 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <iostream>
+#include <sstream>
+#include <cassert>
+
+// MSGPACK_USE_X3_PARSE should be defined before including msgpack.hpp
+// It usually defined as a compiler option as -DMSGPACK_USE_X3_PARSE.
+
+#include <msgpack.hpp>
+
+int main() {
+    std::stringstream ss;
+    std::map<std::string, std::vector<int>> v1 {
+        { "ABC", { 1, 2, 3 } },
+        { "DEFG", { 4, 5 } }
+    };
+    std::vector<std::string> v2 {
+        "HIJ", "KLM", "NOP"
+    };
+    msgpack::pack(ss, v1);
+    msgpack::pack(ss, v2);
+
+    std::string const& buf = ss.str();
+    auto it = buf.begin();
+    auto end = buf.end();
+    {
+        auto oh = msgpack::unpack(it, end);
+        // it is updated here.
+        assert(v1 == (oh.get().as<std::map<std::string, std::vector<int>>>()));
+    }
+    {
+        auto oh = msgpack::unpack(it, end);
+        assert(v2 == oh.get().as<std::vector<std::string>>());
+    }
+}

fuzz/CMakeLists.txt

@@ -0,0 +1,43 @@
+FIND_PACKAGE (GTest REQUIRED)
+FIND_PACKAGE (ZLIB REQUIRED)
+FIND_PACKAGE (Boost REQUIRED COMPONENTS system filesystem)
+
+INCLUDE_DIRECTORIES (
+  ${GTEST_INCLUDE_DIRS}
+  ${ZLIB_INCLUDE_DIRS}
+  ${Boost_INCLUDE_DIRS}
+)
+
+LIST (APPEND check_PROGRAMS
+    regression_runner.cpp
+)
+
+LINK_DIRECTORIES (
+  ${Boost_LIBRARY_DIRS}
+)
+
+FOREACH (source_file ${check_PROGRAMS})
+    GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
+    ADD_EXECUTABLE (
+        ${source_file_we}
+        ${source_file}
+    )
+    TARGET_LINK_LIBRARIES (${source_file_we}
+        msgpackc
+        ${GTEST_BOTH_LIBRARIES}
+        ${ZLIB_LIBRARIES}
+        ${CMAKE_THREAD_LIBS_INIT}
+        ${Boost_LIBRARIES}
+    )
+    ADD_TEST (${source_file_we} ${source_file_we})
+    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+      SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Wno-mismatched-tags -g")
+        IF ("${MSGPACK_SAN}" STREQUAL "ASAN")
+            SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-omit-frame-pointer -fsanitize=address")
+            SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-omit-frame-pointer -fsanitize=address")
+        ELSEIF ("${MSGPACK_SAN}" STREQUAL "UBSAN")
+            SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=undefined")
+            SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=undefined")
+        ENDIF()
+    ENDIF()
+ENDFOREACH ()

fuzz/regression_runner.cpp

@@ -0,0 +1,50 @@
+#include <boost/filesystem.hpp>
+#include <gtest/gtest.h>
+
+#include <fstream>
+#include <iostream>
+#include <vector>
+
+#include "unpack_pack_fuzzer.cpp"
+
+using ::testing::TestWithParam;
+using ::testing::ValuesIn;
+
+
+std::vector<std::string> ListDirectory(const std::string& path) {
+  std::vector<std::string> v;
+
+  boost::filesystem::path p(path);
+  boost::filesystem::directory_iterator f{p};
+
+  if(boost::filesystem::is_directory(p)) {
+    while (f != boost::filesystem::directory_iterator{}) {
+      v.push_back((*f++).path().string());
+    }
+  }
+  return v;
+}
+
+class UnpackPackFuzzerRegressionTest : public ::testing::TestWithParam<std::string> {
+public:
+};
+
+TEST_P(UnpackPackFuzzerRegressionTest, Returns0) {
+  auto fpath = GetParam();
+  std::ifstream in(fpath, std::ifstream::binary);
+  if (!in) {
+    FAIL() << fpath << " not found";
+  }
+  in.seekg(0, in.end);
+  size_t length = in.tellg();
+  in.seekg(0, in.beg);
+  std::vector<char> bytes(length);
+  in.read(bytes.data(), bytes.size());
+  assert(in);
+  EXPECT_EQ(0, LLVMFuzzerTestOneInput(reinterpret_cast<const uint8_t *>(bytes.data()),
+                                      bytes.size()));
+}
+
+INSTANTIATE_TEST_CASE_P(UnpackPackFuzzerRegressions,
+                        UnpackPackFuzzerRegressionTest,
+                        ::testing::ValuesIn(ListDirectory("../../fuzz/unpack_pack_fuzzer_regressions")));

fuzz/unpack_pack_fuzzer.cpp

@@ -0,0 +1,23 @@
+#include <msgpack.hpp>
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  try {
+    // NOTE(derwolfe): by default the limits are set at 2^32-1 length. I'm
+    // setting these at far smaller values to avoid OOMs
+    const int test_limit = 1000;
+    msgpack::object_handle unpacked = msgpack::unpack(reinterpret_cast<const char *>(data),
+                                                      size,
+                                                      nullptr,
+                                                      nullptr,
+                                                      msgpack::unpack_limit(test_limit,
+                                                                            test_limit,
+                                                                            test_limit,
+                                                                            test_limit,
+                                                                            test_limit,
+                                                                            test_limit));
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, unpacked.get());
+  } catch (...) {
+  }
+  return 0;
+}

fuzz/unpack_pack_fuzzer_seed_corpus/EmptyArray

@@ -0,0 +1 @@
+<EFBFBD>

fuzz/unpack_pack_fuzzer_seed_corpus/EmptyObject

@@ -0,0 +1 @@
+<EFBFBD>

fuzz/unpack_pack_fuzzer_seed_corpus/ExcessiveNesting

@@ -0,0 +1,2 @@
+<EFBFBD>
<01><02><03><04><05><06><07><08>	<09>
+<EFBFBD><0B><0C>

include/msgpack.h

@@ -0,0 +1,24 @@
+/*
+ * MessagePack for C
+ *
+ * Copyright (C) 2008-2009 FURUHASHI Sadayuki
+ *
+ *    Distributed under the Boost Software License, Version 1.0.
+ *    (See accompanying file LICENSE_1_0.txt or copy at
+ *    http://www.boost.org/LICENSE_1_0.txt)
+ */
+/**
+ * @defgroup msgpack MessagePack C
+ * @{
+ * @}
+ */
+
+#include "msgpack/util.h"
+#include "msgpack/object.h"
+#include "msgpack/zone.h"
+#include "msgpack/pack.h"
+#include "msgpack/unpack.h"
+#include "msgpack/sbuffer.h"
+#include "msgpack/vrefbuffer.h"
+#include "msgpack/version.h"
+

include/msgpack.hpp

@@ -0,0 +1,22 @@
+//
+// MessagePack for C++
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#include "msgpack/object.hpp"
+#include "msgpack/iterator.hpp"
+#include "msgpack/zone.hpp"
+#include "msgpack/pack.hpp"
+#include "msgpack/null_visitor.hpp"
+#include "msgpack/parse.hpp"
+#include "msgpack/unpack.hpp"
+#include "msgpack/x3_parse.hpp"
+#include "msgpack/x3_unpack.hpp"
+#include "msgpack/sbuffer.hpp"
+#include "msgpack/vrefbuffer.hpp"
+#include "msgpack/version.hpp"
+#include "msgpack/type.hpp"

include/msgpack/adaptor/adaptor_base.hpp

@@ -0,0 +1,19 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2015-2016 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_ADAPTOR_BASE_HPP
+#define MSGPACK_ADAPTOR_BASE_HPP
+
+#include "msgpack/adaptor/adaptor_base_decl.hpp"
+
+#include "msgpack/v1/adaptor/adaptor_base.hpp"
+#include "msgpack/v2/adaptor/adaptor_base.hpp"
+#include "msgpack/v3/adaptor/adaptor_base.hpp"
+
+#endif // MSGPACK_ADAPTOR_BASE_HPP

include/msgpack/adaptor/adaptor_base_decl.hpp

@@ -0,0 +1,17 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2016 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_ADAPTOR_BASE_DECL_HPP
+#define MSGPACK_ADAPTOR_BASE_DECL_HPP
+
+#include "msgpack/v1/adaptor/adaptor_base_decl.hpp"
+#include "msgpack/v2/adaptor/adaptor_base_decl.hpp"
+#include "msgpack/v3/adaptor/adaptor_base_decl.hpp"
+
+#endif // MSGPACK_ADAPTOR_BASE_DECL_HPP

include/msgpack/adaptor/array_ref.hpp

@@ -0,0 +1,17 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_TYPE_ARRAY_REF_HPP
+#define MSGPACK_TYPE_ARRAY_REF_HPP
+
+#include "msgpack/adaptor/array_ref_decl.hpp"
+
+#include "msgpack/v1/adaptor/array_ref.hpp"
+
+#endif // MSGPACK_TYPE_ARRAY_REFL_HPP

include/msgpack/adaptor/array_ref_decl.hpp

@@ -0,0 +1,17 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_TYPE_ARRAY_REF_DECL_HPP
+#define MSGPACK_TYPE_ARRAY_REF_DECL_HPP
+
+#include "msgpack/v1/adaptor/array_ref_decl.hpp"
+#include "msgpack/v2/adaptor/array_ref_decl.hpp"
+#include "msgpack/v3/adaptor/array_ref_decl.hpp"
+
+#endif // MSGPACK_TYPE_ARRAY_REF_DECL_HPP

include/msgpack/adaptor/bool.hpp

@@ -0,0 +1,15 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_TYPE_BOOL_HPP
+#define MSGPACK_TYPE_BOOL_HPP
+
+#include "msgpack/v1/adaptor/bool.hpp"
+
+#endif // MSGPACK_TYPE_BOOL_HPP

include/msgpack/adaptor/boost/fusion.hpp

@@ -0,0 +1,15 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2015 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_TYPE_BOOST_FUSION_HPP
+#define MSGPACK_TYPE_BOOST_FUSION_HPP
+
+#include "msgpack/v1/adaptor/boost/fusion.hpp"
+
+#endif // MSGPACK_TYPE_BOOST_FUSION_HPP

include/msgpack/adaptor/boost/msgpack_variant.hpp

@@ -0,0 +1,18 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2015-2016 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_HPP
+#define MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_HPP
+
+#include "msgpack/adaptor/boost/msgpack_variant_decl.hpp"
+
+#include "msgpack/v1/adaptor/boost/msgpack_variant.hpp"
+//#include "msgpack/v2/adaptor/boost/msgpack_variant.hpp"
+
+#endif // MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_HPP

include/msgpack/adaptor/boost/msgpack_variant_decl.hpp

@@ -0,0 +1,17 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2016 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_DECL_HPP
+#define MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_DECL_HPP
+
+#include "msgpack/v1/adaptor/boost/msgpack_variant_decl.hpp"
+#include "msgpack/v2/adaptor/boost/msgpack_variant_decl.hpp"
+#include "msgpack/v3/adaptor/boost/msgpack_variant_decl.hpp"
+
+#endif // MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_DECL_HPP

include/msgpack/adaptor/boost/optional.hpp

@@ -0,0 +1,15 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2016 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_TYPE_BOOST_OPTIONAL_HPP
+#define MSGPACK_TYPE_BOOST_OPTIONAL_HPP
+
+#include "msgpack/v1/adaptor/boost/optional.hpp"
+
+#endif // MSGPACK_TYPE_BOOST_OPTIONAL_HPP

include/msgpack/adaptor/boost/string_ref.hpp

@@ -0,0 +1,15 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2016 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_TYPE_BOOST_STRING_REF_HPP
+#define MSGPACK_TYPE_BOOST_STRING_REF_HPP
+
+#include "msgpack/v1/adaptor/boost/string_ref.hpp"
+
+#endif // MSGPACK_TYPE_BOOST_STRING_REF_HPP