Fixed brace

Updated the version to 7.0.0.

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,19 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-msgpack-c or msgpack-cxx version.
-e.g) msgpack-cxx 5.0.0 
-
-**To Reproduce**
-Please prepare https://stackoverflow.com/help/minimal-reproducible-example
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.

.github/depends/boost.sh

@@ -0,0 +1,72 @@
+#!/bin/bash
+
+usage()
+{
+  cat <<EOL
+  -b   - 32-bit or 64-bit library, maybe 32, 64 or both
+  -t   - the toolset, maybe gcc, clang or both
+  -p   - installation prefix
+EOL
+}
+
+build_boost()
+{
+  ./b2 \
+      --toolset=$1 \
+      --prefix=$3/$2 \
+      --with-test \
+      --with-headers \
+      --with-chrono \
+      --with-context \
+      --with-filesystem \
+      --with-system \
+      --with-timer \
+      address-model=$2 \
+      install || exit 1
+}
+
+bit="64"
+toolset="gcc"
+prefix="$HOME/boost-prefix"
+
+while getopts "b:t:p:" c; do
+  case "$c" in
+    b)
+      bit="$OPTARG"
+      [ "$bit" != "32" ] && [ "$bit" != "64" ] && [ "$bit" != "both" ] && usage && exit 1
+      ;;
+    t)
+      toolset="$OPTARG"
+      [ "$toolset" != "gcc" ] && [ "$toolset" != "clang" ] && [ "$toolset" != "both" ] && usage && exit 1
+      ;;
+    p)
+      prefix="$OPTARG"
+      ;;
+    ?*)
+      echo "invalid arguments." && exit 1
+      ;;
+  esac
+done
+
+mkdir $prefix || exit 1
+wget https://boostorg.jfrog.io/artifactory/main/release/1.85.0/source/boost_1_85_0.tar.bz2 || exit 1
+tar xf boost_1_85_0.tar.bz2 || exit 1
+cd boost_1_85_0
+./bootstrap.sh || exit 1
+
+build()
+{
+  if [ "$bit" = "both" ]; then
+    build_boost $1 32 $prefix
+    build_boost $1 64 $prefix
+  else
+    build_boost $1 $bit $prefix
+  fi
+}
+
+if [ "$toolset" = "both" ]; then
+  build gcc
+  build clang
+else
+  build $toolset
+fi

.github/depends/zlib.sh

@@ -0,0 +1,51 @@
+#!/bin/bash
+
+usage()
+{
+  cat <<EOL
+  -b   - 32-bit or 64-bit library, maybe 32 or 64
+  -p   - installation prefix
+EOL
+}
+
+bit="64"
+prefix="$HOME/zlib-prefix"
+
+while getopts "b:t:p:" c; do
+  case "$c" in
+    b)
+      bit="$OPTARG"
+      [ "$bit" != "32" ] && [ "$bit" != "64" ] && [ "$bit" != "both" ] && usage && exit 1
+      ;;
+    p)
+      prefix="$OPTARG"
+      ;;
+    ?*)
+      echo "invalid arguments." && exit 1
+      ;;
+  esac
+done
+
+mkdir $prefix || exit 1
+wget https://zlib.net/zlib-1.3.1.tar.gz || exit 1
+tar -xf zlib-1.3.1.tar.gz || exit 1
+cd zlib-1.3.1
+
+build()
+{
+  cmake \
+    -D CMAKE_BUILD_TYPE=Release \
+    -D CMAKE_INSTALL_PREFIX=$2/$1 \
+    -D CMAKE_C_FLAGS="-m$1" \
+    -D CMAKE_SHARED_LINKER_FLAGS="-m$1" \
+    -B build$1 \
+    -S .
+  cmake --build build$1 --target install
+}
+
+if [ "$bit" = "both" ]; then
+  build 32 $prefix
+  build 64 $prefix
+else
+  build $bit $prefix
+fi

.github/workflows/coverage.yml

@@ -0,0 +1,74 @@
+name: coverage
+
+on:
+  pull_request:
+    types: [opened, synchronize]
+  push:
+    branches:
+    - cpp_master
+    tags:
+    - '*'
+
+jobs:
+  codecov:
+    timeout-minutes: 30
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v1
+    - name: Install build dependencies
+      run: |
+        sudo apt-get update
+        sudo apt-get install g++-10 cmake lcov -y
+        ./ci/set_gcc_10.sh
+
+    - name: Cache boost
+      id: cache-boost
+      uses: actions/cache@v1
+      with:
+        path: ~/boost-prefix/
+        key: ${{ runner.os }}-boost-1-85-0-2024-05-27
+
+    - name: Build boost
+      if: steps.cache-boost.outputs.cache-hit != 'true'
+      run: ./.github/depends/boost.sh -b 64 -t gcc -p $HOME/boost-prefix
+
+    - name: Cache zlib
+      id: cache-zlib
+      uses: actions/cache@v1
+      with:
+        path: ~/zlib-prefix/
+        key: ${{ runner.os }}-zlib-64-1-2-11-2021-08-09
+
+    - name: Build zlib
+      if: steps.cache-zlib.outputs.cache-hit != 'true'
+      run: ./.github/depends/zlib.sh -b 64 -p $HOME/zlib-prefix
+
+    - name: Compile tests
+      run: |
+        mkdir build
+        cmake \
+            -D MSGPACK_CXX20=ON \
+            -D MSGPACK_32BIT=OFF \
+            -D MSGPACK_CHAR_SIGN=signed \
+            -D MSGPACK_USE_X3_PARSE=ON \
+            -D MSGPACK_BUILD_EXAMPLES=ON \
+            -D MSGPACK_BUILD_TESTS=ON \
+            -D CMAKE_BUILD_TYPE=Debug \
+            -D MSGPACK_GEN_COVERAGE=ON \
+            -D MSGPACK_USE_STD_VARIANT_ADAPTOR=ON \
+            -D CMAKE_PREFIX_PATH="$HOME/zlib-prefix/64;$HOME/boost-prefix/64" \
+            -B build \
+            -S . || exit 1
+        cmake --build build --target all || exit 1
+        ctest --test-dir build || exit 1
+
+    - name: Upload coverage to Codecov
+      working-directory: build
+      run: |
+        # Create lcov report
+        lcov --capture --directory . --output-file coverage.info
+        lcov --remove coverage.info '/usr/*' --output-file coverage.info # filter system-files
+        lcov --list coverage.info # debug info
+        # Uploading report to CodeCov
+        bash <(curl -s https://codecov.io/bash) -f coverage.info || echo "Codecov did not collect coverage reports"

.github/workflows/gha.yml

@@ -0,0 +1,244 @@
+name: CI
+
+on:
+  pull_request:
+    types: [opened, synchronize]
+  push:
+    branches:
+    - cpp_master
+    tags:
+    - '*'
+
+jobs:
+  macos:
+    name: ${{ format('macOS (pattern {0})', matrix.pattern) }}
+    runs-on: macos-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        pattern: [0, 1, 2, 3, 4]
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v3
+    - name: Install Dependencies
+      run: |
+        brew update
+        brew install --force llvm
+
+    - name: Cache boost
+      id: cache-boost
+      uses: actions/cache@v3
+      with:
+        path: ~/boost-prefix/
+        key: ${{ runner.os }}-boost-1-85-0-2024-05-27
+
+    - name: Build boost
+      if: steps.cache-boost.outputs.cache-hit != 'true'
+      run: ./.github/depends/boost.sh -b 64 -t clang -p $HOME/boost-prefix
+
+    - name: Cache zlib
+      id: cache-zlib
+      uses: actions/cache@v3
+      with:
+        path: ~/zlib-prefix/
+        key: ${{ runner.os }}-zlib-1-2-13-2022-11-02
+
+    - name: Build zlib
+      if: steps.cache-zlib.outputs.cache-hit != 'true'
+      run: ./.github/depends/zlib.sh -b 64 -p $HOME/zlib-prefix
+
+    - name: Build and test
+      shell: bash
+      run: |
+        # default configuration - overwrite its params later depending on matrix.pattern
+        export MSGPACK_CXX_VERSION="MSGPACK_CXX20=ON"
+        export ARCH=64
+        export API_VERSION=3
+        export CHAR_SIGN="signed"
+        export X3_PARSE="OFF"
+        export SANITIZE="-fsanitize=undefined -fno-sanitize-recover=all"
+
+        case ${{ matrix.pattern }} in
+          0)
+            export MSGPACK_CXX_VERSION="MSGPACK_CXX11=ON"
+            ;;
+          1)
+            export API_VERSION=1
+            ;;
+          2)
+            export API_VERSION=2
+            ;;
+          3)
+            export X3_PARSE="ON"
+            ;;
+          4)
+            export CHAR_SIGN="unsigned"
+            ;;
+        esac
+
+        # build and test
+        export CXX="clang++"
+        CMAKE_CXX_COMPILER="$CXX" CXXFLAGS="-Werror -g ${SANITIZE}" ci/build_cmake.sh || exit 1
+
+        cat Files.cmake| grep ".*\.[h|hpp]" | perl -pe 's/ //g' | sort > tmp1  && find include -name "*.h" -o -name "*.hpp" | sort > tmp2 && diff tmp1 tmp2
+
+  linux:
+    name: ${{ format('Linux (pattern {0})', matrix.pattern) }}
+    runs-on: ubuntu-20.04
+    strategy:
+      fail-fast: false
+      matrix:
+        pattern: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Install build dependencies
+      shell: bash
+      run: |
+        sudo apt-get update
+        sudo apt-get install g++-10 cmake valgrind -y
+        sudo apt-get install g++-10-multilib -y  # for 32-bit compile
+        ./ci/set_gcc_10.sh
+
+    - name: Cache boost
+      id: cache-boost
+      uses: actions/cache@v3
+      with:
+        path: ~/boost-prefix/
+        key: ${{ runner.os }}-boost-1-85-0-2024-05-27
+
+    - name: Build boost
+      if: steps.cache-boost.outputs.cache-hit != 'true'
+      run: ./.github/depends/boost.sh -b both -t gcc -p $HOME/boost-prefix
+
+    - name: Cache zlib
+      id: cache-zlib
+      uses: actions/cache@v3
+      with:
+        path: ~/zlib-prefix/
+        key: ${{ runner.os }}-zlib-1-2-13-2022-11-02
+
+    - name: Build zlib
+      if: steps.cache-zlib.outputs.cache-hit != 'true'
+      run: ./.github/depends/zlib.sh -b both -p $HOME/zlib-prefix
+
+    - name: Build and test
+      shell: bash
+      run: |
+        # default configuration - overwrite its params later depending on matrix.pattern
+        export MSGPACK_CXX_VERSION="MSGPACK_CXX20=ON"
+        export ARCH=64
+        export API_VERSION=3
+        export CHAR_SIGN="signed"
+        export X3_PARSE="OFF"
+        export SANITIZE="-fsanitize=undefined -fno-sanitize-recover=all"
+        export ACTION="ci/build_cmake.sh"
+
+        case ${{ matrix.pattern }} in
+          0)
+            export CXX="clang++-10"
+            export MSGPACK_CXX_VERSION="MSGPACK_CXX11=ON"
+            ;;
+          1)
+            export CXX="g++-10"
+            export MSGPACK_CXX_VERSION="MSGPACK_CXX11=ON"
+            ;;
+          2)
+            export CXX="clang++-10"
+            export MSGPACK_CXX_VERSION="MSGPACK_CXX14=ON"
+            ;;
+          3)
+            export CXX="g++-10"
+            export MSGPACK_CXX_VERSION="MSGPACK_CXX17=ON"
+            export MSGPACK_USE_STD_VARIANT_ADAPTOR="MSGPACK_USE_STD_VARIANT_ADAPTOR=ON"
+            ;;
+          4)
+            export CXX="clang++-10"
+            export MSGPACK_CXX_VERSION="MSGPACK_CXX20=ON"
+            export NO_BOOST="-DMSGPACK_NO_BOOST"
+            ;;
+          5)
+            export CXX="g++-10"
+            export ARCH=32
+            ;;
+          6)
+            export CXX="clang++-10"
+            export API_VERSION=2
+            ;;
+          7)
+            export CXX="g++-10"
+            export API_VERSION=1
+            ;;
+          8)
+            export CXX="clang++-10"
+            export CHAR_SIGN="unsigned"
+            ;;
+          9)
+            export CXX="g++-10"
+            export X3_PARSE="ON"
+            ;;
+          10)
+            export CXX="clang++-10"
+            export ACTION="ci/build_regression.sh"
+            ;;
+          11)
+            export CXX="g++-10"
+            export ARCH=32
+            export CHAR_SIGN="unsigned"
+            export X3_PARSE="ON"
+            ;;
+        esac
+
+        # build and test
+        CMAKE_CXX_COMPILER="$CXX" CXXFLAGS="-Werror -g ${SANITIZE} ${NO_BOOST}" ci/build_cmake.sh || exit 1
+        cat Files.cmake| grep ".*\.[h|hpp]" | perl -pe 's/ //g' | sort > tmp1  && find include -name "*.h" -o -name "*.hpp" | sort > tmp2 && diff tmp1 tmp2
+
+  windows:
+    name: ${{ format('Windows cxx{0}', matrix.cxx) }}
+    runs-on: windows-2019
+    strategy:
+      fail-fast: false
+      matrix:
+        # MSVC2019 only supports /std:c++14, /std:c++17 and /std:c++latest
+        cxx: [14, 17, 20]
+        pp_flag: ["/Zc:preprocessor-", "/Zc:preprocessor"]
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Cache vcpkg dependencies
+      id: cache-vcpkg
+      uses: actions/cache@v3
+      with:
+        path: C:/vcpkg/installed/x64-windows
+        key: ${{ runner.os }}-vcpkg-2021-08-09
+
+    - name: Install vcpkg dependencies
+      if: steps.cache-vcpkg.outputs.cache-hit != 'true'
+      shell: powershell
+      run: |
+        vcpkg update
+        vcpkg install zlib:x64-windows
+        vcpkg install boost-assert:x64-windows boost-numeric-conversion:x64-windows boost-variant:x64-windows boost-utility:x64-windows boost-fusion:x64-windows boost-optional:x64-windows boost-predef:x64-windows boost-preprocessor:x64-windows boost-timer:x64-windows boost-test:x64-windows
+
+    - name: Build and test
+      shell: powershell
+      run: |
+        $CPPVER="MSGPACK_CXX${{ matrix.cxx }}=ON"
+
+        md build
+        cmake `
+            -A x64 `
+            -G "Visual Studio 16 2019" `
+            -D CMAKE_TOOLCHAIN_FILE="C:/vcpkg/scripts/buildsystems/vcpkg.cmake" `
+            -D MSGPACK_BUILD_TESTS=ON `
+            -D $CPPVER `
+            -D CMAKE_CXX_FLAGS="${{ matrix.pp_flag }} /D_VARIADIC_MAX=10 /EHsc /D_SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING /D_SILENCE_CXX17_ALLOCATOR_VOID_DEPRECATION_WARNING /D_SILENCE_CXX17_OLD_ALLOCATOR_MEMBERS_DEPRECATION_WARNING /W3 /WX" `
+            -B build `
+            -S .
+        if ($LastExitCode -ne 0) { exit $LastExitCode }
+
+        cmake --build build --config Release
+        if ($LastExitCode -ne 0) { exit $LastExitCode }
+
+        ctest -VV --test-dir build -C Release
+        if ($LastExitCode -ne 0) { exit $LastExitCode }

.gitignore

@@ -0,0 +1,56 @@
+# Files generated by the bootstrap script.
+/INSTALL
+/AUTHORS
+/ChangeLog
+/NEWS
+/README
+/ac/
+/aclocal.m4
+/autom4te.cache/
+/config.h.in
+/configure
+/msgpack_vc2008.sln
+/msgpack_vc2008.vcproj
+Makefile.in
+
+# Files generated by the configure script.
+
+/config.h
+/config.log
+/config.status
+/libtool
+/msgpack.pc
+/src/msgpack/version.h
+/src/msgpack/version.hpp
+/stamp-h1
+Makefile
+.deps
+.libs
+
+# Files generated by make.
+*.o
+*.so
+*.lo
+*.la
+
+# Files generated by make check.
+# TODO: Replace these with something like /test/*_test
+/test/buffer
+/test/cases
+/test/convert
+/test/fixint
+/test/fixint_c
+/test/msgpack_test
+/test/msgpackc_test
+/test/object
+/test/pack_unpack
+/test/pack_unpack_c
+/test/streaming
+/test/streaming_c
+/test/version
+/test/zone
+
+build
+*-build
+.cache
+compile_commands.json

CHANGELOG.md

@@ -1,3 +1,84 @@
+# 2024-11-02 version 7.0.0
+  * Refine build system (#1133)
+  * Refine CI (#1122)
+  * Refine documents (#1117)
+## << breaking changes >>
+  * Revert double and fload packing behavior (#1144)
+    * If below decimal point is zero (e.g. 2.00),
+      * Before: pack as int format family    `0x02`
+      * After : pack as float format family  `0xcb 0x40 0x00 0x00 0x00 0x00 0x00 0x00 0x00`
+
+# 2024-04-02 version 6.1.1
+  * Fix compilation error when std::variant has the same types (#1112)
+  * Improve CI (#1090, #1110)
+  * Fix to avoid common function name's (has_as::check) ambiguity/conflict with other libraries' macros  (#1085)
+
+# 2023-07-08 version 6.1.0
+  * Remove dependency on boost in chrono.hpp (#1076)
+  * Add support for std::variant behavior (#1075)
+  * Fix msgpack::type::variant behavior to respect MessagePack format (#1071)
+  * Add rebind allocators (#1065)
+
+# 2023-03-02 version 6.0.0
+## << breaking changes >>
+  * Change CMake package name of C++ library to msgpack-cxx (#1054)
+    Unified all C++ package, library, cmake, tarball name become msgpack-cxx.
+
+# 2023-01-10 version 5.0.0 for C++
+ * Fix config for new MSVC preprocessor (#1040)
+## << breaking changes >>
+ * Change CMake package name of C++ library to msgpackc-cxx (#1045, #1048)
+
+# 2022-11-02 version 4.1.3 for C++
+  * Fix compile error that direct inclusion of chrono with `MSGPACK_NO_BOOST` (#1038))
+
+# 2022-09-07 version 4.1.2 for C++
+  * Fix noexcept on zone (#1030)
+  * Improve cmake support (#1028, #1032)
+  * Improve CI (#1023)
+  * Improve supporting platform (#1021)
+  * Refine double/float packing (#1018)
+  * Refine include files dependency (#1011)
+
+# 2022-03-09 version 4.1.1 for C++
+  * Remove chrono support on `MSGPACK_NO_BOOST` to fix  compile error.
+  * Improve build system (#1003)
+
+# 2022-02-12 version 4.1.0 for C++
+  * Add experimental support for no boost dependency (#1001)
+    * For cmake, add `-DMSGPACK_USE_BOOST=OFF`. For C++ compiler add `-DMSGPACK_NO_BOOST`.
+  * Improve BIN console output (#995)
+  * Fix include notation (#991)
+
+# 2021-10-23 version 4.0.3 for C++
+  * Remove Enabler2 template parameter from object adaptor (#987)
+  * Add MSGPACK_BUILD_DOCS cmake option (#983, #984)
+
+# 2021-08-31 version 4.0.2 for C++
+  * Fix fuzzer interface function name (#972)
+  * Fix boost test link error and support both dynamin(default) and static link boost (#971)
+
+# 2021-08-30 version 4.0.1 for C++
+  * Fix release tarball and its generation script (#967)
+
+# 2021-08-29 version 4.0.0 for C++
+  * Improve zone alignment logic (#965)
+  * Fix v1 unpack logic for STR and BIN (#957, #951)
+  * Fix UB on memcmp with size 0 (#954)
+  * Fix `iovec` name conflict (#952)
+  * Add `std::array<std::byte>` `std::span<char>` `std::span<unsigned char>` `std::span<std::byte>` adaptors (#951)
+  * Improve documents (#918, #919, #951)
+  * Improve tests (#916)
+  * Introduce BOOST_ASSERT (#898)
+  * Improve build system (#897, #905, #924, #951)
+  * Improve Boost.Fusion support (#894)
+  * Check nullptr before call memcpy (#891)
+  * Refine and bugfix `std::chrono::time_point` adaptor (#888, #893)
+  * Improve CI (#884, #892, #895, #951, #955)
+## << breaking changes >>
+  * Separate C++ part of the msgpack-c  from C/C++ mixed msgpack-c (#876, #878)
+  * Require boost libraries. See README.md Dependency(#912)
+
 # 2020-06-05 version 3.3.0
   * Add json example for C (#870)
   * Add both header and body packing functions for C (#870)

CMakeLists.txt

@@ -0,0 +1,268 @@
+if(${CMAKE_VERSION} VERSION_GREATER "3.4")
+    CMAKE_MINIMUM_REQUIRED (VERSION 3.5)
+else()
+    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 ()
+endif()
+
+PROJECT (msgpack-cxx LANGUAGES CXX)
+
+ADD_LIBRARY (msgpack-cxx INTERFACE)
+
+FILE (READ ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/version_master.hpp 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})
+
+LIST (APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake/")
+SET (GNUCXX_STD_SUPPORT_VERSION "4.3")
+
+OPTION (MSGPACK_CXX11 "Using c++11 compiler" ON)
+OPTION (MSGPACK_CXX14 "Using c++14 compiler" OFF)
+OPTION (MSGPACK_CXX17 "Using c++17 compiler" OFF)
+OPTION (MSGPACK_CXX20 "Using c++20 compiler" OFF)
+
+OPTION (MSGPACK_32BIT                   "32bit compile"                        OFF)
+OPTION (MSGPACK_USE_BOOST               "Use Boost libraried"                  ON)
+OPTION (MSGPACK_USE_X3_PARSE            "Use Boost X3 parse"                   OFF)
+OPTION (MSGPACK_BUILD_TESTS             "Build tests"                          OFF)
+OPTION (MSGPACK_BUILD_DOCS              "Build Doxygen documentation"          ON)
+OPTION (MSGPACK_FUZZ_REGRESSION         "Enable regression testing"            OFF)
+OPTION (MSGPACK_BUILD_EXAMPLES          "Build msgpack examples"               OFF)
+OPTION (MSGPACK_GEN_COVERAGE            "Generate coverage report"             OFF)
+OPTION (MSGPACK_USE_STATIC_BOOST        "Statically link with boost libraries" OFF)
+OPTION (MSGPACK_CHAR_SIGN               "Char sign to use (signed or unsigned)")
+OPTION (MSGPACK_USE_STD_VARIANT_ADAPTOR "Enable the adaptor for std::variant"  OFF)
+
+SET (CMAKE_CXX_STANDARD_REQUIRED ON)
+
+IF (MSGPACK_USE_X3_PARSE)
+    IF (NOT (MSGPACK_CXX14 OR MSGPACK_CXX17 OR MSGPACK_CXX20))
+        MESSAGE (FATAL_ERROR "MSGPACK_USE_X3_PARSE requires MSGPACK_CXX14 or newer")
+    ENDIF ()
+    SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_X3_PARSE ${CMAKE_CXX_FLAGS}")
+ENDIF ()
+
+IF (MSGPACK_CXX20)
+    SET (CMAKE_CXX_STANDARD 20)
+ELSEIF (MSGPACK_CXX17)
+    SET (CMAKE_CXX_STANDARD 17)
+ELSEIF (MSGPACK_CXX14)
+    SET (CMAKE_CXX_STANDARD 14)
+ELSEIF (MSGPACK_CXX11)
+    SET (CMAKE_CXX_STANDARD 11)
+ELSE ()
+    SET (CMAKE_CXX_STANDARD 98)
+ENDIF ()
+
+IF (MSGPACK_32BIT)
+    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+        TARGET_COMPILE_OPTIONS(msgpack-cxx INTERFACE -m32)
+        TARGET_LINK_OPTIONS(msgpack-cxx INTERFACE -m32)
+    ELSEIF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
+        TARGET_COMPILE_OPTIONS(msgpack-cxx INTERFACE -m32)
+        TARGET_LINK_OPTIONS(msgpack-cxx INTERFACE -m32)
+    ENDIF ()
+ENDIF ()
+
+IF (MSGPACK_USE_BOOST)
+    IF ((CMAKE_VERSION VERSION_GREATER 3.30) OR
+        (CMAKE_VERSION VERSION_EQUAL 3.30))
+        CMAKE_POLICY(SET CMP0167 NEW)
+    ENDIF ()
+    SET (Boost_USE_MULTITHREADED ON)
+
+    IF (MSGPACK_USE_STATIC_BOOST)
+        MESSAGE (STATUS "Staticly linking with Boost")
+        SET (Boost_USE_STATIC_LIBS TRUE)
+    ELSE ()
+        MESSAGE (STATUS "Dynamically linking with Boost")
+        SET (Boost_USE_STATIC_LIBS FALSE)
+    ENDIF ()
+
+    FIND_PACKAGE (Boost REQUIRED)
+ELSE ()
+    TARGET_COMPILE_DEFINITIONS(msgpack-cxx INTERFACE MSGPACK_NO_BOOST)
+ENDIF ()
+
+IF (MSGPACK_CHAR_SIGN)
+    TARGET_COMPILE_OPTIONS(msgpack-cxx INTERFACE -f${MSGPACK_CHAR_SIGN}-char)
+ENDIF ()
+
+IF (MSGPACK_DEFAULT_API_VERSION)
+    TARGET_COMPILE_DEFINITIONS(msgpack-cxx INTERFACE MSGPACK_DEFAULT_API_VERSION=${MSGPACK_DEFAULT_API_VERSION})
+ELSE ()
+    SET (MSGPACK_DEFAULT_API_VERSION 3)
+    TARGET_COMPILE_DEFINITIONS(msgpack-cxx INTERFACE MSGPACK_DEFAULT_API_VERSION=3)
+ENDIF ()
+
+IF (MSGPACK_USE_STD_VARIANT_ADAPTOR)
+    TARGET_COMPILE_DEFINITIONS(msgpack-cxx INTERFACE MSGPACK_USE_STD_VARIANT_ADAPTOR)
+ENDIF ()
+
+IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+    IF (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.1)
+        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)
+    ENDIF ()
+ENDIF ()
+
+
+INCLUDE (Files.cmake)
+
+TARGET_INCLUDE_DIRECTORIES (msgpack-cxx
+    INTERFACE
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+)
+
+IF (MSGPACK_USE_BOOST)
+    TARGET_LINK_LIBRARIES (msgpack-cxx INTERFACE Boost::boost)
+ENDIF ()
+
+IF (MSGPACK_GEN_COVERAGE)
+    IF (NOT MSGPACK_BUILD_TESTS)
+        MESSAGE(FATAL_ERROR "Coverage requires -DMSGPACK_BUILD_TESTS=ON")
+    ENDIF ()
+    STRING (TOUPPER "${CMAKE_BUILD_TYPE}" UPPER_CMAKE_BUILD_TYPE)
+    IF (NOT "${UPPER_CMAKE_BUILD_TYPE}" STREQUAL "DEBUG")
+        MESSAGE (FATAL_ERROR "Coverage requires -DCMAKE_BUILD_TYPE=Debug")
+    ENDIF ()
+
+    INCLUDE (CodeCoverage)
+    SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COVERAGE_FLAGS}")
+    SETUP_TARGET_FOR_COVERAGE(coverage make coverage test)
+ENDIF ()
+
+IF (MSGPACK_BUILD_TESTS)
+    IF (${CMAKE_CXX_STANDARD} EQUAL 98)
+        MESSAGE (FATAL_ERROR "Tests requires C++11 or newer")
+    ENDIF ()
+    IF ((CMAKE_VERSION VERSION_GREATER 3.27) OR
+        (CMAKE_VERSION VERSION_EQUAL 3.27))
+        CMAKE_POLICY(SET CMP0145 OLD)
+    ENDIF ()
+    IF (NOT MSGPACK_USE_BOOST)
+        MESSAGE(FATAL_ERROR "Test requires -DMSGPACK_USE_BOOST=ON")
+    ENDIF ()
+    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 ()
+
+# enable regression testing
+IF (MSGPACK_FUZZ_REGRESSION)
+    ENABLE_TESTING ()
+    ADD_SUBDIRECTORY (fuzz)
+ENDIF ()
+
+IF ("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "sparc")
+    TARGET_COMPILE_DEFINITIONS(msgpack-cxx INTERFACE MSGPACK_ZONE_ALIGN=8)
+ENDIF ()
+
+IF (MSGPACK_BUILD_EXAMPLES)
+    ADD_SUBDIRECTORY (example)
+ENDIF ()
+
+# Doxygen
+IF (MSGPACK_BUILD_DOCS)
+    FIND_PACKAGE (Doxygen)
+    IF (DOXYGEN_FOUND)
+        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
+            ${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
+        )
+    ENDIF ()
+ENDIF ()
+
+include (GNUInstallDirs)
+
+# Install library.
+INSTALL (TARGETS msgpack-cxx
+         EXPORT msgpack-cxx-targets
+         COMPONENT msgpack-cxx
+         # This provides include directory in exported target
+         # relative to prefix in single directory we've put everything in.
+         INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+)
+
+# Install headers from source tree.
+INSTALL (DIRECTORY include/
+         DESTINATION include
+         COMPONENT msgpack-cxx
+)
+
+INCLUDE (CMakePackageConfigHelpers)
+
+IF (NOT (CMAKE_VERSION VERSION_LESS 3.14))
+    SET (extra_version_file_args ARCH_INDEPENDENT)
+ENDIF ()
+SET (cmake_config_path "${CMAKE_INSTALL_LIBDIR}/cmake/msgpack-cxx")
+
+# Configure the main package file from source tree.
+CONFIGURE_PACKAGE_CONFIG_FILE (
+    msgpack-cxx-config.cmake.in
+    "${CMAKE_CURRENT_BINARY_DIR}/msgpack-cxx-config.cmake"
+    INSTALL_DESTINATION "${cmake_config_path}"
+)
+
+# Write package version file.
+WRITE_BASIC_PACKAGE_VERSION_FILE (
+    msgpack-cxx-config-version.cmake
+    VERSION ${VERSION}
+    COMPATIBILITY SameMajorVersion
+    ${extra_version_file_args}
+)
+
+# Install the generated package version file and the main package file.
+INSTALL (FILES
+    "${CMAKE_CURRENT_BINARY_DIR}/msgpack-cxx-config.cmake"
+    "${CMAKE_CURRENT_BINARY_DIR}/msgpack-cxx-config-version.cmake"
+    DESTINATION "${cmake_config_path}"
+    COMPONENT msgpack-cxx
+)
+
+# This installs package in install tree for using installed targets.
+INSTALL (
+    EXPORT msgpack-cxx-targets
+    FILE msgpack-cxx-targets.cmake
+    DESTINATION "${cmake_config_path}"
+    COMPONENT msgpack-cxx
+)

Files.cmake

@@ -0,0 +1,734 @@
+SET (msgpack-cxx_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/complex.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/timespec.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/array_byte.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/variant.hpp
+    include/msgpack/adaptor/cpp17/vector_byte.hpp
+    include/msgpack/adaptor/cpp20/span.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/adaptor/wstring.hpp
+    include/msgpack/assert.hpp
+    include/msgpack/cpp_config.hpp
+    include/msgpack/cpp_config_decl.hpp
+    include/msgpack/cpp_version.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/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/ptx.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/nvcc.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/cuda.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/cloudabi.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/other/workaround.h
+    include/msgpack/predef/platform.h
+    include/msgpack/predef/platform/cloudabi.h
+    include/msgpack/predef/platform/ios.h
+    include/msgpack/predef/platform/mingw.h
+    include/msgpack/predef/platform/mingw32.h
+    include/msgpack/predef/platform/mingw64.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_server.h
+    include/msgpack/predef/platform/windows_store.h
+    include/msgpack/predef/platform/windows_system.h
+    include/msgpack/predef/platform/windows_uwp.h
+    include/msgpack/predef/version.h
+    include/msgpack/predef/version_number.h
+    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/detail/to_list_msvc.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/sysdep.hpp
+    include/msgpack/type.hpp
+    include/msgpack/unpack.hpp
+    include/msgpack/unpack_decl.hpp
+    include/msgpack/unpack_define.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/complex.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/timespec.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/array_byte.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/variant.hpp
+    include/msgpack/v1/adaptor/cpp17/vector_byte.hpp
+    include/msgpack/v1/adaptor/cpp20/span.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/adaptor/wstring.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/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/version_master.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
+)

QUICKSTART-CPP.md

@@ -0,0 +1,159 @@
+# Implementation Status
+
+The serialization library is production-ready.
+
+Currently, RPC implementation is in testing phase. Requires newer kernel, not running on RHEL5/CentOS5.
+
+# Install
+
+Same as QuickStart for C Language.
+
+# Serialization QuickStart for C+\+
+
+## First program
+
+Include `msgpack.hpp` header to use MessagePack on your program.
+
+```cpp
+#include <msgpack.hpp>
+#include <vector>
+#include <string>
+#include <iostream>
+
+int main(void) {
+        // serializes this object.
+        std::vector<std::string> vec;
+        vec.push_back("Hello");
+        vec.push_back("MessagePack");
+
+        // serialize it into simple buffer.
+        msgpack::sbuffer sbuf;
+        msgpack::pack(sbuf, vec);
+
+        // deserialize it.
+        msgpack::object_handle oh =
+            msgpack::unpack(sbuf.data(), sbuf.size());
+
+        // print the deserialized object.
+        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);
+}
+```
+
+Compile it as follows:
+
+```
+$ g++ -Ipath_to_msgpack/include hello.cc -o hello
+$ ./hello
+["Hello", "MessagePack"]
+```
+
+## Streaming feature
+
+```cpp
+#include <msgpack.hpp>
+#include <iostream>
+#include <string>
+
+int main() {
+        // serializes multiple objects using msgpack::packer.
+        msgpack::sbuffer buffer;
+
+        msgpack::packer<msgpack::sbuffer> pk(&buffer);
+        pk.pack(std::string("Log message ... 1"));
+        pk.pack(std::string("Log message ... 2"));
+        pk.pack(std::string("Log message ... 3"));
+
+        // deserializes these objects using msgpack::unpacker.
+        msgpack::unpacker pac;
+
+        // feeds the buffer.
+        pac.reserve_buffer(buffer.size());
+        memcpy(pac.buffer(), buffer.data(), buffer.size());
+        pac.buffer_consumed(buffer.size());
+
+        // now starts streaming deserialization.
+        msgpack::object_handle oh;
+        while(pac.next(oh)) {
+            std::cout << oh.get() << std::endl;
+        }
+
+        // results:
+        // $ g++ -Ipath_to_msgpack/include stream.cc -o stream
+        // $ ./stream
+        // "Log message ... 1"
+        // "Log message ... 2"
+        // "Log message ... 3"
+}
+```
+
+### Streaming into an array or map
+
+```cpp
+#include <msgpack.hpp>
+#include <iostream>
+#include <string>
+
+int main() {
+        // serializes multiple objects into one message containing an array using msgpack::packer.
+        msgpack::sbuffer buffer;
+
+        msgpack::packer<msgpack::sbuffer> pk(&buffer);
+        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"));
+
+        // serializes multiple objects into one message containing a map using msgpack::packer.
+        msgpack::sbuffer buffer2;
+
+        msgpack::packer<msgpack::sbuffer> pk2(&buffer2);
+        pk2.pack_map(2);
+        pk2.pack(std::string("x"));
+        pk2.pack(3);
+        pk2.pack(std::string("y"));
+        pk2.pack(3.4321);
+
+}
+```
+
+
+## User-defined classes
+
+You can use serialize/deserializes user-defined classes using `MSGPACK_DEFINE` macro.
+
+```cpp
+#include <msgpack.hpp>
+#include <vector>
+#include <string>
+
+class myclass {
+private:
+    std::string m_str;
+    std::vector<int> m_vec;
+public:
+    MSGPACK_DEFINE(m_str, m_vec);
+};
+
+int main() {
+        std::vector<myclass> vec;
+        // add some elements into vec...
+
+        // you can serialize myclass directly
+        msgpack::sbuffer sbuf;
+        msgpack::pack(sbuf, vec);
+
+        msgpack::object_handle oh =
+            msgpack::unpack(sbuf.data(), sbuf.size());
+
+        msgpack::object obj = oh.get();
+
+        // you can convert object to myclass directly
+        std::vector<myclass> rvec;
+        obj.convert(rvec);
+}
+```

README.md

@@ -1,6 +1,9 @@
-`msgpack` for C/C++
+`msgpack` for C++
 ===================
 
+Version 7.0.0 [![Build Status](https://github.com/msgpack/msgpack-c/workflows/CI/badge.svg?branch=cpp_master)](https://github.com/msgpack/msgpack-c/actions) [![Build status](https://ci.appveyor.com/api/projects/status/8kstcgt79qj123mw/branch/cpp_master?svg=true)](https://ci.appveyor.com/project/redboltz/msgpack-c/branch/cpp_master)
+[![codecov](https://codecov.io/gh/msgpack/msgpack-c/branch/cpp_master/graph/badge.svg)](https://codecov.io/gh/msgpack/msgpack-c/branch/cpp_master)
+
 It's like JSON but smaller and faster.
 
 Overview
@@ -12,15 +15,193 @@ 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.
 
-### C Library
+Example
+-------
 
-See [c_master](https://github.com/msgpack/msgpack-c/tree/c_master)
+```c++
+#include <msgpack.hpp>
+#include <string>
+#include <iostream>
+#include <sstream>
 
-### C++ Library
+int main()
+{
+    msgpack::type::tuple<int, bool, std::string> src(1, true, "example");
 
-See [cpp_master](https://github.com/msgpack/msgpack-c/tree/cpp_master)
+    // 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);
 
-### Documentation
+    // 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.
+
+Dependency
+----------
+
+msgpack-c requires [boost library](https://www.boost.org/).
+C++ version of msgpack-c itself is a header-only library and depends only on
+boost headers. Tests depend on boost unit test framework and are linked with
+it, so if you want to build them, you need to have this dependency installed.
+
+Experimental support for removing boost dependency
+
+For cmake:
+
+```
+cmake -DMSGPACK_USE_BOOST=OFF ..
+```
+
+NOTE: `-DMSGPACK_BUILD_TESTS=ON` doesn't work with `-DMSGPACK_USE_BOOST=OFF`.
+
+For C++ compiler
+
+```
+clang++ -DMSGPACK_NO_BOOST your_code.cpp
+```
+
+
+Usage
+-----
+
+- If you build your project with cmake, you can find msgpack-c with a
+  canonical cmake-way:
+
+  ```cmake
+  # ...
+  find_package(msgpack REQUIRED)
+  # ...
+  target_link_libraries(your_target_name <PRIVATE/PUBLIC/INTERFACE> msgpack-cxx)
+  # ...
+  ```
+
+  This will search for `msgpack` cmake package in a system prefix and in
+  prefixes from `CMAKE_PREFIX_PATH`. Note that msgpack-c depends on boost
+  headers, and `msgpack` cmake package depends on `Boost` cmake package. The
+  library is header-only and `target_link_libraries` command just adds path
+  to msgpack-c headers to your compiler's include path.
+
+  A usage example can be found at [test-install](test-install) directory.
+
+- If you do not use cmake, you can just add path yo msgpack-c and boost
+  headers to your include path:
+
+  ```bash
+  g++ -I msgpack-c/include -I path_to_boost your_source_file.cpp
+  ```
+
+Building and Installing
+-----------------------
+
+### Install from git repository
+
+#### Using the Terminal (CLI)
+
+You will need:
+
+- `gcc >= 4.1.0`
+- `cmake >= 3.1.0`
+
+C++03:
+
+```bash
+git clone https://github.com/msgpack/msgpack-c.git
+cd msgpack-c
+git checkout cpp_master
+cmake .
+sudo cmake --build . --target install
+```
+
+If you want to build tests with different C++ version, you can use
+`MSGPACK_CXX11`, `MSGPACK_CXX14`, `MSGPACK_CXX17`, `MSGPACK_CXX20` options.
+Just replace the line
+
+```bash
+cmake .
+```
+
+with a line like that:
+
+```bash
+cmake -DMSGPACK_CXX20=ON .
+```
+
+Note that these flags do not affect installation. They just switch test cases.
+All files are installed in every settings.
+
+If you don't have superuser permissions or don't want to install the library
+to a system-wide prefix, you can use `CMAKE_INSTALL_PREFIX` option like that:
+
+```bash
+cmake -DCMAKE_INSTALL_PREFIX=/your/custom/prefix .
+```
+
+Other useful options:
+
+- `MSGPACK_BUILD_TESTS` (default `OFF`): build tests
+- `MSGPACK_BUILD_EXAMPLES` (default `OFF`): build examples
+- `MSGPACK_32BIT` (default `OFF`): 32bit compile
+- `MSGPACK_USE_X3_PARSE` (default `OFF`): use Boost X3 parse
+  (note that it requires C++14 or newer)
+- `MSGPACK_CHAR_SIGN` (not set explicitly by default): char sign to use (signed or unsigned)
+- `MSGPACK_USE_STATIC_BOOST` (default `OFF`): statically link with boost libraries
+
+#### GUI on Windows
+
+Clone msgpack-c git repository with the command:
+
+```
+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. Checkout to `cpp_master` branch
+
+2. Launch [cmake GUI client](http://www.cmake.org/cmake/resources/software.html).
+
+3. Set 'Where is the source code:' text box and
+   'Where to build the binaries:' text box.
+
+4. Click 'Configure' button.
+
+5. Choose your Visual Studio version.
+
+6. Click 'Generate' button.
+
+7. Open the created msgpack.sln on Visual Studio.
+
+8. Build all.
+
+Documentation
+-------------
 
 You can get additional information including the tutorial on the
 [wiki](https://github.com/msgpack/msgpack-c/wiki).

appveyor.yml

@@ -0,0 +1,56 @@
+version: 7.0.0.{build}
+
+branches:
+  only:
+  - cpp_master
+
+environment:
+  matrix:
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      cpp11: -DMSGPACK_CXX11=ON
+      msvc: '"Visual Studio 14 2015"'
+      boost_prefix: C:\Libraries\boost_1_69_0
+      boost_subdir: lib32-msvc-14.0
+build_script:
+  - ps: |
+      appveyor DownloadFile http://zlib.net/zlib-1.3.1.tar.gz -FileName zlib-1.3.1.tar.gz
+      7z x zlib-1.3.1.tar.gz 2> $null
+      7z x zlib-1.3.1.tar 2> $null
+      cd zlib-1.3.1
+
+      md build
+      md prefix
+      cd build
+
+      cmake `
+          -G $env:msvc `
+          -D CMAKE_INSTALL_PREFIX="$env:APPVEYOR_BUILD_FOLDER\zlib-1.3.1\prefix" `
+          ..
+      if ($LastExitCode -ne 0) { exit $LastExitCode }
+
+      cmake --build . --target install --config Release
+      if ($LastExitCode -ne 0) { exit $LastExitCode }
+      cd ..\..
+
+      md build
+      md prefix
+      cd build
+
+      cmake `
+          -G $env:msvc `
+          $env:cpp11 `
+          -D MSGPACK_BUILD_EXAMPLES=ON `
+          -D MSGPACK_BUILD_TESTS=ON `
+          -D CMAKE_EXE_LINKER_FLAGS=/LIBPATH:"$env:boost_prefix\$env:boost_subdir" `
+          -D CMAKE_PREFIX_PATH="$env:boost_prefix;$env:APPVEYOR_BUILD_FOLDER\zlib-1.3.1\prefix" `
+          -D CMAKE_INSTALL_PREFIX="$env:APPVEYOR_BUILD_FOLDER\prefix" `
+          -D CMAKE_CXX_FLAGS="/D_VARIADIC_MAX=10 /EHsc /DBOOST_ALL_DYN_LINK" `
+          ..
+      if ($LastExitCode -ne 0) { exit $LastExitCode }
+
+      cmake --build . --config Release
+      if ($LastExitCode -ne 0) { exit $LastExitCode }
+
+test_script:
+- set PATH=%PATH%;%APPVEYOR_BUILD_FOLDER%\zlib-1.3.1\build\Release;%APPVEYOR_BUILD_FOLDER%\build\release;%boost_prefix%\%boost_subdir%
+- ctest -VV -C Release

ci/build_cmake.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+
+build_dir="$CXX-build"
+prefix_dir="`pwd`/$CXX-prefix"
+mkdir $build_dir  || exit 1
+mkdir $prefix_dir || exit 1
+
+if [ "${ARCH}" == "32" ]; then
+    export BIT32="ON"
+    export ARCH_FLAG="-m32"
+else
+    export BIT32="OFF"
+    export ARCH_FLAG="-m64"
+fi
+
+cmake \
+    -D CMAKE_PREFIX_PATH="${HOME}/boost-prefix/${ARCH};${HOME}/zlib-prefix/${ARCH}" \
+    -D MSGPACK_BUILD_TESTS=ON \
+    -D ${MSGPACK_CXX_VERSION} \
+    -D MSGPACK_32BIT=${BIT32} \
+    -D MSGPACK_CHAR_SIGN=${CHAR_SIGN} \
+    -D MSGPACK_DEFAULT_API_VERSION=${API_VERSION} \
+    -D MSGPACK_USE_X3_PARSE=${X3_PARSE} \
+    -D MSGPACK_USE_STD_VARIANT_ADAPTOR=${STD_VARIANT_ADAPTOR} \
+    -D CMAKE_CXX_FLAGS="${CXXFLAGS} ${ARCH_FLAG}" \
+    -D CMAKE_INSTALL_PREFIX=$prefix_dir \
+    -B $build_dir \
+    -S . || exit 1
+
+cmake --build $build_dir --target install || exit 1
+
+ctest -VV --test-dir $build_dir || exit 1
+
+if [ "${ARCH}" != "32" ] && [ `uname` = "Linux" ]; then
+    ctest -T memcheck --test-dir $build_dir | 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
+
+if [ "${ARCH}" != "32" ]; then
+    cd test-install || exit 1
+
+    mkdir $build_dir
+    cmake \
+        -D CMAKE_PREFIX_PATH="$prefix_dir;${HOME}/boost-prefix/${ARCH}" \
+        -B $build_dir \
+        -S . || exit 1
+    cmake --build $build_dir --target all || exit 1
+
+    $build_dir/test-install || exit 1
+fi

ci/build_regression.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+
+build_dir="$CXX-build"
+mkdir $build_dir || exit 1
+
+if [ "${ARCH}" == "32" ]
+then
+    echo "64 bit support required for regressions"
+    exit 1
+fi
+
+cmake \
+    -D CMAKE_PREFIX_PATH="${HOME}/boost-prefix/${ARCH};${HOME}/zlib-prefix/${ARCH}" \
+    -D MSGPACK_FUZZ_REGRESSION="ON" \
+    -D ${MSGPACK_CXX_VERSION} \
+    -D MSGPACK_CHAR_SIGN=${CHAR_SIGN} \
+    -D MSGPACK_DEFAULT_API_VERSION=${API_VERSION} \
+    -D MSGPACK_USE_X3_PARSE=${X3_PARSE} \
+    -D CMAKE_CXX_FLAGS="${CXXFLAGS}" \
+    -B $build_dir \
+    -S . || exit 1
+
+cmake --build $build_dir --target all || exit 1
+
+ctest -VV --test-dir $build_dir || exit 1

ci/set_gcc_10.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+version=10
+priority=100
+
+sudo update-alternatives --install /usr/bin/gcc         gcc         /usr/bin/gcc-${version}         ${priority}
+sudo update-alternatives --install /usr/bin/gcc-ar      gcc-ar      /usr/bin/gcc-ar-${version}      ${priority}
+sudo update-alternatives --install /usr/bin/gcc-nm      gcc-nm      /usr/bin/gcc-nm-${version}      ${priority}
+sudo update-alternatives --install /usr/bin/gcc-ranlib  gcc-ranlib  /usr/bin/gcc-ranlib-${version}  ${priority}
+sudo update-alternatives --install /usr/bin/gcov        gcov        /usr/bin/gcov-${version}        ${priority}
+sudo update-alternatives --install /usr/bin/gcov-dump   gcov-dump   /usr/bin/gcov-dump-${version}   ${priority}
+sudo update-alternatives --install /usr/bin/gcov-tool   gcov-tool   /usr/bin/gcov-tool-${version}   ${priority}
+sudo update-alternatives --install /usr/bin/lto-dump    lto-dump    /usr/bin/lto-dump-${version}    ${priority}
+sudo update-alternatives --install /usr/bin/g++         g++         /usr/bin/g++-${version}         ${priority}
+
+sudo update-alternatives --install /usr/bin/cc   cc   /usr/bin/gcc-${version} ${priority}
+sudo update-alternatives --install /usr/bin/c++  c++  /usr/bin/g++-${version} ${priority}

cmake/CodeCoverage.cmake

@@ -0,0 +1,55 @@
+# Check prereqs
+FIND_PROGRAM(GCOV_PATH gcov)
+FIND_PROGRAM(LCOV_PATH lcov)
+FIND_PROGRAM(GENHTML_PATH genhtml)
+
+IF(NOT GCOV_PATH)
+    MESSAGE(FATAL_ERROR "gcov not found! Aborting...")
+ENDIF()
+
+IF(NOT CMAKE_COMPILER_IS_GNUCC AND NOT CMAKE_COMPILER_IS_GNUCXX)
+    # Clang version 3.0.0 and greater now supports gcov as well.
+    MESSAGE(STATUS "Compiler is not GNU gcc! Clang Version 3.0.0 and greater supports gcov as well, but older versions don't.")
+    IF(NOT "${CMAKE_C_COMPILER_ID}" MATCHES "Clang" AND NOT "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
+        MESSAGE(FATAL_ERROR "Compiler is not GNU gcc! Aborting...")
+    ENDIF()
+ENDIF()
+
+SET(COVERAGE_FLAGS "-g -O0 --coverage")
+
+FUNCTION(SETUP_TARGET_FOR_COVERAGE _targetname _testrunner _outputname)
+
+    IF(NOT LCOV_PATH)
+        MESSAGE(FATAL_ERROR "lcov not found! Aborting...")
+    ENDIF()
+
+    IF(NOT GENHTML_PATH)
+        MESSAGE(FATAL_ERROR "genhtml not found! Aborting...")
+    ENDIF()
+
+    # Setup target
+    ADD_CUSTOM_TARGET(${_targetname}
+
+        # Cleanup lcov
+        ${LCOV_PATH} --directory . --zerocounters
+
+        # Run tests
+        COMMAND ${_testrunner} ${ARGV3}
+
+        # Capturing lcov counters and generating report
+        COMMAND ${LCOV_PATH} --directory . --capture --output-file ${_outputname}.info --base-directory ${CMAKE_SOURCE_DIR} --no-external --quiet
+        COMMAND ${LCOV_PATH} --remove ${_outputname}.info '*/test/*' '*/fuzz/*' --output-file ${_outputname}.info.cleaned --quiet
+        COMMAND ${GENHTML_PATH} -o ${_outputname} ${_outputname}.info.cleaned --prefix ${CMAKE_SOURCE_DIR}
+        # COMMAND ${CMAKE_COMMAND} -E remove ${_outputname}.info ${_outputname}.info.cleaned
+
+        WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+        COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report."
+    )
+
+    # Show info where to find the report
+    ADD_CUSTOM_COMMAND(TARGET ${_targetname} POST_BUILD
+        COMMAND ;
+        COMMENT "Open ./${_outputname}/index.html in your browser to view the coverage report."
+    )
+
+ENDFUNCTION()

codecov.yml

@@ -0,0 +1,36 @@
+codecov:
+  notify:
+    require_ci_to_pass: yes
+
+coverage:
+  precision: 2
+  round: down
+  range: "70...100"
+
+  status:
+    project: yes
+    patch: yes
+    changes: no
+
+parsers:
+  gcov:
+    branch_detection:
+      conditional: yes
+      loop: yes
+      method: no
+      macro: no
+
+comment:
+  layout: "header, diff"
+  behavior: default
+  require_changes: no
+
+ignore:
+  - "test"
+  - "fuzz"
+  - "erb"
+  - "ci"
+  - "cmake"
+  - "examle"
+  - "external"
+  - "usr"

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%><%}%>>
+tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_tuple(A0 const& a0<%1.upto(i) {|j|%>, A<%=j%> const& 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(A0 const& a0<%1.upto(i) {|j|%>, A<%=j%> const& 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,343 @@
+//
+// 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/versioning.hpp"
+#include "msgpack/cpp_config.hpp"
+#include "msgpack/zone_decl.hpp"
+#include "msgpack/assert.hpp"
+
+#include <stdint.h>
+#include <cstdlib>
+#include <memory>
+#include <vector>
+
+<% 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 = static_cast<size_t>(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);
+
+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):m_chunk_size(chunk_size), m_chunk_list(m_chunk_size)
+{
+}
+
+inline char* zone::get_aligned(char* ptr, size_t align)
+{
+    MSGPACK_ASSERT(align != 0 && (align & (align - 1)) == 0); // align must be 2^n (n >= 0)
+    return
+        reinterpret_cast<char*>(
+            reinterpret_cast<uintptr_t>(ptr + (align - 1)) & ~static_cast<uintptr_t>(align - 1)
+        );
+}
+
+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 + static_cast<size_t>(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 + static_cast<size_t>(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,9 @@
+ADD_SUBDIRECTORY (cpp03)
+ADD_SUBDIRECTORY (cpp11)
+
+IF (MSGPACK_USE_BOOST)
+    ADD_SUBDIRECTORY (boost)
+    IF (MSGPACK_USE_X3_PARSE)
+        ADD_SUBDIRECTORY (x3)
+    ENDIF ()
+ENDIF ()

example/boost/CMakeLists.txt

@@ -0,0 +1,45 @@
+FIND_PACKAGE (Boost REQUIRED)
+FIND_PACKAGE (Threads REQUIRED)
+FIND_PACKAGE (ZLIB REQUIRED)
+
+LIST (APPEND exec_PROGRAMS
+    msgpack_variant_capitalize.cpp
+    msgpack_variant_mapbased.cpp
+)
+
+IF (MSGPACK_CXX11 OR MSGPACK_CXX14 OR MSGPACK_CXX17 OR MSGPACK_CXX20)
+    LIST (APPEND exec_PROGRAMS asio_send_recv.cpp)
+    IF (ZLIB_FOUND)
+        LIST (APPEND exec_PROGRAMS asio_send_recv_zlib.cpp)
+    ENDIF ()
+ENDIF ()
+
+FOREACH (source_file ${exec_PROGRAMS})
+    GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
+    ADD_EXECUTABLE (
+        ${source_file_we}
+        ${source_file}
+    )
+    TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
+        msgpack-cxx
+        Threads::Threads
+    )
+    IF (ZLIB_FOUND)
+        TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE ZLIB::ZLIB)
+    ENDIF ()
+    IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "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}" MATCHES "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;
+                }
+                do_async_read_some = [&] {
+                    unp.reserve_buffer(window_size);
+                    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 = static_cast<uInt>(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 = static_cast<uInt>(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,97 @@
+// 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);
+
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), 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/cpp03/CMakeLists.txt

@@ -0,0 +1,113 @@
+FIND_PACKAGE (Threads REQUIRED)
+
+FIND_PACKAGE (Boost COMPONENTS timer)
+
+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_USE_BOOST)
+    IF (Boost_TIMER_LIBRARY)
+        LIST (APPEND with_boost_lib_PROGRAMS
+            speed_test.cpp
+            speed_test_nested_array.cpp
+        )
+    ENDIF ()
+ENDIF ()
+
+FOREACH (source_file ${exec_PROGRAMS})
+    GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
+    ADD_EXECUTABLE (
+        ${source_file_we}
+        ${source_file}
+    )
+    TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
+        msgpack-cxx
+    )
+    IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "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_LINK_LIBRARIES (${source_file_we} PRIVATE
+        msgpack-cxx
+        Threads::Threads
+    )
+    IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "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})
+    GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
+    ADD_EXECUTABLE (
+        ${source_file_we}
+        ${source_file}
+    )
+    TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
+        msgpack-cxx
+        Boost::timer
+    )
+    IF (NOT MSVC AND NOT APPLE)
+        TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
+            rt
+        )
+    ENDIF ()
+
+    IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "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}" MATCHES "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,104 @@
+// 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);
+
+        std::string const& str = ss.str();
+        print(str);
+
+        msgpack::object_handle oh =
+            msgpack::unpack(str.data(), 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,76 @@
+// 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());
+
+        std::string const& str = ss.str();
+        msgpack::object_handle oh =
+            msgpack::unpack(str.data(), 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,119 @@
+// 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);
+
+        std::string const& str = ss.str();
+        print(str);
+
+        msgpack::object_handle oh =
+            msgpack::unpack(str.data(), 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,112 @@
+// 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());
+
+        std::string const& str = ss.str();
+        msgpack::object_handle oh = msgpack::unpack(str.data(), 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,43 @@
+// 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.
+    std::string const& ps = ss.str();
+    msgpack::object obj = msgpack::unpack(z, ps.data(), ps.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, ps.data(), ps.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,38 @@
+IF (MSGPACK_CXX11 OR MSGPACK_CXX14 OR MSGPACK_CXX17)
+    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_LINK_LIBRARIES (${source_file_we} PRIVATE
+            msgpack-cxx
+        )
+        IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "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}" MATCHES "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,159 @@
+// 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);
+
+    auto const& str = ss.str();
+    auto oh = msgpack::unpack(str.data(), str.size());
+    auto 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 const& str = ss.str();
+    auto oh = msgpack::unpack(str.data(), 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 const& str = ss.str();
+    auto oh = msgpack::unpack(str.data(), 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 const& str = ss.str();
+    auto oh = msgpack::unpack(str.data(), 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 const& str = ss.str();
+    auto oh = msgpack::unpack(str.data(), 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 const& str = ss.str();
+        auto oh = msgpack::unpack(str.data(), 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 const& str = ss.str();
+        auto oh = msgpack::unpack(str.data(), 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 const& str = ss.str();
+        auto oh = msgpack::unpack(str.data(), 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 const& str = ss.str();
+        auto oh = msgpack::unpack(str.data(), 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 const& str = ss.str();
+        auto oh = msgpack::unpack(str.data(), 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/x3/CMakeLists.txt

@@ -0,0 +1,63 @@
+IF (MSGPACK_USE_X3_PARSE AND MSGPACK_DEFAULT_API_VERSION VERSION_GREATER 1)
+    FIND_PACKAGE (Boost REQUIRED COMPONENTS context)
+    FIND_PACKAGE (Threads REQUIRED)
+
+    LIST (APPEND exec_PROGRAMS
+        unpack.cpp
+        parse.cpp
+    )
+    LIST (APPEND with_boost_PROGRAMS
+        stream_unpack.cpp
+    )
+    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} PRIVATE msgpack-cxx)
+
+        IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "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}" MATCHES "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_LINK_LIBRARIES (${source_file_we} PRIVATE
+            msgpack-cxx
+            Boost::context
+            Threads::Threads
+        )
+        IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "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}" MATCHES "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,37 @@
+FIND_PACKAGE (Threads REQUIRED)
+FIND_PACKAGE (Boost REQUIRED COMPONENTS filesystem unit_test_framework)
+
+LIST (APPEND check_PROGRAMS
+    regression_runner.cpp
+)
+
+FOREACH (source_file ${check_PROGRAMS})
+    GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
+    ADD_EXECUTABLE (
+        ${source_file_we}
+        ${source_file}
+    )
+
+    TARGET_COMPILE_DEFINITIONS (${source_file_we} PRIVATE
+        $<IF:$<BOOL:${MSGPACK_USE_STATIC_BOOST}>,,BOOST_TEST_DYN_LINK>)
+
+    TARGET_LINK_LIBRARIES (${source_file_we}
+        msgpack-cxx
+        Threads::Threads
+        Boost::filesystem
+        Boost::unit_test_framework
+    )
+
+    ADD_TEST (${source_file_we} ${source_file_we})
+
+    IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "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,49 @@
+#include <boost/filesystem.hpp>
+
+// Use parameterized tests instead of modern data-driven test cases
+// because BOOST_DATA_TEST_CASE requires C++11 or newer. See:
+// - https://www.boost.org/doc/libs/1_76_0/libs/test/doc/html/boost_test/tests_organization/test_cases/param_test.html
+// - https://www.boost.org/doc/libs/1_76_0/libs/test/doc/html/boost_test/tests_organization/test_cases/test_case_generation.html
+#include <boost/test/included/unit_test.hpp>
+#include <boost/test/parameterized_test.hpp>
+
+#include <fstream>
+#include <string>
+#include <vector>
+
+#include "unpack_pack_fuzzer.cpp"
+
+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;
+}
+
+void UnpackPackFuzzerRegressionTest(const std::string& fpath) {
+  std::ifstream in(fpath.c_str(), std::ios_base::binary);
+  if (!in) {
+    BOOST_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());
+  BOOST_REQUIRE(in);
+  BOOST_REQUIRE_EQUAL(0, LLVMFuzzerTestOneInput(reinterpret_cast<const uint8_t *>(bytes.data()), bytes.size()));
+}
+
+boost::unit_test::test_suite* init_unit_test_suite(int /*argc*/, char* /*argv*/[])
+{
+  std::vector<std::string> files = ListDirectory("../../fuzz/unpack_pack_fuzzer_regressions");
+  boost::unit_test::framework::master_test_suite().add(BOOST_PARAM_TEST_CASE(&UnpackPackFuzzerRegressionTest, files.begin(), files.end()));
+  return 0;
+}

fuzz/unpack_pack_fuzzer.cpp

@@ -0,0 +1,27 @@
+#include <msgpack.hpp>
+
+// The function's signature must NOT be changed since other projects rely on it:
+// - libFuzzer
+// - AFL++
+// - Google's oss-fuzz (uses the previous two ones)
+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,
+                                                      MSGPACK_NULLPTR,
+                                                      MSGPACK_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 @@
+’
’’’’’’’’	’
+’’’
’’’’’’’’’’’’’’’’’’’ ’!’"’#’$’%’&’'’(’)’*’+’,’-’.’/’0’1’2’3’4’5’6’7’8’9’:’;’<’=’>’?’@’A’B’C’D’E’F’G’H’I’J’K’L’M’N’O’P’Q’R’S’T’U’V’W’X’Y’Z’[’\’]’^’_’`’a’b’c’d’e’f’g’h’i’j’k’l’m’n’o’p’q’r’s’t’u’v’w‘x

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

include/msgpack/adaptor/boost/string_view.hpp

@@ -0,0 +1,15 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// 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)
+//
+#ifndef MSGPACK_TYPE_BOOST_STRING_VIEW_HPP
+#define MSGPACK_TYPE_BOOST_STRING_VIEW_HPP
+
+#include "msgpack/v1/adaptor/boost/string_view.hpp"
+
+#endif // MSGPACK_TYPE_BOOST_STRING_VIEW_HPP

include/msgpack/adaptor/carray.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_CARRAY_HPP
+#define MSGPACK_TYPE_CARRAY_HPP
+
+#include "msgpack/v1/adaptor/carray.hpp"
+
+#endif // MSGPACK_TYPE_CARRAY_HPP

include/msgpack/adaptor/char_ptr.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_CHAR_PTR_HPP
+#define MSGPACK_TYPE_CHAR_PTR_HPP
+
+#include "msgpack/v1/adaptor/char_ptr.hpp"
+
+#endif // MSGPACK_TYPE_CHAR_PTR_HPP

include/msgpack/adaptor/check_container_size.hpp

@@ -0,0 +1,17 @@
+//
+// 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_CHECK_CONTAINER_SIZE_HPP
+#define MSGPACK_CHECK_CONTAINER_SIZE_HPP
+
+#include "msgpack/adaptor/check_container_size_decl.hpp"
+
+#include "msgpack/v1/adaptor/check_container_size.hpp"
+
+#endif // MSGPACK_CHECK_CONTAINER_SIZE_HPP

include/msgpack/adaptor/check_container_size_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_CHECK_CONTAINER_SIZE_DECL_HPP
+#define MSGPACK_CHECK_CONTAINER_SIZE_DECL_HPP
+
+#include "msgpack/v1/adaptor/check_container_size_decl.hpp"
+#include "msgpack/v2/adaptor/check_container_size_decl.hpp"
+#include "msgpack/v3/adaptor/check_container_size_decl.hpp"
+
+#endif // MSGPACK_CHECK_CONTAINER_SIZE_DECL_HPP

include/msgpack/adaptor/complex.hpp

@@ -0,0 +1,15 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2020 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_COMPLEX_HPP
+#define MSGPACK_TYPE_COMPLEX_HPP
+
+#include "msgpack/v1/adaptor/complex.hpp"
+
+#endif // MSGPACK_TYPE_COMPLEX_HPP

include/msgpack/adaptor/cpp11/array.hpp

@@ -0,0 +1,16 @@
+//
+// 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_CPP11_ARRAY_HPP
+#define MSGPACK_TYPE_CPP11_ARRAY_HPP
+
+#include "msgpack/v1/adaptor/cpp11/array.hpp"
+
+#endif // MSGPACK_TYPE_CPP11_ARRAY_HPP

include/msgpack/adaptor/cpp11/array_char.hpp

@@ -0,0 +1,16 @@
+//
+// 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_CPP11_ARRAY_CHAR_HPP
+#define MSGPACK_TYPE_CPP11_ARRAY_CHAR_HPP
+
+#include "msgpack/v1/adaptor/cpp11/array_char.hpp"
+
+#endif // MSGPACK_TYPE_CPP11_ARRAY_CHAR_HPP

include/msgpack/adaptor/cpp11/array_unsigned_char.hpp

@@ -0,0 +1,16 @@
+//
+// 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_CPP11_ARRAY_UNSIGNED_CHAR_HPP
+#define MSGPACK_TYPE_CPP11_ARRAY_UNSIGNED_CHAR_HPP
+
+#include "msgpack/v1/adaptor/cpp11/array_unsigned_char.hpp"
+
+#endif // MSGPACK_TYPE_CPP11_ARRAY_UNSIGNED_CHAR_HPP

include/msgpack/adaptor/cpp11/chrono.hpp

@@ -0,0 +1,16 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// 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)
+//
+
+#ifndef MSGPACK_TYPE_CPP11_CHRONO_HPP
+#define MSGPACK_TYPE_CPP11_CHRONO_HPP
+
+#include "msgpack/v1/adaptor/cpp11/chrono.hpp"
+
+#endif // MSGPACK_TYPE_CPP11_CHRONO_HPP

include/msgpack/adaptor/cpp11/forward_list.hpp

@@ -0,0 +1,16 @@
+//
+// 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_CPP11_FORWARD_LIST_HPP
+#define MSGPACK_TYPE_CPP11_FORWARD_LIST_HPP
+
+#include "msgpack/v1/adaptor/cpp11/forward_list.hpp"
+
+#endif // MSGPACK_TYPE_CPP11_FORWARD_LIST_HPP

include/msgpack/adaptor/cpp11/reference_wrapper.hpp

@@ -0,0 +1,16 @@
+//
+// 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_CPP11_REFERENCE_WRAPPER_HPP
+#define MSGPACK_TYPE_CPP11_REFERENCE_WRAPPER_HPP
+
+#include "msgpack/v1/adaptor/cpp11/reference_wrapper.hpp"
+
+#endif // MSGPACK_TYPE_CPP11_REFERENCE_WRAPPER_HPP

include/msgpack/adaptor/cpp11/shared_ptr.hpp

@@ -0,0 +1,16 @@
+//
+// 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_CPP11_SHARED_PTR_HPP
+#define MSGPACK_TYPE_CPP11_SHARED_PTR_HPP
+
+#include "msgpack/v1/adaptor/cpp11/shared_ptr.hpp"
+
+#endif // MSGPACK_TYPE_CPP11_SHARED_PTR_HPP

include/msgpack/adaptor/cpp11/timespec.hpp

@@ -0,0 +1,16 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2019 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_CPP11_TIMESPEC_HPP
+#define MSGPACK_TYPE_CPP11_TIMESPEC_HPP
+
+#include "msgpack/v1/adaptor/cpp11/timespec.hpp"
+
+#endif // MSGPACK_TYPE_CPP11_TIMESPEC_HPP

include/msgpack/adaptor/cpp11/tuple.hpp

@@ -0,0 +1,16 @@
+//
+// 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_CPP11_TUPLE_HPP
+#define MSGPACK_TYPE_CPP11_TUPLE_HPP
+
+#include "msgpack/v1/adaptor/cpp11/tuple.hpp"
+
+#endif // MSGPACK_TYPE_CPP11_TUPLE_HPP

include/msgpack/adaptor/cpp11/unique_ptr.hpp

@@ -0,0 +1,16 @@
+//
+// 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_CPP11_UNIQUE_PTR_HPP
+#define MSGPACK_TYPE_CPP11_UNIQUE_PTR_HPP
+
+#include "msgpack/v1/adaptor/cpp11/unique_ptr.hpp"
+
+#endif // MSGPACK_TYPE_CPP11_UNIQUE_PTR_HPP

include/msgpack/adaptor/cpp11/unordered_map.hpp

@@ -0,0 +1,16 @@
+//
+// 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_CPP11_UNORDERED_MAP_HPP
+#define MSGPACK_TYPE_CPP11_UNORDERED_MAP_HPP
+
+#include "msgpack/v1/adaptor/cpp11/unordered_map.hpp"
+
+#endif // MSGPACK_TYPE_CPP11_UNORDERED_MAP_HPP

include/msgpack/adaptor/cpp11/unordered_set.hpp

@@ -0,0 +1,16 @@
+//
+// 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_CPP11_UNORDERED_SET_HPP
+#define MSGPACK_TYPE_CPP11_UNORDERED_SET_HPP
+
+#include "msgpack/v1/adaptor/cpp11/unordered_set.hpp"
+
+#endif // MSGPACK_TYPE_CPP11_UNORDERED_SET_HPP

include/msgpack/adaptor/cpp17/array_byte.hpp

@@ -0,0 +1,16 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2021 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_CPP17_ARRAY_BYTE_HPP
+#define MSGPACK_TYPE_CPP17_ARRAY_BYTE_HPP
+
+#include "msgpack/v1/adaptor/cpp17/array_byte.hpp"
+
+#endif // MSGPACK_TYPE_CPP17_ARRAY_BYTE_HPP

include/msgpack/adaptor/cpp17/byte.hpp

@@ -0,0 +1,16 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2018 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_CPP17_BYTE_HPP
+#define MSGPACK_TYPE_CPP17_BYTE_HPP
+
+#include "msgpack/v1/adaptor/cpp17/byte.hpp"
+
+#endif // MSGPACK_TYPE_CPP17_BYTE_HPP

include/msgpack/adaptor/cpp17/carray_byte.hpp

@@ -0,0 +1,16 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2018 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_CPP17_CARRAY_BYTE_HPP
+#define MSGPACK_TYPE_CPP17_CARRAY_BYTE_HPP
+
+#include "msgpack/v1/adaptor/cpp17/carray_byte.hpp"
+
+#endif // MSGPACK_TYPE_CPP17_CARRAY_BYTE_HPP

include/msgpack/adaptor/cpp17/optional.hpp

@@ -0,0 +1,16 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// 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)
+//
+
+#ifndef MSGPACK_TYPE_CPP17_OPTIONAL_HPP
+#define MSGPACK_TYPE_CPP17_OPTIONAL_HPP
+
+#include "msgpack/v1/adaptor/cpp17/optional.hpp"
+
+#endif // MSGPACK_TYPE_CPP17_OPTIONAL_HPP

include/msgpack/adaptor/cpp17/string_view.hpp

@@ -0,0 +1,16 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// 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)
+//
+
+#ifndef MSGPACK_TYPE_CPP17_STRING_VIEW_HPP
+#define MSGPACK_TYPE_CPP17_STRING_VIEW_HPP
+
+#include "msgpack/v1/adaptor/cpp17/string_view.hpp"
+
+#endif // MSGPACK_TYPE_CPP17_STRING_VIEW_HPP

include/msgpack/adaptor/cpp17/variant.hpp

@@ -0,0 +1,16 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2023 Uy Ha
+//
+//    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_CPP17_VARIANT_HPP
+#define MSGPACK_TYPE_CPP17_VARIANT_HPP
+
+#include "msgpack/v1/adaptor/cpp17/variant.hpp"
+
+#endif // MSGPACK_TYPE_CPP17_VARIANT_HPP

include/msgpack/adaptor/cpp17/vector_byte.hpp

@@ -0,0 +1,16 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2018 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_CPP17_VECTOR_BYTE_HPP
+#define MSGPACK_TYPE_CPP17_VECTOR_BYTE_HPP
+
+#include "msgpack/v1/adaptor/cpp17/vector_byte.hpp"
+
+#endif // MSGPACK_TYPE_CPP17_VECTOR_BYTE_HPP