Merge pull request #976 from redboltz/update_to_c_4

Updated the version to 4.0.0.

.github/workflows/coverage.yml

@@ -0,0 +1,53 @@
+name: coverage
+
+on:
+  pull_request:
+    types: [opened, synchronize]
+  push:
+    branches:
+    - c_master
+    tags:
+    - '*'
+
+jobs:
+
+  codecov:
+    timeout-minutes: 30
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v1
+    - name: install depends
+      run: |
+        sudo apt-get update
+        sudo apt-get install g++-multilib lcov
+    - name: Compile tests
+      run: |
+        # install gtest
+        BASE=`pwd`
+        wget https://github.com/google/googletest/archive/release-1.7.0.zip -O googletest-release-1.7.0.zip
+        unzip -q googletest-release-1.7.0.zip
+        cd googletest-release-1.7.0
+        g++ -m64 src/gtest-all.cc -I. -Iinclude -c -fPIC
+        g++ -m64 src/gtest_main.cc -I. -Iinclude -c -fPIC
+        ar -rv libgtest.a gtest-all.o
+        ar -rv libgtest_main.a gtest_main.o
+        mkdir -p ${BASE}/usr/include
+        cp -r include/gtest ${BASE}/usr/include
+        mkdir -p ${BASE}/usr/lib
+        mv *.a ${BASE}/usr/lib
+        cd ..
+
+        mkdir build && cd build
+        CMAKE_LIBRARY_PATH="${BASE}/build" GTEST_ROOT="${BASE}/usr" CMAKE_PREFIX_PATH="${BASE}/usr/gcc/lib64/cmake" cmake -DMSGPACK_32BIT=OFF -DBUILD_SHARED_LIBS=ON -DMSGPACK_CHAR_SIGN=signed -DMSGPACK_BUILD_EXAMPLES=ON -DMSGPACK_BUILD_TESTS=ON -DCMAKE_BUILD_TYPE=Debug -DMSGPACK_GEN_COVERAGE=ON ..
+        make -j4
+        make test
+    - 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,225 @@
+name: CI
+
+on:
+  pull_request:
+    types: [opened, synchronize]
+  push:
+    branches:
+    - c_master
+    tags:
+    - '*'
+
+jobs:
+  macos:
+    runs-on: macos-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        pattern: [0, 1, 2, 3]
+    steps:
+    - uses: actions/checkout@v1
+    - name: build and test
+      env:
+        CC: clang
+        CXX: clang++
+      shell: bash
+      run: |
+        BASE=`pwd`;
+
+        # matrix config
+        ACTION="ci/build_cmake.sh"
+        export ARCH="64"
+        if [ ${{ matrix.pattern }} == 0 ]; then
+          export SHARED="ON"
+          export CHAR_SIGN="unsigned"
+        fi
+        if [ ${{ matrix.pattern }} == 1 ]; then
+          export SHARED="ON"
+          export CHAR_SIGN="signed"
+        fi
+        if [ ${{ matrix.pattern }} == 2 ]; then
+          export SHARED="OFF"
+          export CHAR_SIGN="signed"
+        fi
+        if [ ${{ matrix.pattern }} == 3 ]; then
+          export SHARED="OFF"
+          export CHAR_SIGN="unsigned"
+        fi
+
+        # install gtest
+        wget https://github.com/google/googletest/archive/release-1.7.0.zip -O googletest-release-1.7.0.zip
+        unzip -q googletest-release-1.7.0.zip
+        cd googletest-release-1.7.0
+        $CXX -m${ARCH} src/gtest-all.cc -I. -Iinclude -c
+        $CXX -m${ARCH} src/gtest_main.cc -I. -Iinclude -c
+        ar -rv libgtest.a gtest-all.o
+        ar -rv libgtest_main.a gtest_main.o
+        mkdir -p ${BASE}/usr/include
+        cp -r include/gtest ${BASE}/usr/include
+        mkdir -p ${BASE}/usr/lib
+        mv *.a ${BASE}/usr/lib
+        cd ..
+
+        # build and test
+        CMAKE_CXX_COMPILER="${CXX}" CMAKE_C_COMPILER="${CC}" GTEST_ROOT="${BASE}/usr" CFLAGS="-Werror -g -fsanitize=undefined" CXXFLAGS="-Werror -g -fsanitize=undefined" ${ACTION}
+
+  linux:
+    runs-on: ubuntu-18.04
+    strategy:
+      fail-fast: false
+      matrix:
+        pattern: [0, 1, 2, 3, 4, 5, 6, 7, 8]
+    steps:
+    - uses: actions/checkout@v1
+    - name: install build depends
+      run: |
+        sudo apt-get update
+        sudo apt-get install g++-multilib clang-8 valgrind
+    - name: build and test
+      shell: bash
+      run: |
+        BASE=`pwd`;
+
+        # matrix config
+        if [ ${{ matrix.pattern }} == 0 ]; then
+          export CC=clang
+          export CXX=clang++
+          ACTION="ci/build_cmake.sh"
+          export ARCH="64"
+          export SHARED="ON"
+          export CHAR_SIGN="unsigned"
+        fi
+        if [ ${{ matrix.pattern }} == 1 ]; then
+          export CC=clang
+          export CXX=clang++
+          ACTION="ci/build_cmake.sh"
+          export ARCH="32"
+          export SHARED="ON"
+          export CHAR_SIGN="signed"
+        fi
+        if [ ${{ matrix.pattern }} == 2 ]; then
+          export CC=clang
+          export CXX=clang++
+          ACTION="ci/build_cmake.sh"
+          export ARCH="64"
+          export SHARED="ON"
+          export CHAR_SIGN="signed"
+        fi
+        if [ ${{ matrix.pattern }} == 3 ]; then
+          export CC=clang
+          export CXX=clang++
+          ACTION="ci/build_cmake.sh"
+          export ARCH="32"
+          export SHARED="OFF"
+          export CHAR_SIGN="unsigned"
+        fi
+        if [ ${{ matrix.pattern }} == 4 ]; then
+          export CC=gcc
+          export CXX=g++
+          ACTION="ci/build_cmake.sh"
+          export ARCH="64"
+          export SHARED="ON"
+          export CHAR_SIGN="signed"
+        fi
+        if [ ${{ matrix.pattern }} == 5 ]; then
+          export CC=gcc
+          export CXX=g++
+          ACTION="ci/build_cmake.sh"
+          export ARCH="32"
+          export SHARED="ON"
+          export CHAR_SIGN="unsigned"
+        fi
+        if [ ${{ matrix.pattern }} == 6 ]; then
+          export CC=gcc
+          export CXX=g++
+          ACTION="ci/build_cmake.sh"
+          export ARCH="64"
+          export SHARED="ON"
+          export CHAR_SIGN="unsigned"
+        fi
+        if [ ${{ matrix.pattern }} == 7 ]; then
+          export CC=gcc
+          export CXX=g++
+          ACTION="ci/build_cmake.sh"
+          export ARCH="32"
+          export SHARED="OFF"
+          export CHAR_SIGN="signed"
+        fi
+        if [ ${{ matrix.pattern }} == 8 ]; then
+          export CC=gcc
+          export CXX=g++
+          ACTION="ci/build_cmake_embedded.sh"
+          export ARCH="64"
+        fi
+
+        # install gtest
+        wget https://github.com/google/googletest/archive/release-1.7.0.zip -O googletest-release-1.7.0.zip
+        unzip -q googletest-release-1.7.0.zip
+        cd googletest-release-1.7.0
+        $CXX -m${ARCH} src/gtest-all.cc -I. -Iinclude -c -fPIC
+        $CXX -m${ARCH} src/gtest_main.cc -I. -Iinclude -c -fPIC
+        ar -rv libgtest.a gtest-all.o
+        ar -rv libgtest_main.a gtest_main.o
+        mkdir -p ${BASE}/usr/include
+        cp -r include/gtest ${BASE}/usr/include
+        mkdir -p ${BASE}/usr/lib
+        mv *.a ${BASE}/usr/lib
+        cd ..
+
+        # install zlib
+        if [ ${ARCH} == 32 ]; then
+          sudo apt-get install lib32z1-dev
+        fi
+
+        # build and test
+        CMAKE_CXX_COMPILER="${CXX}" CMAKE_C_COMPILER="${CC}" GTEST_ROOT="${BASE}/usr" CFLAGS="-Werror -g -fsanitize=undefined" CXXFLAGS="-Werror -g -fsanitize=undefined" MSGPACK_SAN="${SAN}" ${ACTION}
+
+  windows:
+    runs-on: windows-2019
+    strategy:
+      fail-fast: false
+      matrix:
+        pattern: [0, 1, 2, 3]
+    steps:
+    - uses: actions/checkout@v2.0.0
+    - name: Cache vcpkg
+      id: cache-vcpkg
+      uses: actions/cache@v1.1.2
+      with:
+        path: C:/vcpkg/installed
+        key: windows-2019-vcpkg-v2
+    - name: Build dependencies
+      if: steps.cache-vcpkg.outputs.cache-hit != 'true'
+      shell: powershell
+      run: |
+        vcpkg install gtest:x64-windows gtest:x86-windows
+        vcpkg install zlib:x64-windows zlib:x86-windows
+    - name: Build and test
+      shell: powershell
+      run: |
+        if (${{ matrix.pattern }} -eq 0) {
+          $ARCH="x64"
+          $SHARED="ON"
+        }
+        elseif (${{ matrix.pattern }} -eq 1) {
+          $ARCH="x64"
+          $SHARED="OFF"
+        }
+        elseif (${{ matrix.pattern }} -eq 2) {
+          $ARCH="Win32"
+          $SHARED="ON"
+        }
+        else {
+          $ARCH="Win32"
+          $SHARED="OFF"
+        }
+
+        $CUR=(Get-Location).Path
+        md build
+        cd build
+        cmake -A $ARCH -DBUILD_SHARED_LIBS=$SHARED -DCMAKE_TOOLCHAIN_FILE="C:/vcpkg/scripts/buildsystems/vcpkg.cmake" "-DCMAKE_CXX_FLAGS=/D_VARIADIC_MAX=10 /EHsc /D_SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING" ..
+        cmake --build . --config Release
+        $pathbak="$env:PATH"
+        $env:PATH="C:\vcpkg\installed\x64-windows\bin;$CUR\build\Release;$pathbak"
+        ctest -V
+        $env:PATH=$pathbak

.gitmodules

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

.travis.yml

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

CHANGELOG.md

@@ -1,3 +1,202 @@
+# 2021-08-01 version 4.0.0
+  * Fix and improve alignment logic (#962)
+  * Fix iovec name conflict (#953)
+  * Fix empty string print (#942)
+  * Fix buffer ptr size (#899)
+  * Fix UB. Check null pointer before using memcpy() (#890)
+  * Improve CI environment (#885, #899)
+
+## << breaking changes >>
+* Separate C part of the msgpack-c from C/C++ mixed msgpack-c (#876, #878)
+
+
+# 2020-06-05 version 3.3.0
+  * Add json example for C (#870)
+  * Add both header and body packing functions for C (#870)
+  * Set default ref_size and chunk_size to vrefbuffer (#865)
+  * Add examples (#861)
+  * Improve build system (#839, #842)
+  * Improve tests (#829)
+  * Improve documents (#828)
+  * Remove some warnings (#827, #851, #871)
+  * Improve CI environment (#824, #831, #833, #834, #846, #860, 874)
+
+# 2019-12-10 version 3.2.1
+  * Fix snprintf return value checking (#821)
+  * Remove some warnings (#819)
+  * Fix fbuffer result checking (#812)
+  * Fix temporary object handling (#807)
+  * Improve cmake support (#804)
+  * Fix invalid `int main` parameter (#800)
+  * Improve supporting platform (#797, #817)
+  * Fix ZLIB error handling (#795)
+  * Remove unused variable (#793)
+  * Improve integer overflow checking (#792)
+
+# 2019-05-27 version 3.2.0
+
+  * Fix invalid include (#783)
+  * Add timespec support (#781)
+  * Fix unchecked fnprintf on C (#780)
+  * Improve integer overflow checking on C (#776)
+  * Fix warnings on `-Wconversion` (#770, #777, #784)
+  * Fix invalid passed by value on aligned_zone_size_visitor (#764)
+  * Improve windows support (#757, #779)
+  * Fix msgpack::object size caluclation error (#754)
+  * Fix memory error on example code (#753)
+  * Fix redundant memory allocation on C (#747)
+  * Fix msgpack::type::tuple base class conversion (#743)
+
+# 2018-09-09 version 3.1.1
+
+  * Add force endian set functionality (#736)
+  * Fix vrefbuffer memory management problem (#733)
+  * Fix msvc specific problem (#731, #732)
+  * Update boost from 1.61.0 to 1.68.0 (#730)
+  * Fix msgpack_timestamp type mismatch bug (#726)
+
+# 2018-08-10 version 3.1.0
+
+  * Improve documents (#687, #718)
+  * Add fuzzer support (#689)
+  * Fix msgpack::object union member access bug (#694)
+  * Improve cross platform configuration (#704)
+  * Fix out of range dereference bug of EXT (#705)
+  * Add timestamp support. std::chrono::system_clock::time_point is mapped to TIMESTAMP (#706)
+  * Add minimal timestamp support for C. The type `msgpack_timestamp` and the function `msgpack_object_to_timestamp()` are introduced (#707)
+  * Improve MSGPACK_DEFINE family name confliction probability (#710)
+  * Add no static-library build option (BUILD_SHARED_LIBS=ON) (#713, #717, #722)
+  * Add header only cmake target (#721)
+  * Add `std::byte` adaptor (#719)
+  * Remove some warnings (#720)
+
+# 2018-05-12 version 3.0.1
+
+  * Add fuzz directory to release tar ball (#686)
+  * Add include file checking for X-Code (#683)
+
+# 2018-05-09 version 3.0.0
+
+## << breaking changes >>
+
+  * Change offset parameter updating rule. If parse error happens, offset is updated to the error position. (#639, #666)
+
+## << other updates >>
+
+  * Improve cross platform configuration (#655, #677)
+  * Improve build system (#647)
+  * Improve user class adaptor (#645, #673)
+  * Improve msgpack::object visitation logic (#676)
+  * Remove some warnings (#641, 659)
+  * Add `->` and `*` operators to object_handle (#635)
+  * Improve CI environment (#631, #634, #643, #657, #662, #668)
+  * Improve documents (#630, #661)
+  * Refactoring (#670)
+  * Add OSS-Fuzz support (#672, #674, #675, #678)
+
+# 2017-08-04 version 2.1.5
+  * Improve cross platform configuration (#624)
+  * Add boost asio examples (including zlib) (#610)
+  * Remove some warnings (#611)
+  * Fix unpack visitor to treat float32/64 correctly (#613)
+  * Improve documents (#616)
+  * Fix alignment problem on some platform (#617, #518)
+  * Fix conflict std::tuple, std::pair, and boost::fusion::sequence problem (#619)
+
+# 2017-08-03 version 2.1.4 (Invalid)
+  * See https://github.com/msgpack/msgpack-c/issues/623
+
+# 2017-06-15 version 2.1.3
+  * Improve build system (#603)
+  * Add C++17 adaptors `std::optional` and `std::string_view`. (#607, #608)
+  * Improve cross platform configuration (#601)
+  * Remove some warnings (#599, #602, #605)
+
+# 2017-06-07 version 2.1.2
+
+* Improve documents (#565)
+  * Fix empty map parse bug (#568)
+  * Improve build system (#569, #570, #572, #579, #591, #592)
+  * Remove some warnings (#574, #578, #586, #588)
+  * Improve cross platform configuration (#577, #582)
+  * Add cmake package config support (#580)
+  * Fix streaming unpack bug (#585)
+
+# 2017-02-04 version 2.1.1
+
+  * Fix unpacker's buffer management bug (#561)
+  * Add boost string_view adaptor (#558)
+  * Remove some warnings (#557, #559)
+  * Improve coding style (#556)
+
+# 2017-01-10 version 2.1.0
+
+## << breaking changes >>
+
+  * Fix object internal data type is float if msgpack format is float32 (#531)
+
+## << recommended changes >>
+
+  * Add `FLOAT64` type. Please use it instead of `DOUBLE` (#531)
+  * Add `FLOAT32` type. Please use it instead of `FLOAT` (#531)
+
+## << other updates >>
+
+  * Add iterator based parse/unpack function(experimental) (#553)
+  * Add `[[deprecated]]` attribute for C++14 (#552)
+  * Fix `msgpack_unpack()` return code (#548)
+  * Fix integer overflow (#547, #549, #550)
+  * Add example codes (#542)
+  * Add MSGPACK_NVP. You can use not only variable name but also any strings (#535)
+  * Fix and Improve build system (#532, #545)
+  * Fix `gcc_atomic.hpp` include path (#529, #530)
+  * Improve CI environment (#526)
+  * Improve documents (#524)
+  * Add msgpack_unpacker_next_with_size() function (#515)
+  * Fix `as()` applying condition (#511)
+  * Fix fbuffer write (#504)
+  * Add gcc bug workaround (#499)
+  * Improve object print (#497, #500, #505, #533)
+  * Remove some warnings (#495, #506, #508, #513, #528, #538, #545)
+
+# 2016-06-25 version 2.0.0
+
+## << breaking changes >>
+
+  * Removed autotools support. Use cmake instead (#476, #479)
+  * Removed pointer version of msgpack::unpack APIs. Use reference version instead (#453)
+  * Removed MSGPACK_DISABLE_LEGACY_CONVERT. msgpack::object::convert(T*) is removed by default. Use msgpack::object::convert(T&) instead (#451)
+  * Removed msgpacl::type::nil. Use nil_t or define MSGPACK_USE_LECACY_NIL (#444)
+  * Removed std::string to msgpack::object conversion (#434)
+
+## << recommended changes >>
+
+  * Replaced msgpack::unpacked with msgpack::object_handle. msgpack::unpacked is kept as a typedef of msgpack::object_handle. (#448)
+
+## << other updates >>
+
+  * Add strict size checking adaptor. Relaxed tuple conversion (#489)
+  * Fix and Improve example codes (#487)
+  * Add C++/CLI support for nullptr (#481)
+  * Update the boost libraries that are contained by msgpack-c (#475)
+  * Fix gcc_atomic.hpp location (#474)
+  * Add C-Style array support (#466, #488)
+  * Fix include file dependency (#464)
+  * Add a visitor version of unpack API (#461)
+  * Fix JSON string conversion from "nil" to "null" (#458)
+  * Fix and Improve build system (#455, #471, #473, #486, #491)
+  * Fix comments (#452)
+  * Fix unintentional msgpack::zone moving problem (#447)
+  * Fix operator>> and << for msgpack::object (#443)
+  * Fix C++03 msgpack::zone::clear() memory access violation bug (#441)
+  * Fix TARGET_OS_IPHONE checking (#436)
+  * Fix invalid front() call for empty container (#435)
+  * Fix compile error on g++6 (C++11 only) (#426, #430)
+  * Fix zone size expansion logic (#423)
+  * Fix wrong hader file dependency (#421)
+  * Fix msvc specific problem (#420)
+  * Add v2 API support (#415)
+
 # 2016-01-22 version 1.4.0
 
 ## << recommended changes >>

CMakeLists.txt

@@ -1,4 +1,10 @@
-CMAKE_MINIMUM_REQUIRED (VERSION 2.8.6)
+CMAKE_MINIMUM_REQUIRED (VERSION 2.8.12)
+
+IF ((CMAKE_VERSION VERSION_GREATER 3.1) OR
+    (CMAKE_VERSION VERSION_EQUAL 3.1))
+    CMAKE_POLICY(SET CMP0054 NEW)
+ENDIF ()
+
 PROJECT (msgpack)
 
 FILE (READ ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/version_master.h contents)
@@ -10,19 +16,35 @@ STRING (REGEX MATCH "#define MSGPACK_VERSION_REVISION *([0-9a-zA-Z_]*)" NULL_OUT
 SET (VERSION_REVISION ${CMAKE_MATCH_1})
 SET (VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_REVISION})
 
+LIST (APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake/")
 SET (prefix ${CMAKE_INSTALL_PREFIX})
 SET (exec_prefix "\${prefix}")
 SET (libdir "\${exec_prefix}/lib")
 SET (includedir "\${prefix}/include")
-SET (GNUCXX_STD_SUPPORT_VERSION "4.3")
-SET (GNUCXX_NO_MISMATCHED_TAGS_SUPPORT_VERSION "4.4")
 
-OPTION (MSGPACK_CXX11 "Using c++11 compiler" OFF)
 OPTION (MSGPACK_32BIT "32bit compile" OFF)
-OPTION (MSGPACK_BOOST "Using boost libraries" OFF)
 
-SET (CMAKE_CXX_FLAGS "-DMSGPACK_DISABLE_LEGACY_NIL ${CMAKE_CXX_FLAGS}")
+INCLUDE(TestBigEndian)
-SET (CMAKE_CXX_FLAGS "-DMSGPACK_DISABLE_LEGACY_CONVERT ${CMAKE_CXX_FLAGS}")
+TEST_BIG_ENDIAN(BIGENDIAN)
+IF (BIGENDIAN)
+    SET(MSGPACK_ENDIAN_BIG_BYTE 1)
+    SET(MSGPACK_ENDIAN_LITTLE_BYTE 0)
+ELSE ()
+    SET(MSGPACK_ENDIAN_BIG_BYTE 0)
+	SET(MSGPACK_ENDIAN_LITTLE_BYTE 1)
+ENDIF ()
+
+CONFIGURE_FILE (
+    cmake/sysdep.h.in
+    include/msgpack/sysdep.h
+    @ONLY
+)
+
+CONFIGURE_FILE (
+    cmake/pack_template.h.in
+    include/msgpack/pack_template.h
+    @ONLY
+)
 
 IF (APPLE)
     SET(CMAKE_MACOSX_RPATH ON)
@@ -36,213 +58,61 @@ IF (APPLE)
     ENDIF ()
 ENDIF ()
 
-IF (MSGPACK_CXX11)
-   IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-      SET (CMAKE_CXX_FLAGS "-std=c++11 ${CMAKE_CXX_FLAGS}")
-   ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-      SET (CMAKE_CXX_FLAGS "-std=c++11 ${CMAKE_CXX_FLAGS}")
-   ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-      IF (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19)
-          MESSAGE ( FATAL_ERROR "MSVC doesn't support C++11.")
-      ENDIF ()
-   ENDIF ()
-ELSE ()
-   IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-      IF ((CMAKE_CXX_COMPILER_VERSION VERSION_GREATER ${GNUCXX_STD_SUPPORT_VERSION}) OR
-          (CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL   ${GNUCXX_STD_SUPPORT_VERSION}))
-          SET (CMAKE_CXX_FLAGS "-std=c++03 ${CMAKE_CXX_FLAGS}")
-      ENDIF ()
-   ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-      SET (CMAKE_CXX_FLAGS "-std=c++03 ${CMAKE_CXX_FLAGS}")
-   ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-      IF (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 18)
-          SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_CPP03 ${CMAKE_CXX_FLAGS}")
-      ENDIF ()
-   ENDIF ()
-ENDIF ()
-
 IF (MSGPACK_32BIT)
-   IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+   IF ("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU")
-      SET (CMAKE_CXX_FLAGS "-m32 ${CMAKE_CXX_FLAGS}")
       SET (CMAKE_C_FLAGS "-m32 ${CMAKE_C_FLAGS}")
       SET (CMAKE_EXE_LINKER_FLAGS "-m32 ${CMAKE_EXE_LINKER_FLAGS}")
-   ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+   ELSEIF ("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang")
-      SET (CMAKE_CXX_FLAGS "-m32 ${CMAKE_CXX_FLAGS}")
       SET (CMAKE_C_FLAGS "-m32 ${CMAKE_C_FLAGS}")
       SET (CMAKE_EXE_LINKER_FLAGS "-m32 ${CMAKE_EXE_LINKER_FLAGS}")
    ENDIF ()
 ENDIF ()
 
-IF (MSGPACK_BOOST)
+OPTION (MSGPACK_BUILD_EXAMPLES "Build msgpack examples." ON)
-   SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_BOOST ${CMAKE_CXX_FLAGS}")
-   SET (Boost_USE_STATIC_LIBS        ON) # only find static libs
-   SET (Boost_USE_MULTITHREADED      ON)
-   SET (Boost_USE_STATIC_RUNTIME    OFF)
-   FIND_PACKAGE (Boost COMPONENTS chrono timer system)
-   INCLUDE_DIRECTORIES (
-       ${MSGPACK_BOOST_DIR}
-   )
-ENDIF ()
 
 IF (MSGPACK_CHAR_SIGN)
    SET (CMAKE_C_FLAGS "-f${MSGPACK_CHAR_SIGN}-char ${CMAKE_C_FLAGS}")
-   SET (CMAKE_CXX_FLAGS "-f${MSGPACK_CHAR_SIGN}-char ${CMAKE_CXX_FLAGS}")
 ENDIF ()
 
-FILE (GLOB_RECURSE PREDEF_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/external/boost/predef/include/boost ${CMAKE_CURRENT_SOURCE_DIR}/external/boost/predef/include/boost/*.h)
-FOREACH (F ${PREDEF_FILES})
-   SET(M "Converting ${F}")
-   MESSAGE(STATUS ${M})
-   FILE (READ ${CMAKE_CURRENT_SOURCE_DIR}/external/boost/predef/include/boost/${F} CONTENT)
-   STRING(REPLACE "BOOST_" "MSGPACK_" CONTENT ${CONTENT})
-   STRING(REPLACE "boost/" "msgpack/" CONTENT ${CONTENT})
-   FILE (WRITE ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/${F} ${CONTENT})
-ENDFOREACH ()
-
-FILE (GLOB_RECURSE PREPROCESSOR_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/external/boost/preprocessor/include/boost ${CMAKE_CURRENT_SOURCE_DIR}/external/boost/preprocessor/include/boost/*.hpp)
-FOREACH (F ${PREPROCESSOR_FILES})
-   SET(M "Converting ${F}")
-   MESSAGE(STATUS ${M})
-   FILE (READ ${CMAKE_CURRENT_SOURCE_DIR}/external/boost/preprocessor/include/boost/${F} CONTENT)
-   STRING(REPLACE "BOOST_" "MSGPACK_" CONTENT ${CONTENT})
-   STRING(REPLACE "boost/" "msgpack/" CONTENT ${CONTENT})
-   FILE (WRITE ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/${F} ${CONTENT})
-ENDFOREACH ()
-
 FIND_PACKAGE (GTest)
 FIND_PACKAGE (ZLIB)
 FIND_PACKAGE (Threads)
 IF (GTEST_FOUND AND ZLIB_FOUND AND THREADS_FOUND)
     OPTION (MSGPACK_BUILD_TESTS "Build msgpack tests." ON)
-ENDIF ()
+    OPTION (MSGPACK_GEN_COVERAGE "Enable running gcov to get a test coverage report." OFF)
-OPTION (MSGPACK_BUILD_EXAMPLES "Build msgpack examples." ON)
-
-OPTION (MSGPACK_ENABLE_CXX "Enable C++ interface." ON)
-OPTION (MSGPACK_ENABLE_SHARED "Build shared libaries in addition to static libraries." ON)
-
-INCLUDE (CheckCXXSourceCompiles)
-CHECK_CXX_SOURCE_COMPILES ("
-#include <bits/atomicity.h>
-int atomic_sub(int i) { return __gnu_cxx::__exchange_and_add(&i, -1) - 1; }
-int atomic_add(int i) { return __gnu_cxx::__exchange_and_add(&i, 1) + 1; }
-int main(int argc, char * argv[])
-{
-    atomic_sub(1);
-    atomic_add(1);
-}
-" MSGPACK_ENABLE_GCC_CXX_ATOMIC)
-
-
-LIST (APPEND msgpackc_SOURCES
-    src/unpack.c
-    src/objectc.c
-    src/version.c
-    src/vrefbuffer.c
-    src/zone.c
-)
-
-LIST (APPEND msgpackc_HEADERS
-    include/msgpack/pack_define.h
-    include/msgpack/pack_template.h
-    include/msgpack/unpack_define.h
-    include/msgpack/unpack_template.h
-    include/msgpack/util.h
-    include/msgpack/sysdep.h
-    include/msgpack/gcc_atomic.h
-    include/msgpack.h
-    include/msgpack/sbuffer.h
-    include/msgpack/version.h
-    include/msgpack/version_master.h
-    include/msgpack/vrefbuffer.h
-    include/msgpack/zbuffer.h
-    include/msgpack/fbuffer.h
-    include/msgpack/pack.h
-    include/msgpack/unpack.h
-    include/msgpack/object.h
-    include/msgpack/zone.h
-)
-
-FILE (GLOB_RECURSE PREDEF_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/predef/*.h)
-
-LIST (APPEND msgpackc_HEADERS ${PREDEF_FILES})
-LIST (APPEND msgpackc_HEADERS include/msgpack/predef.h)
-
-IF (MSGPACK_ENABLE_CXX)
-    LIST (APPEND msgpack_HEADERS
-        include/msgpack.hpp
-        include/msgpack/adaptor/adaptor_base.hpp
-        include/msgpack/adaptor/array_ref.hpp
-        include/msgpack/adaptor/bool.hpp
-        include/msgpack/adaptor/boost/fusion.hpp
-        include/msgpack/adaptor/boost/msgpack_variant.hpp
-        include/msgpack/adaptor/boost/optional.hpp
-        include/msgpack/adaptor/boost/string_ref.hpp
-        include/msgpack/adaptor/char_ptr.hpp
-        include/msgpack/adaptor/check_container_size.hpp
-        include/msgpack/adaptor/cpp11/array.hpp
-        include/msgpack/adaptor/cpp11/array_char.hpp
-        include/msgpack/adaptor/cpp11/array_unsigned_char.hpp
-        include/msgpack/adaptor/cpp11/forward_list.hpp
-        include/msgpack/adaptor/cpp11/reference_wrapper.hpp
-        include/msgpack/adaptor/cpp11/shared_ptr.hpp
-        include/msgpack/adaptor/cpp11/tuple.hpp
-        include/msgpack/adaptor/cpp11/unique_ptr.hpp
-        include/msgpack/adaptor/cpp11/unordered_map.hpp
-        include/msgpack/adaptor/cpp11/unordered_set.hpp
-        include/msgpack/adaptor/define.hpp
-        include/msgpack/adaptor/deque.hpp
-        include/msgpack/adaptor/detail/cpp03_define_array.hpp
-        include/msgpack/adaptor/detail/cpp03_define_map.hpp
-        include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp
-        include/msgpack/adaptor/detail/cpp11_define_array.hpp
-        include/msgpack/adaptor/detail/cpp11_define_map.hpp
-        include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp
-        include/msgpack/adaptor/ext.hpp
-        include/msgpack/adaptor/fixint.hpp
-        include/msgpack/adaptor/float.hpp
-        include/msgpack/adaptor/int.hpp
-        include/msgpack/adaptor/list.hpp
-        include/msgpack/adaptor/map.hpp
-        include/msgpack/adaptor/msgpack_tuple.hpp
-        include/msgpack/adaptor/nil.hpp
-        include/msgpack/adaptor/pair.hpp
-        include/msgpack/adaptor/raw.hpp
-        include/msgpack/adaptor/v4raw.hpp
-        include/msgpack/adaptor/set.hpp
-        include/msgpack/adaptor/string.hpp
-        include/msgpack/adaptor/tr1/unordered_map.hpp
-        include/msgpack/adaptor/tr1/unordered_set.hpp
-        include/msgpack/adaptor/vector.hpp
-        include/msgpack/adaptor/vector_bool.hpp
-        include/msgpack/adaptor/vector_char.hpp
-        include/msgpack/adaptor/vector_unsigned_char.hpp
-        include/msgpack/cpp_config.hpp
-        include/msgpack/detail/cpp03_zone.hpp
-        include/msgpack/detail/cpp11_zone.hpp
-        include/msgpack/fbuffer.hpp
-        include/msgpack/iterator.hpp
-        include/msgpack/meta.hpp
-        include/msgpack/object.hpp
-        include/msgpack/object_fwd.hpp
-        include/msgpack/pack.hpp
-        include/msgpack/sbuffer.hpp
-        include/msgpack/type.hpp
-        include/msgpack/unpack.hpp
-        include/msgpack/version.hpp
-        include/msgpack/versioning.hpp
-        include/msgpack/vrefbuffer.hpp
-        include/msgpack/zbuffer.hpp
-        include/msgpack/zone.hpp
-    )
-    FILE (GLOB_RECURSE PREPROCESSOR_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/preprocessor/*.hpp)
-
-    LIST (APPEND msgpackc_HEADERS ${PREPROCESSOR_FILES})
-    LIST (APPEND msgpackc_HEADERS include/msgpack/preprocessor.hpp)
 ENDIF ()
 
-EXECUTE_PROCESS (
+IF (DEFINED BUILD_SHARED_LIBS)
-    COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/src/msgpack
+    IF (BUILD_SHARED_LIBS)
-)
+        IF (DEFINED MSGPACK_ENABLE_SHARED AND NOT MSGPACK_ENABLE_SHARED)
+            MESSAGE(WARNING "MSGPACK_ENABLE_SHARED is overridden to ON by BUILD_SHARED_LIBS")
+        ENDIF ()
+        SET (MSGPACK_ENABLE_SHARED ON)
+        IF (DEFINED MSGPACK_ENABLE_STATIC AND MSGPACK_ENABLE_STATIC)
+            MESSAGE(WARNING "MSGPACK_ENABLE_STATIC is overridden to OFF by BUILD_SHARED_LIBS")
+        ENDIF ()
+        SET (MSGPACK_ENABLE_STATIC OFF)
+    ELSE ()
+        IF (DEFINED MSGPACK_ENABLE_SHARED AND MSGPACK_ENABLE_SHARED)
+            MESSAGE(WARNING "MSGPACK_ENABLE_SHARED is overridden to OFF by BUILD_SHARED_LIBS")
+        ENDIF ()
+        SET (MSGPACK_ENABLE_SHARED OFF)
+        IF (DEFINED MSGPACK_ENABLE_STATIC AND NOT MSGPACK_ENABLE_STATIC)
+            MESSAGE(WARNING "MSGPACK_ENABLE_STATIC is overridden to ON by BUILD_SHARED_LIBS")
+        ENDIF ()
+        SET (MSGPACK_ENABLE_STATIC ON)
+    ENDIF ()
+ELSE ()
+    IF (NOT DEFINED MSGPACK_ENABLE_SHARED)
+        SET (MSGPACK_ENABLE_SHARED ON)
+    ENDIF ()
+    IF (NOT DEFINED MSGPACK_ENABLE_STATIC)
+        SET (MSGPACK_ENABLE_STATIC ON)
+    ENDIF ()
+    SET (BUILD_SHARED_LIBS ${MSGPACK_ENABLE_SHARED})
+ENDIF ()
+
+INCLUDE (Files.cmake)
 
 CONFIGURE_FILE (
     msgpack.pc.in
@@ -250,32 +120,71 @@ CONFIGURE_FILE (
     @ONLY
 )
 
-INCLUDE_DIRECTORIES (
+IF (MSGPACK_ENABLE_SHARED OR MSGPACK_ENABLE_STATIC)
-    ./
+    ADD_LIBRARY (msgpackc
-    include/
-    ${CMAKE_CURRENT_BINARY_DIR}/include/
-)
-
-IF (MSGPACK_ENABLE_SHARED)
-    ADD_LIBRARY (msgpackc SHARED
         ${msgpackc_SOURCES}
         ${msgpackc_HEADERS}
     )
+
+    SET_TARGET_PROPERTIES (msgpackc PROPERTIES SOVERSION 2 VERSION 2.0.0)
+
+    TARGET_INCLUDE_DIRECTORIES (msgpackc
+        PUBLIC
+            $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+            $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
+            $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include/msgpack>
+            $<INSTALL_INTERFACE:include>
+        PRIVATE
+            ${CMAKE_CURRENT_SOURCE_DIR}
+    )
 ENDIF ()
 
+
+IF (MSGPACK_ENABLE_SHARED AND MSGPACK_ENABLE_STATIC)
     ADD_LIBRARY (msgpackc-static STATIC
         ${msgpackc_SOURCES}
         ${msgpackc_HEADERS}
     )
 
+    TARGET_INCLUDE_DIRECTORIES (msgpackc-static
+        PUBLIC
+            $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+            $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
+            $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include/msgpack>
+            $<INSTALL_INTERFACE:include>
+        PRIVATE
+            ${CMAKE_CURRENT_SOURCE_DIR}
+    )
+
     SET_TARGET_PROPERTIES (msgpackc-static PROPERTIES OUTPUT_NAME "msgpackc")
+
     IF (MSGPACK_ENABLE_SHARED)
+        IF (MSVC)
             SET_TARGET_PROPERTIES (msgpackc PROPERTIES IMPORT_SUFFIX "_import.lib")
-    SET_TARGET_PROPERTIES (msgpackc PROPERTIES SOVERSION 2 VERSION 2.0.0)
+        ELSEIF (MINGW)
+            SET_TARGET_PROPERTIES (msgpackc PROPERTIES IMPORT_SUFFIX ".dll.a")
+        ENDIF ()
+    ENDIF ()
+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_C_FLAGS   "${CMAKE_C_FLAGS} ${COVERAGE_FLAGS}")
+
+    SETUP_TARGET_FOR_COVERAGE(coverage make coverage test)
 ENDIF ()
 
 IF (MSGPACK_BUILD_TESTS)
     ENABLE_TESTING ()
+    list(APPEND CMAKE_CTEST_ARGUMENTS "--output-on-failure")
     # 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)
@@ -283,34 +192,50 @@ IF (MSGPACK_BUILD_TESTS)
     ADD_SUBDIRECTORY (test)
 ENDIF ()
 
-IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+IF ("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_C_COMPILER_ID}" STREQUAL "GNU")
-    IF (MSGPACK_ENABLE_SHARED)
+    IF (MSGPACK_ENABLE_SHARED OR MSGPACK_ENABLE_STATIC)
-        SET_PROPERTY (TARGET msgpackc APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Werror -g -O3 -DPIC")
+        SET_PROPERTY (TARGET msgpackc APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra -DPIC")
+    ENDIF ()
+    IF (MSGPACK_ENABLE_SHARED AND MSGPACK_ENABLE_STATIC)
+       SET_PROPERTY (TARGET msgpackc-static APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra" )
     ENDIF ()
-    SET_PROPERTY (TARGET msgpackc-static APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Werror -g -O3" )
 ENDIF ()
 
-IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+IF ("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang")
+    IF (MSGPACK_ENABLE_SHARED OR MSGPACK_ENABLE_STATIC)
         SET_PROPERTY (TARGET msgpackc APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
     ENDIF ()
-
+    IF (MSGPACK_ENABLE_SHARED AND MSGPACK_ENABLE_STATIC)
-IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+        SET_PROPERTY (TARGET msgpackc-static APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
-    IF ((CMAKE_CXX_COMPILER_VERSION VERSION_GREATER ${GNUCXX_NO_MISMATCHED_TAGS_SUPPORT_VERSION}) OR
-        (CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL   ${GNUCXX_NO_MISMATCHED_TAGS_SUPPORT_VERSION}))
-    SET_PROPERTY (TARGET msgpackc APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
     ENDIF ()
 ENDIF ()
 
-IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+IF ("${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC")
-    IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
+    IF (CMAKE_C_FLAGS MATCHES "/W[0-4]")
-        STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+        STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
     ELSE ()
-        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
+        SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W3 /WX")
     ENDIF ()
 ENDIF ()
 
-IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC90" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC10")
+IF ("${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC")
-    SET_SOURCE_FILES_PROPERTIES(${msgpackc_SOURCES} PROPERTIES LANGUAGE CXX)
+    IF (CMAKE_C_FLAGS MATCHES "/W[0-4]")
+        STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+    ELSE ()
+        SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W3 /WX")
+    ENDIF ()
+ENDIF ()
+
+IF ("${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC90" OR "${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC10")
+    SET_SOURCE_FILES_PROPERTIES(${msgpackc_SOURCES} PROPERTIES LANGUAGE C)
+ENDIF ()
+
+IF ("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "sparc")
+    SET (CMAKE_C_FLAGS   "-DMSGPACK_ZONE_ALIGN=8 ${CMAKE_C_FLAGS}")
+ENDIF ()
+
+IF (NOT DEFINED CMAKE_INSTALL_BINDIR)
+    SET(CMAKE_INSTALL_BINDIR bin)
 ENDIF ()
 
 IF (NOT DEFINED CMAKE_INSTALL_LIBDIR)
@@ -321,14 +246,27 @@ IF (MSGPACK_BUILD_EXAMPLES)
     ADD_SUBDIRECTORY (example)
 ENDIF ()
 
-IF (MSGPACK_ENABLE_SHARED)
+IF (MSGPACK_ENABLE_SHARED OR MSGPACK_ENABLE_STATIC)
-    SET (MSGPACK_INSTALLTARGETS msgpackc msgpackc-static)
+    SET (MSGPACK_INSTALLTARGETS msgpackc)
-ELSE()
-    SET (MSGPACK_INSTALLTARGETS msgpackc-static)
 ENDIF ()
 
-INSTALL (TARGETS ${MSGPACK_INSTALLTARGETS} DESTINATION ${CMAKE_INSTALL_LIBDIR})
+IF (MSGPACK_ENABLE_SHARED AND MSGPACK_ENABLE_STATIC)
-INSTALL (DIRECTORY include DESTINATION ${CMAKE_INSTALL_PREFIX})
+    LIST (APPEND MSGPACK_INSTALLTARGETS msgpackc-static)
+ENDIF ()
+
+INSTALL (TARGETS ${MSGPACK_INSTALLTARGETS} EXPORT msgpack-targets
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+)
+FOREACH (file ${msgpackc_common_HEADERS})
+    GET_FILENAME_COMPONENT (dir ${file} PATH)
+    INSTALL (FILES ${file} DESTINATION ${CMAKE_INSTALL_PREFIX}/${dir})
+ENDFOREACH ()
+FOREACH (file ${msgpackc_configured_HEADERS})
+    GET_FILENAME_COMPONENT (dir ${file} PATH)
+    INSTALL (FILES ${CMAKE_CURRENT_BINARY_DIR}/${file} DESTINATION ${CMAKE_INSTALL_PREFIX}/${dir})
+ENDFOREACH ()
 IF (NOT MSVC)
     INSTALL (FILES ${CMAKE_CURRENT_BINARY_DIR}/msgpack.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
 ENDIF ()
@@ -343,6 +281,7 @@ IF (DOXYGEN_FOUND)
         COMMAND ${CMAKE_COMMAND} -E echo "INPUT              = ${CMAKE_CURRENT_SOURCE_DIR}/include" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c
         COMMAND ${CMAKE_COMMAND} -E echo "EXTRACT_ALL        = YES" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c
         COMMAND ${CMAKE_COMMAND} -E echo "PROJECT_NAME       = \"MessagePack for C\"" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c
+        COMMAND ${CMAKE_COMMAND} -E echo "STRIP_FROM_PATH    = ${CMAKE_CURRENT_SOURCE_DIR}/include" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c
     )
     IF (DOXYGEN_DOT_FOUND)
         LIST (APPEND Doxyfile_c_CONTENT
@@ -350,32 +289,45 @@ IF (DOXYGEN_FOUND)
         )
     ENDIF ()
     ADD_CUSTOM_TARGET (
-        doxygen_c
+        doxygen
         ${Doxyfile_c_CONTENT}
         COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c
         VERBATIM
     )
-    LIST (APPEND Doxyfile_cpp_CONTENT
+ENDIF ()
-        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
+INCLUDE (CMakePackageConfigHelpers)
-        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
+SET (CMAKE_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/msgpack")
-        COMMAND ${CMAKE_COMMAND} -E echo "EXTRACT_ALL        = YES" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp
+
+WRITE_BASIC_PACKAGE_VERSION_FILE (
+    msgpack-config-version.cmake
+    VERSION ${VERSION}
+    COMPATIBILITY SameMajorVersion
 )
-    IF (DOXYGEN_DOT_FOUND)
+
-        LIST (APPEND Doxyfile_cpp_CONTENT
+IF (NOT CMAKE_VERSION VERSION_LESS 3.0)
-            COMMAND ${CMAKE_COMMAND} -E echo "HAVE_DOT       = YES" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp
+    EXPORT (EXPORT msgpack-targets
+        FILE "${CMAKE_CURRENT_BINARY_DIR}/msgpack-targets.cmake"
     )
 ENDIF ()
-    ADD_CUSTOM_TARGET (
+
-        doxygen_cpp
+CONFIGURE_PACKAGE_CONFIG_FILE (msgpack-config.cmake.in
-        ${Doxyfile_cpp_CONTENT}
+    msgpack-config.cmake
-        COMMAND ${CMAKE_COMMAND} -E echo "PROJECT_NAME       = \"MessagePack for C++\"" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp
+    INSTALL_DESTINATION "${CMAKE_INSTALL_CMAKEDIR}"
-        COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp
-        VERBATIM
 )
-    ADD_CUSTOM_TARGET (
+
-        doxygen
+INSTALL (EXPORT msgpack-targets
-        DEPENDS doxygen_c doxygen_cpp
+    FILE
+        msgpack-targets.cmake
+    DESTINATION
+        "${CMAKE_INSTALL_CMAKEDIR}"
+)
+
+INSTALL (
+    FILES
+        "${CMAKE_CURRENT_BINARY_DIR}/msgpack-config.cmake"
+        "${CMAKE_CURRENT_BINARY_DIR}/msgpack-config-version.cmake"
+    DESTINATION
+        "${CMAKE_INSTALL_CMAKEDIR}"
 )
-ENDIF ()

Doxyfile

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

Files.cmake

@@ -0,0 +1,41 @@
+# Source files
+SET (msgpackc_SOURCES
+    src/objectc.c
+    src/unpack.c
+    src/version.c
+    src/vrefbuffer.c
+    src/zone.c
+)
+
+# Header files
+SET (msgpackc_common_HEADERS
+    include/msgpack.h
+    include/msgpack/fbuffer.h
+    include/msgpack/gcc_atomic.h
+    include/msgpack/object.h
+    include/msgpack/pack.h
+    include/msgpack/pack_define.h
+    include/msgpack/sbuffer.h
+    include/msgpack/timestamp.h
+    include/msgpack/unpack.h
+    include/msgpack/unpack_define.h
+    include/msgpack/unpack_template.h
+    include/msgpack/util.h
+    include/msgpack/version.h
+    include/msgpack/version_master.h
+    include/msgpack/vrefbuffer.h
+    include/msgpack/zbuffer.h
+    include/msgpack/zone.h
+)
+
+# Header files will configured
+SET (msgpackc_configured_HEADERS
+    include/msgpack/pack_template.h
+    include/msgpack/sysdep.h
+)
+
+# All header files
+LIST (APPEND msgpackc_HEADERS
+    ${msgpackc_common_HEADERS}
+    ${msgpackc_configured_HEADERS}
+)

Makefile.am

@@ -1,20 +0,0 @@
-SUBDIRS = src test
-
-DOC_FILES = \
-		Doxyfile \
-		README.md \
-		LICENSE_1_0.txt \
-		NOTICE \
-		msgpack_vc8.vcproj \
-		msgpack_vc8.sln
-
-EXTRA_DIST = \
-		$(DOC_FILES) CMakeLists.txt test/CMakeLists.txt example
-
-pkgconfigdir = $(libdir)/pkgconfig
-pkgconfig_DATA = msgpack.pc
-
-doxygen:
-	./preprocess clean
-	cd src && $(MAKE) doxygen
-	./preprocess

QUICKSTART-C.md

@@ -6,10 +6,11 @@ Currently, RPC implementation is not available.
 
 # Install
 
+## Install with package manager
 
-## Mac OS X with MacPorts
+### MacOS with MacPorts
 
-On Mac OS X, you can install MessagePack for C using MacPorts.
+On MacOS, you can install MessagePack for C using MacPorts.
 
 ```
 $ sudo port install msgpack
@@ -20,51 +21,47 @@ You might need to run `sudo port selfupdate` before installing to update the pac
 You can also install via Homebrew.
 
 ```
-$ sudo brew install msgpack
+$ brew install msgpack
 ```
 
-## FreeBSD with Ports Collection
+### FreeBSD with Ports Collection
 
-On FreeBSD, you can use Ports Collection. Install [net/msgpack|http://www.freebsd.org/cgi/cvsweb.cgi/ports/devel/msgpack/] package.
+On FreeBSD, you can use Ports Collection. Install [net/msgpack](http://www.freebsd.org/cgi/cvsweb.cgi/ports/devel/msgpack/) package.
 
-## Gentoo Linux with Portage
+### Gentoo Linux with Portage
 
-On Gentoo Linux, you can use emerge. Install [dev-libs/msgpack|http://gentoo-portage.com/dev-libs/msgpack] package.
+On Gentoo Linux, you can use emerge. Install [dev-libs/msgpack](http://gentoo-portage.com/dev-libs/msgpack) package.
 
-## Other UNIX-like platform with ./configure
+### Windows with vcpkg
 
-On the other UNIX-like platforms, download source package from [Releases|http://msgpack.org/releases/cpp/] and run `./configure && make && make install`.
+There are several package managers available, and vcpkg is typical.
 
 ```
-$ wget http://msgpack.org/releases/cpp/msgpack-1.3.0.tar.gz
+$ vcpkg install msgpack:x64-windows
+```
+## Install with source code
+
+### Build with cmake
+
+You need to install cmake (2.8.12 or higher) first.
+
+```
+$ git clone https://github.com/msgpack/msgpack-c.git
+$ cd msgpack-c
+$ mkdir build
+$ cd build
+$ cmake ..
+$ cmake --build .
+$ cmake --build . --target install
+```
+### Build with autotools
+
+In versions 1.4.2 and below, you can use `autotools` to build on UNIX-like platforms.
+```
+$ wget https://github.com/msgpack/msgpack-c/archive/cpp-1.3.0.tar.gz
 $ tar zxvf msgpack-1.3.0.tar.gz
 $ cd msgpack-1.3.0
-$ ./configure
+$ ./bootstrap  # If the 'configure' script already exists, you can omit this step.
-$ make
-$ sudo make install
-```
-
-## Windows
-
-On Windows, download source package from [here|https://sourceforge.net/projects/msgpack/files/] and extract it.
-Then open `msgpack_vc8.vcproj` file and build it using batch build. It builds libraries on `lib/` folder and header files on `include/` folder.
-
-You can build using command line as follows:
-
-```
-> vcbuild msgpack_vc2008.vcproj
-> dir lib       % DLL files are here
-> dir include   % header files are here
-```
-
-## Install from git repository
-
-You need to install gcc (4.1.0 or higher), autotools.
-
-```
-$ git clone git@github.com:msgpack/msgpack.git
-$ cd msgpack/cpp
-$ ./bootstrap
 $ ./configure
 $ make
 $ sudo make install
@@ -96,13 +93,14 @@ int main(void) {
         /* deserializes it. */
         msgpack_unpacked msg;
         msgpack_unpacked_init(&msg);
-        bool success = msgpack_unpack_next(&msg, buffer->data, buffer->size, NULL);
+        msgpack_unpack_return ret = msgpack_unpack_next(&msg, buffer->data, buffer->size, NULL);
 
         /* prints the deserialized object. */
         msgpack_object obj = msg.data;
         msgpack_object_print(stdout, obj);  /*=> ["Hello", "MessagePack"] */
 
         /* cleaning */
+        msgpack_unpacked_destroy(&msg);
         msgpack_sbuffer_free(buffer);
         msgpack_packer_free(pk);
 }
@@ -137,11 +135,12 @@ int main(void) {
            /* deserializes it. */
            msgpack_unpacked msg;
            msgpack_unpacked_init(&msg);
-           bool success = msgpack_unpack_next(&msg, buffer->data, buffer->size, NULL);
+           msgpack_unpack_return ret = msgpack_unpack_next(&msg, buffer->data, buffer->size, NULL);
 
            /* prints the deserialized object. */
            msgpack_object obj = msg.data;
            msgpack_object_print(stdout, obj);  /*=> ["Hello", "MessagePack"] */
+           msgpack_unpacked_destroy(&msg);
            puts("");
         }
 

QUICKSTART-CPP.md

@@ -1,163 +0,0 @@
-# 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 and link `msgpack` library 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::unpacked msg;
-        msgpack::unpack(&msg, sbuf.data(), sbuf.size());
-
-        // print the deserialized object.
-        msgpack::object obj = msg.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 -DMSGPACK_DISABLE_LEGACY_NIL -DMSGPACK_DISABLE_LEGACY_CONVERT hello.cc -o hello
-$ ./hello
-["Hello", "MessagePack"]
-```
-
-See [MSGPACK_DISABLE_LEGACY_NIL](https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_configure#msgpack_disable_legacy_nil-since-140) and [MSGPACK_DISABLE_LEGACY_CONVERT](https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_configure#msgpack_disable_legacy_convert-since-140).
-
-## Streaming feature
-
-```cpp
-#include <msgpack.hpp>
-#include <iostream>
-#include <string>
-
-int main(void) {
-        // 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::unpacked result;
-        while(pac.next(&result)) {
-            std::cout << result.get() << std::endl;
-        }
-
-        // results:
-        // $ g++ -Ipath_to_msgpack/include -DMSGPACK_DISABLE_LEGACY_NIL -DMSGPACK_DISABLE_LEGACY_CONVERT stream.cc -o stream
-        // $ ./stream
-        // "Log message ... 1"
-        // "Log message ... 2"
-        // "Log message ... 3"
-}
-```
-
-See [MSGPACK_DISABLE_LEGACY_NIL](https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_configure#msgpack_disable_legacy_nil-since-140) and [MSGPACK_DISABLE_LEGACY_CONVERT](https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_configure#msgpack_disable_legacy_convert-since-140).
-
-### Streaming into an array or map
-
-```cpp
-#include <msgpack.hpp>
-#include <iostream>
-#include <string>
-
-int main(void) {
-        // 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(void) {
-        std::vector<myclass> vec;
-        // add some elements into vec...
-
-        // you can serialize myclass directly
-        msgpack::sbuffer sbuf;
-        msgpack::pack(sbuf, vec);
-
-        msgpack::unpacked msg;
-        msgpack::unpack(&msg, sbuf.data(), sbuf.size());
-
-        msgpack::object obj = msg.get();
-
-        // you can convert object to myclass directly
-        std::vector<myclass> rvec;
-        obj.convert(rvec);
-}
-```

README.md

@@ -1,9 +1,10 @@
-`msgpack` for C/C++
+`msgpack` for C
 ===================
 
-Version 1.4.0 [![Build Status](https://travis-ci.org/msgpack/msgpack-c.svg?branch=master)](https://travis-ci.org/msgpack/msgpack-c) [![Build status](https://ci.appveyor.com/api/projects/status/8kstcgt79qj123mw/branch/master?svg=true)](https://ci.appveyor.com/project/redboltz/msgpack-c/branch/master)
+Version 4.0.0 [![Build Status](https://github.com/msgpack/msgpack-c/workflows/CI/badge.svg?branch=c_master)](https://github.com/msgpack/msgpack-c/actions) [![Build status](https://ci.appveyor.com/api/projects/status/8kstcgt79qj123mw/branch/c_master?svg=true)](https://ci.appveyor.com/project/redboltz/msgpack-c/branch/c_master)
+[![codecov](https://codecov.io/gh/msgpack/msgpack-c/branch/c_master/graph/badge.svg)](https://codecov.io/gh/msgpack/msgpack-c/branch/c_master)
 
-It's like JSON but small and fast.
+It's like JSON but smaller and faster.
 
 Overview
 --------
@@ -11,14 +12,12 @@ Overview
 [MessagePack](http://msgpack.org/) is an efficient binary serialization
 format, which lets you exchange data among multiple languages like JSON,
 except that it's faster and smaller. Small integers are encoded into a
-single byte while typical short strings require only one extra byte in
+single byte and short strings require only one extra byte in
 addition to the strings themselves.
 
 Example
 -------
 
-In C:
-
 ```c
 #include <msgpack.h>
 #include <stdio.h>
@@ -60,122 +59,39 @@ int main(void)
 
 See [`QUICKSTART-C.md`](./QUICKSTART-C.md) for more details.
 
-In C++:
-
-```c++
-#include <msgpack.hpp>
-#include <string>
-#include <iostream>
-#include <sstream>
-
-int main(void)
-{
-    msgpack::type::tuple<int, bool, std::string> src(1, true, "example");
-
-    // serialize the object into the buffer.
-    // any classes that implements write(const char*,size_t) can be a buffer.
-    std::stringstream buffer;
-    msgpack::pack(buffer, src);
-
-    // send the buffer ...
-    buffer.seekg(0);
-
-    // deserialize the buffer into msgpack::object instance.
-    std::string str(buffer.str());
-
-    msgpack::unpacked result;
-
-    msgpack::unpack(result, str.data(), str.size());
-
-    // deserialized object is valid during the msgpack::unpacked instance alive.
-    msgpack::object deserialized = result.get();
-
-    // msgpack::object supports ostream.
-    std::cout << deserialized << std::endl;
-
-    // convert msgpack::object instance into the original type.
-    // if the type is mismatched, it throws msgpack::type_error exception.
-    msgpack::type::tuple<int, bool, std::string> dst;
-    deserialized.convert(dst);
-
-    return 0;
-}
-```
-
-See [`QUICKSTART-CPP.md`](./QUICKSTART-CPP.md) for more details.
-
 Usage
 -----
 
-### C++ Header Only Library
-
-When you use msgpack on C++03 and C++11, you can just add
-msgpack-c/include to your include path:
-
-    g++ -I msgpack-c/include -DMSGPACK_DISABLE_LEGACY_NIL -DMSGPACK_DISABLE_LEGACY_CONVERT your_source_file.cpp
-
-See [MSGPACK_DISABLE_LEGACY_NIL](https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_configure#msgpack_disable_legacy_nil-since-140) and [MSGPACK_DISABLE_LEGACY_CONVERT](https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_configure#msgpack_disable_legacy_convert-since-140).
-
-If you want to use C version of msgpack, you need to build it. You can
-also install the C and C++ versions of msgpack.
-
 ### Building and Installing
 
 #### Install from git repository
 
-##### Using autotools
+##### Using the Terminal (CLI)
-
-You will need:
-
- - `gcc >= 4.1.0` or `clang >= 3.3.0`
- - `autoconf >= 2.60`
- - `automake >= 1.10`
- - `libtool >= 2.2.4`
-
-The build steps below are for C and C++03. If compiling for C++11,
-add `-std=c++11` to the environmental variable `CXXFLAGS` with
-`export CXXFLAGS="$CXXFLAGS -std=c++11"` prior to following the
-directions below.
-
-```bash
-$ git clone https://github.com/msgpack/msgpack-c
-$ cd msgpack-c
-$ ./bootstrap
-$ ./configure
-$ make
-```
-
-You can install the resulting library like this:
-
-```bash
-$ sudo make install
-```
-##### Using cmake
-
-###### Using the Terminal (CLI)
 
 You will need:
 
  - `gcc >= 4.1.0`
  - `cmake >= 2.8.0`
 
-C and C++03:
+How to build:
 
     $ git clone https://github.com/msgpack/msgpack-c.git
     $ cd msgpack-c
+    $ git checkout c_master
     $ cmake .
     $ make
     $ sudo make install
 
-If you want to setup C++11 version of msgpack instead,
+How to run tests:
-execute the following commands:
 
-    $ git clone https://github.com/msgpack/msgpack-c.git
+In order to run tests you must have the [GoogleTest](https://github.com/google/googletest) framework installed. If you do not currently have it, install it and re-run `cmake`.
-    $ cd msgpack-c
+Then:
-    $ cmake -DMSGPACK_CXX11=ON .
-    $ sudo make install
 
-##### GUI on Windows
+    $ make test
+
+When you use the C part of `msgpack-c`, you need to build and link the library. By default, both static/shared libraries are built. If you want to build only static library, set `BUILD_SHARED_LIBS=OFF` to cmake. If you want to build only shared library, set `BUILD_SHARED_LIBS=ON`.
+
+#### GUI on Windows
 
 Clone msgpack-c git repository.
 
@@ -185,24 +101,26 @@ or using GUI git client.
 
 e.g.) tortoise git https://code.google.com/p/tortoisegit/
 
-1. Launch [cmake GUI client](http://www.cmake.org/cmake/resources/software.html).
+1. Checkout to c_master branch
 
-2. Set 'Where is the source code:' text box and 'Where to build
+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.
 
-3. Click 'Configure' button.
+4. Click 'Configure' button.
 
-4. Choose your Visual Studio version.
+5. Choose your Visual Studio version.
 
-5. Click 'Generate' button.
+6. Click 'Generate' button.
 
-6. Open the created msgpack.sln on Visual Studio.
+7. Open the created msgpack.sln on Visual Studio.
 
-7. Build all.
+8. Build all.
 
 ### Documentation
 
-You can get addtional information on the
+You can get additional information including the tutorial on the
 [wiki](https://github.com/msgpack/msgpack-c/wiki).
 
 Contributing

appveyor.yml

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

bootstrap

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

ci/build_autotools.sh

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

ci/build_cmake.sh

@@ -16,42 +16,16 @@ then
     exit $ret
 fi
 
-if [ $1 = "cpp11" ]
+if [ "${ARCH}" == "32" ]
 then
-    cpp11="-DMSGPACK_CXX11=ON"
+    export BIT32="ON"
+    export ARCH_FLAG="-m32"
 else
-    cpp11=""
+    export BIT32="OFF"
+    export ARCH_FLAG="-m64"
 fi
 
-if [ $2 = "32" ]
+cmake -DMSGPACK_32BIT=${BIT32} -DBUILD_SHARED_LIBS=${SHARED} -DMSGPACK_CHAR_SIGN=${CHAR_SIGN} -DCMAKE_CXX_FLAGS="${ARCH_FLAG} ${CXXFLAGS}" -DCMAKE_C_FLAGS="${CFLAGS}" ..
-then
-    bit32="-DMSGPACK_32BIT=ON"
-else
-    bit32=""
-fi
-
-if [ $3 = "boost" ]
-then
-    boost="-DMSGPACK_BOOST=ON"
-else
-    boost=""
-fi
-
-if [ "$4" != "" ]
-then
-    boost_dir="-DMSGPACK_BOOST_DIR=$4"
-else
-    boost_dir=""
-fi
-
-if [ "$5" = "OFF" ]
-then
-    shared="-DMSGPACK_ENABLE_SHARED=OFF"
-else
-    shared=""
-fi
-
-cmake $cpp11 $bit32 $boost $boost_dir $shared -DMSGPACK_CHAR_SIGN=${CHAR_SIGN} ..
 
 ret=$?
 if [ $ret -ne 0 ]
@@ -67,7 +41,7 @@ then
     exit $ret
 fi
 
-make test
+ctest -VV
 
 ret=$?
 if [ $ret -ne 0 ]
@@ -83,7 +57,7 @@ then
     exit $ret
 fi
 
-if [ "$2" != "32" ]
+if [ "${ARCH}" != "32" ] && [ `uname` = "Linux" ]
 then
     ctest -T memcheck | tee memcheck.log
 
@@ -100,4 +74,39 @@ then
     fi
 fi
 
+if [ "${ARCH}" != "32" ]
+then
+    mkdir install-test
+
+    ret=$?
+    if [ $ret -ne 0 ]
+    then
+        exit $ret
+    fi
+
+    cd install-test
+
+    ret=$?
+    if [ $ret -ne 0 ]
+    then
+        exit $ret
+    fi
+
+    cmake -DCMAKE_PREFIX_PATH=`pwd`/../install/usr/local/lib/cmake ../../example/cmake
+
+    ret=$?
+    if [ $ret -ne 0 ]
+    then
+        exit $ret
+    fi
+
+    make
+
+    ret=$?
+    if [ $ret -ne 0 ]
+    then
+        exit $ret
+    fi
+fi
+
 exit 0

ci/build_cmake_embedded.sh

@@ -0,0 +1,59 @@
+#!/bin/bash
+
+cd example/cmake
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+rm -f msgpack-c
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+ln -s ../.. msgpack-c
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+mkdir build
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+cd build
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+cmake -DEXAMPLE_MSGPACK_EMBEDDED=ON ..
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+make example example-static
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+exit 0

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()

cmake/pack_template.h.in

@@ -8,6 +8,13 @@
  *    http://www.boost.org/LICENSE_1_0.txt)
  */
 
+#ifndef MSGPACK_ENDIAN_BIG_BYTE
+#define MSGPACK_ENDIAN_BIG_BYTE @MSGPACK_ENDIAN_BIG_BYTE@
+#endif
+#ifndef MSGPACK_ENDIAN_LITTLE_BYTE
+#define MSGPACK_ENDIAN_LITTLE_BYTE @MSGPACK_ENDIAN_LITTLE_BYTE@
+#endif
+
 #if MSGPACK_ENDIAN_LITTLE_BYTE
 #define TAKE8_8(d)  ((uint8_t*)&d)[0]
 #define TAKE8_16(d) ((uint8_t*)&d)[0]
@@ -34,6 +41,10 @@
 #error msgpack_pack_append_buffer callback is not defined
 #endif
 
+#if defined(_MSC_VER)
+#   pragma warning(push)
+#   pragma warning(disable : 4204)   /* nonstandard extension used: non-constant aggregate initializer */
+#endif
 
 /*
  * Integer
@@ -834,31 +845,31 @@ msgpack_pack_inline_func(_ext)(msgpack_pack_user x, size_t l, int8_t type)
     case 1: {
         unsigned char buf[2];
         buf[0] = 0xd4;
-        buf[1] = type;
+        buf[1] = (unsigned char)type;
         msgpack_pack_append_buffer(x, buf, 2);
     } break;
     case 2: {
         unsigned char buf[2];
         buf[0] = 0xd5;
-        buf[1] = type;
+        buf[1] = (unsigned char)type;
         msgpack_pack_append_buffer(x, buf, 2);
     } break;
     case 4: {
         unsigned char buf[2];
         buf[0] = 0xd6;
-        buf[1] = type;
+        buf[1] = (unsigned char)type;
         msgpack_pack_append_buffer(x, buf, 2);
     } break;
     case 8: {
         unsigned char buf[2];
         buf[0] = 0xd7;
-        buf[1] = type;
+        buf[1] = (unsigned char)type;
         msgpack_pack_append_buffer(x, buf, 2);
     } break;
     case 16: {
         unsigned char buf[2];
         buf[0] = 0xd8;
-        buf[1] = type;
+        buf[1] = (unsigned char)type;
         msgpack_pack_append_buffer(x, buf, 2);
     } break;
     default:
@@ -866,19 +877,19 @@ msgpack_pack_inline_func(_ext)(msgpack_pack_user x, size_t l, int8_t type)
             unsigned char buf[3];
             buf[0] = 0xc7;
             buf[1] = (unsigned char)l;
-            buf[2] = type;
+            buf[2] = (unsigned char)type;
             msgpack_pack_append_buffer(x, buf, 3);
         } else if(l < 65536) {
             unsigned char buf[4];
             buf[0] = 0xc8;
             _msgpack_store16(&buf[1], l);
-            buf[3] = type;
+            buf[3] = (unsigned char)type;
             msgpack_pack_append_buffer(x, buf, 4);
         } else {
             unsigned char buf[6];
             buf[0] = 0xc9;
             _msgpack_store32(&buf[1], l);
-            buf[5] = type;
+            buf[5] = (unsigned char)type;
             msgpack_pack_append_buffer(x, buf, 6);
         }
         break;
@@ -890,6 +901,34 @@ msgpack_pack_inline_func(_ext_body)(msgpack_pack_user x, const void* b, size_t l
     msgpack_pack_append_buffer(x, (const unsigned char*)b, l);
 }
 
+msgpack_pack_inline_func(_timestamp)(msgpack_pack_user x, const msgpack_timestamp* d)
+{
+    if ((((int64_t)d->tv_sec) >> 34) == 0) {
+        uint64_t data64 = ((uint64_t) d->tv_nsec << 34) | (uint64_t)d->tv_sec;
+        if ((data64 & 0xffffffff00000000L) == 0)   {
+            // timestamp 32
+            char buf[4];
+            uint32_t data32 = (uint32_t)data64;
+            msgpack_pack_ext(x, 4, -1);
+            _msgpack_store32(buf, data32);
+            msgpack_pack_append_buffer(x, buf, 4);
+        } else {
+            // timestamp 64
+            char buf[8];
+            msgpack_pack_ext(x, 8, -1);
+            _msgpack_store64(buf, data64);
+            msgpack_pack_append_buffer(x, buf, 8);
+        }
+    } else  {
+        // timestamp 96
+        char buf[12];
+        _msgpack_store32(&buf[0], d->tv_nsec);
+        _msgpack_store64(&buf[4], d->tv_sec);
+        msgpack_pack_ext(x, 12, -1);
+        msgpack_pack_append_buffer(x, buf, 12);
+    }
+}
+
 #undef msgpack_pack_inline_func
 #undef msgpack_pack_user
 #undef msgpack_pack_append_buffer
@@ -907,3 +946,7 @@ msgpack_pack_inline_func(_ext_body)(msgpack_pack_user x, const void* b, size_t l
 #undef msgpack_pack_real_int16
 #undef msgpack_pack_real_int32
 #undef msgpack_pack_real_int64
+
+#if defined(_MSC_VER)
+#   pragma warning(pop)
+#endif

cmake/sysdep.h.in

@@ -10,19 +10,36 @@
 #ifndef MSGPACK_SYSDEP_H
 #define MSGPACK_SYSDEP_H
 
-#include <msgpack/predef.h>
-
 #include <stdlib.h>
 #include <stddef.h>
+
+#ifndef MSGPACK_ENDIAN_BIG_BYTE
+#define MSGPACK_ENDIAN_BIG_BYTE @MSGPACK_ENDIAN_BIG_BYTE@
+#endif
+#ifndef MSGPACK_ENDIAN_LITTLE_BYTE
+#define MSGPACK_ENDIAN_LITTLE_BYTE @MSGPACK_ENDIAN_LITTLE_BYTE@
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER <= 1800
+#   define snprintf(buf, len, format,...) _snprintf_s(buf, len, _TRUNCATE, format, __VA_ARGS__)
+#endif
+
 #if defined(_MSC_VER) && _MSC_VER < 1600
-    typedef __int8 int8_t;
+    typedef signed __int8 int8_t;
     typedef unsigned __int8 uint8_t;
-    typedef __int16 int16_t;
+    typedef signed __int16 int16_t;
     typedef unsigned __int16 uint16_t;
-    typedef __int32 int32_t;
+    typedef signed __int32 int32_t;
     typedef unsigned __int32 uint32_t;
-    typedef __int64 int64_t;
+    typedef signed __int64 int64_t;
     typedef unsigned __int64 uint64_t;
+#   if defined(_WIN64)
+        typedef signed __int64 intptr_t;
+        typedef unsigned __int64 uintptr_t;
+#   else
+        typedef signed __int32 intptr_t;
+        typedef unsigned __int32 uintptr_t;
+#   endif
 #elif defined(_MSC_VER)  // && _MSC_VER >= 1600
 #   include <stdint.h>
 #else
@@ -39,16 +56,28 @@
 #endif
 
 #ifdef _WIN32
+#   if defined(_KERNEL_MODE)
+#       define _msgpack_atomic_counter_header <ntddk.h>
+#   else
 #       define _msgpack_atomic_counter_header <windows.h>
+#       if !defined(WIN32_LEAN_AND_MEAN)
+#           define WIN32_LEAN_AND_MEAN
+#       endif /* WIN32_LEAN_AND_MEAN */
+#   endif
     typedef long _msgpack_atomic_counter_t;
+#if defined(_AMD64_) || defined(_M_X64) || defined(_M_ARM64)
+#    define _msgpack_sync_decr_and_fetch(ptr) _InterlockedDecrement(ptr)
+#    define _msgpack_sync_incr_and_fetch(ptr) _InterlockedIncrement(ptr)
+#else
 #    define _msgpack_sync_decr_and_fetch(ptr) InterlockedDecrement(ptr)
 #    define _msgpack_sync_incr_and_fetch(ptr) InterlockedIncrement(ptr)
+#endif
 #elif defined(__GNUC__) && ((__GNUC__*10 + __GNUC_MINOR__) < 41)
 
 #   if defined(__cplusplus)
-#       define _msgpack_atomic_counter_header "gcc_atomic.hpp"
+#       define _msgpack_atomic_counter_header "msgpack/gcc_atomic.hpp"
 #   else
-#       define _msgpack_atomic_counter_header "gcc_atomic.h"
+#       define _msgpack_atomic_counter_header "msgpack/gcc_atomic.h"
 #   endif
 
 #else
@@ -69,7 +98,7 @@
 #       endif
 #   endif
 
-#else /* _*/
+#elif defined(unix) || defined(__unix) || defined(__APPLE__) || defined(__OpenBSD__)
 
 #include <arpa/inet.h>  /* __BYTE_ORDER */
 #   if defined(linux)
@@ -78,9 +107,15 @@
 
 #endif
 
+#if !defined(MSGPACK_ENDIAN_LITTLE_BYTE) && !defined(MSGPACK_ENDIAN_BIG_BYTE)
+#include <msgpack/predef/other/endian.h>
+#endif // !defined(MSGPACK_ENDIAN_LITTLE_BYTE) && !defined(MSGPACK_ENDIAN_BIG_BYTE)
+
 #if MSGPACK_ENDIAN_LITTLE_BYTE
 
-#   ifdef _WIN32
+#   if defined(unix) || defined(__unix) || defined(__APPLE__) || defined(__OpenBSD__)
+#       define _msgpack_be16(x) ntohs((uint16_t)x)
+#   else
 #       if defined(ntohs)
 #           define _msgpack_be16(x) ntohs(x)
 #       elif defined(_byteswap_ushort) || (defined(_MSC_VER) && _MSC_VER >= 1400)
@@ -90,11 +125,11 @@
                 ((((uint16_t)x) <<  8) ) | \
                 ((((uint16_t)x) >>  8) ) )
 #        endif
-#   else
-#        define _msgpack_be16(x) ntohs(x)
 #   endif
 
-#   ifdef _WIN32
+#   if defined(unix) || defined(__unix) || defined(__APPLE__) || defined(__OpenBSD__)
+#       define _msgpack_be32(x) ntohl((uint32_t)x)
+#   else
 #       if defined(ntohl)
 #           define _msgpack_be32(x) ntohl(x)
 #       elif defined(_byteswap_ulong) || (defined(_MSC_VER) && _MSC_VER >= 1400)
@@ -106,8 +141,6 @@
                   ((((uint32_t)x) >>  8) & 0x0000ff00U ) | \
                   ((((uint32_t)x) >> 24)               ) )
 #       endif
-#   else
-#        define _msgpack_be32(x) ntohl(x)
 #   endif
 
 #   if defined(_byteswap_uint64) || (defined(_MSC_VER) && _MSC_VER >= 1400)
@@ -140,16 +173,16 @@
 
 #define _msgpack_load16(cast, from, to) do {       \
         memcpy((cast*)(to), (from), sizeof(cast)); \
-        *(to) = _msgpack_be16(*(to));              \
+        *(to) = (cast)_msgpack_be16(*(to));      \
     } while (0);
 
 #define _msgpack_load32(cast, from, to) do {       \
         memcpy((cast*)(to), (from), sizeof(cast)); \
-        *(to) = _msgpack_be32(*(to));              \
+        *(to) = (cast)_msgpack_be32(*(to));        \
     } while (0);
 #define _msgpack_load64(cast, from, to) do {       \
         memcpy((cast*)(to), (from), sizeof(cast)); \
-        *(to) = _msgpack_be64(*(to));              \
+        *(to) = (cast)_msgpack_be64(*(to));        \
     } while (0);
 
 #define _msgpack_store16(to, num) \
@@ -170,12 +203,14 @@
 
 
 #if !defined(__cplusplus) && defined(_MSC_VER)
+#  if !defined(_KERNEL_MODE)
 #    if !defined(FALSE)
 #      define FALSE (0)
 #    endif
 #    if !defined(TRUE)
 #      define TRUE (!FALSE)
 #    endif
+#  endif
 #  if _MSC_VER >= 1800
 #    include <stdbool.h>
 #  else
@@ -186,4 +221,8 @@
 #  define inline __inline
 #endif
 
+#ifdef __APPLE__
+#  include <TargetConditionals.h>
+#endif
+
 #endif /* msgpack/sysdep.h */

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"

configure.in

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

erb/cpp03_define_array.hpp.erb

@@ -1,173 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// 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)
-//
-#ifndef MSGPACK_CPP03_DEFINE_ARRAY_HPP
-#define MSGPACK_CPP03_DEFINE_ARRAY_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/msgpack_tuple.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/object_fwd.hpp"
-
-#define MSGPACK_DEFINE_ARRAY(...) \
-    template <typename Packer> \
-    void msgpack_pack(Packer& pk) const \
-    { \
-        msgpack::type::make_define_array(__VA_ARGS__).msgpack_pack(pk); \
-    } \
-    void msgpack_unpack(msgpack::object const& o) \
-    { \
-        msgpack::type::make_define_array(__VA_ARGS__).msgpack_unpack(o); \
-    }\
-    template <typename MSGPACK_OBJECT> \
-    void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone& z) const \
-    { \
-        msgpack::type::make_define_array(__VA_ARGS__).msgpack_object(o, z); \
-    }
-
-#define MSGPACK_BASE_ARRAY(base) (*const_cast<base *>(static_cast<base const*>(this)))
-
-// MSGPACK_ADD_ENUM must be used in the global namespace.
-#define MSGPACK_ADD_ENUM(enum_name) \
-  namespace msgpack { \
-  /** @cond */ \
-  MSGPACK_API_VERSION_NAMESPACE(v1) { \
-  /** @endcond */ \
-  namespace adaptor { \
-    template<> \
-    struct convert<enum_name> { \
-      msgpack::object const& operator()(msgpack::object const& o, enum_name& v) const {\
-        int tmp; \
-        o >> tmp; \
-        v = static_cast<enum_name>(tmp); \
-        return o; \
-      } \
-    }; \
-    template<> \
-    struct object<enum_name> { \
-      void operator()(msgpack::object& o, const enum_name& v) const {\
-        o << static_cast<int>(v); \
-      } \
-    }; \
-    template<> \
-    struct object_with_zone<enum_name> { \
-      void operator()(msgpack::object::with_zone& o, const enum_name& v) const { \
-        o << static_cast<int>(v); \
-      } \
-    }; \
-    template<> \
-    struct pack<enum_name> { \
-      template <typename Stream> \
-      msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const enum_name& v) const { \
-        return o << static_cast<int>(v); \
-      } \
-    }; \
-  } \
-  /** @cond */ \
-  } \
-  /** @endcond */ \
-  }
-
-namespace msgpack {
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-namespace type {
-
-/// @cond
-<% GENERATION_LIMIT = 31 %>
-template <typename A0 = void<%1.upto(GENERATION_LIMIT+1) {|i|%>, typename A<%=i%> = void<%}%>>
-struct define_array;
-/// @endcond
-
-template <>
-struct define_array<> {
-    typedef define_array<> value_type;
-    typedef tuple<> tuple_type;
-    template <typename Packer>
-    void msgpack_pack(Packer& pk) const
-    {
-        pk.pack_array(0);
-    }
-    void msgpack_unpack(msgpack::object const& o)
-    {
-        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-    }
-    void msgpack_object(msgpack::object* o, msgpack::zone&) const
-    {
-        o->type = msgpack::type::ARRAY;
-        o->via.array.ptr = nullptr;
-        o->via.array.size = 0;
-    }
-};
-
-/// @cond
-<%0.upto(GENERATION_LIMIT) {|i|%>
-template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-struct define_array<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
-    typedef define_array<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> value_type;
-    typedef tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> tuple_type;
-    define_array(A0& _a0<%1.upto(i) {|j|%>, A<%=j%>& _a<%=j%><%}%>) :
-        a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {}
-    template <typename Packer>
-    void msgpack_pack(Packer& pk) const
-    {
-        pk.pack_array(<%=i+1%>);
-        <%0.upto(i) {|j|%>
-        pk.pack(a<%=j%>);<%}%>
-    }
-    void msgpack_unpack(msgpack::object const& o)
-    {
-        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        const size_t size = o.via.array.size;
-        if(size > 0) {
-            msgpack::object *ptr = o.via.array.ptr;
-            switch(size) {
-            default:<%(i).downto(0) {|j|%>
-            case <%=j+1%>: ptr[<%=j%>].convert(a<%=j%>);<%}%>
-            }
-        }
-    }
-    void msgpack_object(msgpack::object* o, msgpack::zone& z) const
-    {
-        o->type = msgpack::type::ARRAY;
-        o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*<%=i+1%>));
-        o->via.array.size = <%=i+1%>;
-        <%0.upto(i) {|j|%>
-        o->via.array.ptr[<%=j%>] = msgpack::object(a<%=j%>, z);<%}%>
-    }
-    <%0.upto(i) {|j|%>
-    A<%=j%>& a<%=j%>;<%}%>
-};
-<%}%>
-/// @endcond
-
-inline define_array<> make_define_array()
-{
-    return define_array<>();
-}
-
-/// @cond
-<%0.upto(GENERATION_LIMIT) {|i|%>
-template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-inline define_array<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_define_array(A0& a0<%1.upto(i) {|j|%>, A<%=j%>& a<%=j%><%}%>)
-{
-    return define_array<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>);
-}
-<%}%>
-/// @endcond
-
-}  // namespace type
-/// @cond
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-}  // namespace msgpack
-
-
-#endif // MSGPACK_CPP03_DEFINE_ARRAY_HPP

erb/cpp03_define_map.hpp.erb

@@ -1,173 +0,0 @@
-//
-// 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_CPP03_DEFINE_MAP_HPP
-#define MSGPACK_CPP03_DEFINE_MAP_HPP
-
-// BOOST_PP_VARIADICS is defined in boost/preprocessor/config/config.hpp
-// http://www.boost.org/libs/preprocessor/doc/ref/variadics.html
-// However, supporting compiler detection is not complete. msgpack-c requires
-// variadic macro arguments support. So BOOST_PP_VARIADICS is defined here explicitly.
-#if !defined(MSGPACK_PP_VARIADICS)
-#define MSGPACK_PP_VARIADICS
-#endif
-
-#include <msgpack/preprocessor.hpp>
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/msgpack_tuple.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/object_fwd.hpp"
-
-#define MSGPACK_DEFINE_MAP_EACH_PROC(r, data, elem) \
-    MSGPACK_PP_IF( \
-        MSGPACK_PP_IS_BEGIN_PARENS(elem), \
-        elem, \
-        (MSGPACK_PP_STRINGIZE(elem))(elem) \
-    )
-
-#define MSGPACK_DEFINE_MAP_IMPL(...) \
-    MSGPACK_PP_SEQ_TO_TUPLE( \
-        MSGPACK_PP_SEQ_FOR_EACH( \
-            MSGPACK_DEFINE_MAP_EACH_PROC, \
-            0, \
-            MSGPACK_PP_VARIADIC_TO_SEQ(__VA_ARGS__) \
-        ) \
-    )
-
-#define MSGPACK_DEFINE_MAP(...) \
-    template <typename Packer> \
-    void msgpack_pack(Packer& pk) const \
-    { \
-        msgpack::type::make_define_map \
-            MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \
-            .msgpack_pack(pk); \
-    } \
-    void msgpack_unpack(msgpack::object const& o) \
-    { \
-        msgpack::type::make_define_map \
-            MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \
-            .msgpack_unpack(o); \
-    }\
-    template <typename MSGPACK_OBJECT> \
-    void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone& z) const \
-    { \
-        msgpack::type::make_define_map \
-            MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \
-            .msgpack_object(o, z); \
-    }
-
-#define MSGPACK_BASE_MAP(base) \
-    (MSGPACK_PP_STRINGIZE(base))(*const_cast<base *>(static_cast<base const*>(this)))
-
-namespace msgpack {
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-namespace type {
-
-/// @cond
-<% GENERATION_LIMIT = 31 %>
-template <typename A0 = void<%1.upto(GENERATION_LIMIT+1) {|i|%>, typename A<%=i%> = void<%}%>>
-struct define_map;
-/// @endcond
-
-template <>
-struct define_map<> {
-    template <typename Packer>
-    void msgpack_pack(Packer& pk) const
-    {
-        pk.pack_map(0);
-    }
-    void msgpack_unpack(msgpack::object const& o) const
-    {
-        if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
-    }
-    void msgpack_object(msgpack::object* o, msgpack::zone&) const
-    {
-        o->type = msgpack::type::MAP;
-        o->via.map.ptr = nullptr;
-        o->via.map.size = 0;
-    }
-};
-
-/// @cond
-<%1.step(GENERATION_LIMIT+1,2) {|i|%>
-template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-struct define_map<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
-    define_map(A0& _a0<%1.upto(i) {|j|%>, A<%=j%>& _a<%=j%><%}%>) :
-        a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {}
-    template <typename Packer>
-    void msgpack_pack(Packer& pk) const
-    {
-        pk.pack_map(<%=(i+1)/2%>);
-        <%0.upto(i) {|j|%>
-        pk.pack(a<%=j%>);<%}%>
-    }
-    void msgpack_unpack(msgpack::object const& o) const
-    {
-        if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
-        std::map<std::string, msgpack::object const*> kvmap;
-        for (uint32_t i = 0; i < o.via.map.size; ++i) {
-            kvmap.insert(
-                std::map<std::string, msgpack::object const*>::value_type(
-                    std::string(
-                        o.via.map.ptr[i].key.via.str.ptr,
-                        o.via.map.ptr[i].key.via.str.size),
-                    &o.via.map.ptr[i].val
-                )
-            );
-        }
-        <%0.step(i,2) {|j|%>
-        {
-            std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a<%=j%>);
-            if (it != kvmap.end()) {
-                it->second->convert(a<%=j+1%>);
-            }
-        }
-        <%}%>
-    }
-    void msgpack_object(msgpack::object* o, msgpack::zone& z) const
-    {
-        o->type = msgpack::type::MAP;
-        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*<%=(i+1)/2%>));
-        o->via.map.size = <%=(i+1)/2%>;
-        <%0.step(i,2) {|j|%>
-        o->via.map.ptr[<%=j/2%>].key = msgpack::object(a<%=j%>, z);
-        o->via.map.ptr[<%=j/2%>].val = msgpack::object(a<%=j+1%>, z);
-        <%}%>
-    }
-    <%0.upto(i) {|j|%>
-    A<%=j%>& a<%=j%>;<%}%>
-};
-<%}%>
-/// @endcond
-
-inline define_map<> make_define_map()
-{
-    return define_map<>();
-}
-
-/// @cond
-<%0.upto(GENERATION_LIMIT) {|i|%>
-template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-inline define_map<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_define_map(A0& a0<%1.upto(i) {|j|%>, A<%=j%>& a<%=j%><%}%>)
-{
-    return define_map<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>);
-}
-<%}%>
-/// @endcond
-
-}  // namespace type
-/// @cond
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-}  // namespace msgpack
-
-#endif // MSGPACK_CPP03_DEFINE_MAP_HPP

erb/cpp03_msgpack_tuple.hpp.erb

@@ -1,238 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2013 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_CPP03_MSGPACK_TUPLE_HPP
-#define MSGPACK_CPP03_MSGPACK_TUPLE_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace type {
-
-// FIXME operator==
-// FIXME operator!=
-<% GENERATION_LIMIT = 31 %>
-
-/// @cond
-template <typename A0 = void<%1.upto(GENERATION_LIMIT+1) {|i|%>, typename A<%=i%> = void<%}%>>
-struct tuple;
-/// @endcond
-
-template <typename Tuple, int N>
-struct tuple_element;
-
-template <typename Tuple, int N>
-struct const_tuple_element;
-
-template <typename T>
-struct tuple_type {
-    typedef T type;
-    typedef T value_type;
-    typedef T& reference;
-    typedef const T& const_reference;
-    typedef const T& transparent_reference;
-};
-
-template <typename T>
-struct tuple_type<T&> {
-    typedef T type;
-    typedef T& value_type;
-    typedef T& reference;
-    typedef const T& const_reference;
-    typedef T& transparent_reference;
-};
-
-template <typename T>
-struct tuple_type<const T&> {
-    typedef T type;
-    typedef T& value_type;
-    typedef T& reference;
-    typedef const T& const_reference;
-    typedef const T& transparent_reference;
-};
-
-/// @cond
-<%0.upto(GENERATION_LIMIT) {|i|%>
-<%0.upto(i) {|j|%>
-template <typename A0<%1.upto(i) {|k|%>, typename A<%=k%><%}%>>
-struct tuple_element<tuple<A0<%1.upto(i) {|k|%>, A<%=k%><%}%>>, <%=j%>> : tuple_type<A<%=j%>> {
-    tuple_element(tuple<A0<%1.upto(i) {|k|%>, A<%=k%> <%}%>>& x) : m_x(x.a<%=j%>) {}
-    typename tuple_type<A<%=j%>>::reference get() { return m_x; }
-    typename tuple_type<A<%=j%>>::const_reference get() const { return m_x; }
-private:
-    typename tuple_type<A<%=j%>>::reference m_x;
-};
-<%}%>
-<%}%>
-
-<%0.upto(GENERATION_LIMIT) {|i|%>
-<%0.upto(i) {|j|%>
-template <typename A0<%1.upto(i) {|k|%>, typename A<%=k%><%}%>>
-struct const_tuple_element<tuple<A0<%1.upto(i) {|k|%>, A<%=k%><%}%>>, <%=j%>> : tuple_type<A<%=j%>> {
-    const_tuple_element(const tuple<A0<%1.upto(i) {|k|%>, A<%=k%><%}%>>& x) : m_x(x.a<%=j%>) {}
-    typename tuple_type<A<%=j%>>::const_reference get() const { return m_x; }
-private:
-    typename tuple_type<A<%=j%>>::const_reference m_x;
-};
-<%}%>
-<%}%>
-/// @endcond
-
-template <>
-struct tuple<> {
-    tuple() {}
-    tuple(msgpack::object const& o) { o.convert(*this); }
-    typedef tuple<> value_type;
-};
-
-/// @cond
-<%0.upto(GENERATION_LIMIT) {|i|%>
-template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-struct tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
-    typedef tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> value_type;
-    tuple() {}
-    tuple(typename tuple_type<A0>::transparent_reference _a0<%1.upto(i) {|j|%>, typename tuple_type<A<%=j%>>::transparent_reference _a<%=j%><%}%>) :
-        a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {}
-    tuple(msgpack::object const& o) { o.convert(*this); }
-    template <int N> typename tuple_element<value_type, N>::reference get()
-        { return tuple_element<value_type, N>(*this).get(); }
-    template <int N> typename const_tuple_element<value_type, N>::const_reference get() const
-        { return const_tuple_element<value_type, N>(*this).get(); }
-    <%0.upto(i) {|j|%>
-    A<%=j%> a<%=j%>;<%}%>
-};
-
-template <int N, typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-inline typename type::tuple_element<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>, N>::reference get(type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& t)
-{ return t.template get<N>(); }
-template <int N, typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-inline typename type::const_tuple_element<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>, N>::const_reference get(type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> const& t)
-{ return t.template get<N>(); }
-<%}%>
-/// @endcond
-
-inline tuple<> make_tuple()
-{
-    return tuple<>();
-}
-
-/// @cond
-<%0.upto(GENERATION_LIMIT) {|i|%>
-template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-inline tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_tuple(typename tuple_type<A0>::transparent_reference a0<%1.upto(i) {|j|%>, typename tuple_type<A<%=j%>>::transparent_reference a<%=j%><%}%>)
-{
-    return tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>);
-}
-<%}%>
-/// @endcond
-
-}  // namespace type
-
-namespace adaptor {
-
-template <>
-struct convert<type::tuple<> > {
-    msgpack::object const& operator()(
-        msgpack::object const& o,
-        type::tuple<>&) const {
-        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        return o;
-    }
-};
-
-/// @cond
-<%0.upto(GENERATION_LIMIT) {|i|%>
-template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-struct convert<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> > {
-    msgpack::object const& operator()(
-        msgpack::object const& o,
-        type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) const {
-        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        if(o.via.array.size < <%=i+1%>) { throw msgpack::type_error(); }
-        <%0.upto(i) {|j|%>
-        // In order to avoid clang++'s invalid warning, msgpack::object:: has been added.
-        o.via.array.ptr[<%=j%>].msgpack::object::convert<typename type::tuple_type<A<%=j%>>::type>(v.template get<<%=j%>>());<%}%>
-        return o;
-    }
-};
-<%}%>
-/// @endcond
-
-template <>
-struct pack<type::tuple<> > {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(
-        msgpack::packer<Stream>& o,
-        const type::tuple<>&) const {
-        o.pack_array(0);
-        return o;
-    }
-};
-
-/// @cond
-<%0.upto(GENERATION_LIMIT) {|i|%>
-template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-struct pack<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> > {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(
-        msgpack::packer<Stream>& o,
-        const type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) const {
-        o.pack_array(<%=i+1%>);
-        <%0.upto(i) {|j|%>
-        o.pack(v.template get<<%=j%>>());<%}%>
-        return o;
-    }
-};
-<%}%>
-/// @endcond
-
-template <>
-struct object_with_zone<type::tuple<> > {
-    void operator()(
-        msgpack::object::with_zone& o,
-        const type::tuple<>&) const {
-        o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = nullptr;
-        o.via.array.size = 0;
-    }
-};
-
-/// @cond
-<%0.upto(GENERATION_LIMIT) {|i|%>
-template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-struct object_with_zone<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> > {
-    void operator()(
-        msgpack::object::with_zone& o,
-        const type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) const {
-        o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*<%=i+1%>));
-        o.via.array.size = <%=i+1%>;
-        <%0.upto(i) {|j|%>
-        o.via.array.ptr[<%=j%>] = msgpack::object(v.template get<<%=j%>>(), o.zone);<%}%>
-    }
-};
-<%}%>
-/// @endcond
-
-} // namespace adaptor
-
-/// @cond
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-}  // namespace msgpack
-
-#endif // MSGPACK_CPP03_MSGPACK_TUPLE_HPP

erb/cpp03_zone.hpp.erb

@@ -1,338 +0,0 @@
-//
-// MessagePack for C++ memory pool
-//
-// Copyright (C) 2008-2010 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)
-//
-#ifndef MSGPACK_CPP03_ZONE_HPP
-#define MSGPACK_CPP03_ZONE_HPP
-
-#include <cstdlib>
-#include <memory>
-#include <vector>
-
-#include "msgpack/versioning.hpp"
-
-#ifndef MSGPACK_ZONE_CHUNK_SIZE
-#define MSGPACK_ZONE_CHUNK_SIZE 8192
-#endif
-
-#ifndef MSGPACK_ZONE_ALIGN
-#define MSGPACK_ZONE_ALIGN sizeof(void*)
-#endif
-
-<% GENERATION_LIMIT = 15 %>
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-class zone {
-    struct finalizer {
-        finalizer(void (*func)(void*), void* data):m_func(func), m_data(data) {}
-        void operator()() { m_func(m_data); }
-        void (*m_func)(void*);
-        void* m_data;
-    };
-    struct finalizer_array {
-        finalizer_array():m_tail(nullptr), m_end(nullptr), m_array(nullptr) {}
-        void call() {
-            finalizer* fin = m_tail;
-            for(; fin != m_array; --fin) (*(fin-1))();
-        }
-        ~finalizer_array() {
-            call();
-            ::free(m_array);
-        }
-        void clear() {
-            call();
-            m_tail = m_array;
-        }
-        void push(void (*func)(void* data), void* data)
-        {
-            finalizer* fin = m_tail;
-
-            if(fin == m_end) {
-                push_expand(func, data);
-                return;
-            }
-
-            fin->m_func = func;
-            fin->m_data = data;
-
-            ++m_tail;
-        }
-        void push_expand(void (*func)(void*), void* data) {
-            const size_t nused = m_end - m_array;
-            size_t nnext;
-            if(nused == 0) {
-                nnext = (sizeof(finalizer) < 72/2) ?
-                    72 / sizeof(finalizer) : 8;
-            } else {
-                nnext = nused * 2;
-            }
-            finalizer* tmp =
-                static_cast<finalizer*>(::realloc(m_array, sizeof(finalizer) * nnext));
-            if(!tmp) {
-                throw std::bad_alloc();
-            }
-            m_array     = tmp;
-            m_end   = tmp + nnext;
-            m_tail  = tmp + nused;
-            new (m_tail) finalizer(func, data);
-
-            ++m_tail;
-        }
-        finalizer* m_tail;
-        finalizer* m_end;
-        finalizer* m_array;
-    };
-    struct chunk {
-        chunk* m_next;
-    };
-    struct chunk_list {
-        chunk_list(size_t chunk_size)
-        {
-            chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + chunk_size));
-            if(!c) {
-                throw std::bad_alloc();
-            }
-
-            m_head = c;
-            m_free = chunk_size;
-            m_ptr  = reinterpret_cast<char*>(c) + sizeof(chunk);
-            c->m_next = nullptr;
-        }
-        ~chunk_list()
-        {
-            chunk* c = m_head;
-            while(c) {
-                chunk* n = c->m_next;
-                ::free(c);
-                c = n;
-            }
-        }
-        void clear(size_t chunk_size)
-        {
-            chunk* c = m_head;
-            while(true) {
-                chunk* n = c->m_next;
-                if(n) {
-                    ::free(c);
-                    c = n;
-                } else {
-                    break;
-                }
-            }
-            m_head->m_next = nullptr;
-            m_free = chunk_size;
-            m_ptr  = reinterpret_cast<char*>(m_head) + sizeof(chunk);
-        }
-        size_t m_free;
-        char* m_ptr;
-        chunk* m_head;
-    };
-    size_t m_chunk_size;
-    chunk_list m_chunk_list;
-    finalizer_array m_finalizer_array;
-
-public:
-    zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE) /* throw() */;
-
-public:
-    void* allocate_align(size_t size, size_t align = MSGPACK_ZONE_ALIGN);
-    void* allocate_no_align(size_t size);
-
-    void push_finalizer(void (*func)(void*), void* data);
-
-    template <typename T>
-    void push_finalizer(msgpack::unique_ptr<T> obj);
-
-    void clear();
-
-    void swap(zone& o);
-    static void* operator new(std::size_t size)
-    {
-        void* p = ::malloc(size);
-        if (!p) throw std::bad_alloc();
-        return p;
-    }
-    static void operator delete(void *p) /* throw() */
-    {
-        ::free(p);
-    }
-    static void* operator new(std::size_t size, void* place) /* throw() */
-    {
-        return ::operator new(size, place);
-    }
-    static void operator delete(void* p, void* place) /* throw() */
-    {
-        ::operator delete(p, place);
-    }
-    /// @cond
-    <%0.upto(GENERATION_LIMIT) {|i|%>
-    template <typename T<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-    T* allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>);
-    <%}%>
-    /// @endcond
-
-private:
-    void undo_allocate(size_t size);
-
-    template <typename T>
-    static void object_destruct(void* obj);
-
-    template <typename T>
-    static void object_delete(void* obj);
-
-    void* allocate_expand(size_t size);
-private:
-    zone(const zone&);
-    zone& operator=(const zone&);
-};
-
-inline zone::zone(size_t chunk_size) /* throw() */ :m_chunk_size(chunk_size), m_chunk_list(m_chunk_size)
-{
-}
-
-inline void* zone::allocate_align(size_t size, size_t align)
-{
-    char* aligned =
-        reinterpret_cast<char*>(
-            reinterpret_cast<size_t>(
-                (m_chunk_list.m_ptr + (align - 1))) / align * align);
-    size_t adjusted_size = size + (aligned - m_chunk_list.m_ptr);
-    if(m_chunk_list.m_free >= adjusted_size) {
-        m_chunk_list.m_free -= adjusted_size;
-        m_chunk_list.m_ptr  += adjusted_size;
-        return aligned;
-    }
-    return reinterpret_cast<char*>(
-        reinterpret_cast<size_t>(
-            allocate_expand(size + (align - 1))) / align * align);
-}
-
-inline void* zone::allocate_no_align(size_t size)
-{
-    if(m_chunk_list.m_free < size) {
-        return allocate_expand(size);
-    }
-
-    char* ptr = m_chunk_list.m_ptr;
-    m_chunk_list.m_free -= size;
-    m_chunk_list.m_ptr  += size;
-
-    return ptr;
-}
-
-inline void* zone::allocate_expand(size_t size)
-{
-    chunk_list* const cl = &m_chunk_list;
-
-    size_t sz = m_chunk_size;
-
-    while(sz < size) {
-        size_t tmp_sz = sz * 2;
-        if (tmp_sz <= sz) {
-            sz = size;
-            break;
-        }
-        sz = tmp_sz;
-    }
-
-    chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + sz));
-    if (!c) throw std::bad_alloc();
-
-    char* ptr = reinterpret_cast<char*>(c) + sizeof(chunk);
-
-    c->m_next  = cl->m_head;
-    cl->m_head = c;
-    cl->m_free = sz - size;
-    cl->m_ptr  = ptr + size;
-
-    return ptr;
-}
-
-inline void zone::push_finalizer(void (*func)(void*), void* data)
-{
-    m_finalizer_array.push(func, data);
-}
-
-template <typename T>
-inline void zone::push_finalizer(msgpack::unique_ptr<T> obj)
-{
-    m_finalizer_array.push(&zone::object_delete<T>, obj.release());
-}
-
-inline void zone::clear()
-{
-    m_finalizer_array.clear();
-    m_chunk_list.clear(m_chunk_size);
-}
-
-inline void zone::swap(zone& o)
-{
-    using std::swap;
-    swap(m_chunk_size, o.m_chunk_size);
-    swap(m_chunk_list, o.m_chunk_list);
-    swap(m_finalizer_array, o.m_finalizer_array);
-}
-
-template <typename T>
-void zone::object_destruct(void* obj)
-{
-    static_cast<T*>(obj)->~T();
-}
-
-template <typename T>
-void zone::object_delete(void* obj)
-{
-    delete static_cast<T*>(obj);
-}
-
-inline void zone::undo_allocate(size_t size)
-{
-    m_chunk_list.m_ptr  -= size;
-    m_chunk_list.m_free += size;
-}
-
-inline std::size_t aligned_size(
-    std::size_t size,
-    std::size_t align = MSGPACK_ZONE_ALIGN) {
-    return (size + align - 1) / align * align;
-}
-
-/// @cond
-<%0.upto(GENERATION_LIMIT) {|i|%>
-template <typename T<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-T* zone::allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>)
-{
-    void* x = allocate_align(sizeof(T));
-    try {
-        m_finalizer_array.push(&zone::object_destruct<T>, x);
-    } catch (...) {
-        undo_allocate(sizeof(T));
-        throw;
-    }
-    try {
-        return new (x) T(<%=(1..i).map{|j|"a#{j}"}.join(', ')%>);
-    } catch (...) {
-        --m_finalizer_array.m_tail;
-        undo_allocate(sizeof(T));
-        throw;
-    }
-}
-<%}%>
-/// @endcond
-
-/// @cond
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-}  // namespace msgpack
-
-#endif // MSGPACK_CPP03_ZONE_HPP

example/CMakeLists.txt

@@ -1,4 +1,44 @@
-ADD_SUBDIRECTORY (c)
+FIND_PACKAGE (cJSON)
-ADD_SUBDIRECTORY (cpp03)
+
-ADD_SUBDIRECTORY (cpp11)
+LIST (APPEND exec_PROGRAMS
-ADD_SUBDIRECTORY (boost)
+    boundary.c
+    lib_buffer_unpack.c
+    simple_c.c
+    speed_test_uint32_array.c
+    speed_test_uint64_array.c
+    user_buffer_unpack.c
+)
+IF (cJSON_FOUND)
+    LIST (APPEND exec_PROGRAMS jsonconv.c)
+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}
+        msgpackc
+    )
+    IF ("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_C_COMPILER_ID}" STREQUAL "GNU")
+        SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra")
+    ENDIF ()
+
+    IF ("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang")
+        SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
+    ENDIF ()
+
+    IF ("${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC")
+        IF (CMAKE_C_FLAGS MATCHES "/W[0-4]")
+            STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+        ELSE ()
+            SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W3 /WX")
+        ENDIF ()
+    ENDIF ()
+ENDFOREACH ()
+
+IF (cJSON_FOUND)
+    TARGET_LINK_LIBRARIES (jsonconv ${CJSON_LIBRARIES})
+    TARGET_INCLUDE_DIRECTORIES(jsonconv PRIVATE ${CJSON_INCLUDE_DIRS})
+ENDIF ()

example/boost/CMakeLists.txt

@@ -1,36 +0,0 @@
-IF (MSGPACK_BOOST)
-    LIST (APPEND exec_PROGRAMS
-        msgpack_variant_capitalize.cpp
-        msgpack_variant_mapbased.cpp
-    )
-ENDIF ()
-
-FOREACH (source_file ${exec_PROGRAMS})
-    GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
-    ADD_EXECUTABLE (
-        ${source_file_we}
-        ${source_file}
-    )
-    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-        SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Werror -g -O3")
-    ENDIF ()
-
-    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-        SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
-    ENDIF ()
-
-    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-        IF ((CMAKE_CXX_COMPILER_VERSION VERSION_GREATER ${GNUCXX_NO_MISMATCHED_TAGS_SUPPORT_VERSION}) OR
-            (CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL   ${GNUCXX_NO_MISMATCHED_TAGS_SUPPORT_VERSION}))
-        SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
-        ENDIF ()
-    ENDIF ()
-
-    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-        IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
-            STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-        ELSE ()
-            SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
-        ENDIF ()
-    ENDIF ()
-ENDFOREACH ()

example/boost/msgpack_variant_capitalize.cpp

@@ -1,94 +0,0 @@
-// 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::unpacked unp1 = msgpack::unpack(ss1.str().data(), ss1.str().size());
-    msgpack::object const& obj1 = unp1.get();
-    std::cout << "Unpacked msgpack object." << std::endl;
-    std::cout << obj1 << std::endl;
-
-    msgpack::type::variant v = obj1.as<msgpack::type::variant>();
-    std::cout << "Applying proc..." << std::endl;
-    boost::apply_visitor(proc(), v);
-
-    std::stringstream ss2;
-    std::cout << "Packing modified object." << std::endl;
-    msgpack::pack(ss2, v);
-    print(ss2.str());
-
-    msgpack::unpacked unp2 = msgpack::unpack(ss2.str().data(), ss2.str().size());
-    msgpack::object const& obj2 = unp2.get();
-    std::cout << "Modified msgpack object." << std::endl;
-    std::cout << obj2 << std::endl;
-}

example/boost/msgpack_variant_mapbased.cpp

@@ -1,92 +0,0 @@
-// 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)
-                v.erase(it++);
-#else  // defined(MSGPACK_USE_CPP03)
-#  if MSGPACK_LIB_STD_CXX
-                it = v.erase(std::multimap<msgpack::type::variant_ref, msgpack::type::variant_ref>::const_iterator(it));
-#  else  // MSGPACK_LIB_STD_CXX
-                it = v.erase(it);
-#  endif // MSGPACK_LIB_STD_CXX
-#endif // defined(MSGPACK_USE_CPP03)
-            }
-            else if (key == "address") {
-                // When you want to append string
-                // "Tokyo" -> "Tokyo, JAPAN"
-                // Use msgpack::type::variant instead of msgpack::type::variant_ref
-                // or do as follows:
-                boost::string_ref const& value = it->second.as_boost_string_ref();
-                it->second = std::string(&value.front(), value.size()) + ", JAPAN";
-                ++it;
-            }
-        }
-    }
-    template <typename T>
-    void operator()(T const&) const {
-        std::cout << "  match others" << std::endl;
-    }
-};
-
-int main() {
-    std::stringstream ss;
-    user u;
-    u.name = "Takatoshi Kondo";
-    u.age = 42;
-    u.address = "Tokyo";
-    msgpack::pack(ss, u);
-
-    msgpack::unpacked unp = msgpack::unpack(ss.str().data(), ss.str().size());
-    msgpack::object const& obj = unp.get();
-    std::cout << "Unpacked msgpack object." << std::endl;
-    std::cout << obj << std::endl;
-    msgpack::type::variant_ref v = obj.as<msgpack::type::variant_ref>();
-    std::cout << "Applying proc..." << std::endl;
-    boost::apply_visitor(proc(), v);
-    msgpack::zone z;
-    std::cout << "Applied msgpack object." << std::endl;
-    std::cout << msgpack::object(v, z) << std::endl;
-}

example/boundary.c

@@ -0,0 +1,296 @@
+/* gcc boundary.c -o boundary -Wconversion -Wpointer-sign */
+#include <msgpack.h>
+#include <stdio.h>
+#include <assert.h>
+
+static inline unsigned char atohex(char a)
+{
+    int x;
+    if (a >= 'a') {
+        x = a - 'a' + 10;
+    } else if (a >= 'A') {
+        x = a - 'A' + 10;
+    } else {
+        x = a - '0';
+    }
+    assert(x >= 0 && x < 16);
+    return (unsigned char)x;
+}
+
+// Return 0 if equal
+static inline int bytesncmp(char *data, const char *bytes, size_t len)
+{
+    size_t n = len >> 1;
+    size_t i = 0;
+    int diff;
+    for (; i < n; i++) {
+        diff = (unsigned char)data[i] - (atohex(bytes[2 * i]) << 4) - atohex(bytes[2 * i + 1]);
+        if (diff != 0) {
+            return diff;
+        }
+    }
+    return 0;
+}
+
+int main()
+{
+    msgpack_sbuffer sbuf;
+    msgpack_packer *x;
+    size_t offset = 0;
+    char data[65536];
+    msgpack_timestamp ts[] = {
+        { 0xFFFFFFFF, 0 },
+        { 0x100000000, 0 },
+        { 0x3FFFFFFFF, 0 },
+        { 0x400000000, 0 },
+        { INT64_MAX, UINT32_MAX }
+    };
+
+#define check_sbuffer(b)                                     \
+    do {                                                     \
+        size_t len = strlen(#b);                             \
+        assert((sbuf.size - offset) * 2 == len);             \
+        assert(bytesncmp(sbuf.data + offset, #b, len) == 0); \
+        offset = sbuf.size;                                  \
+    } while (0)
+
+    msgpack_sbuffer_init(&sbuf);
+    x = msgpack_packer_new(&sbuf, msgpack_sbuffer_write);
+
+    msgpack_pack_fix_uint8(x, 0); check_sbuffer(cc00);          /* cc 00 */
+    msgpack_pack_fix_uint8(x, 0xFF); check_sbuffer(ccff);       /* cc ff */
+    msgpack_pack_fix_uint16(x, 0); check_sbuffer(cd0000);       /* cd 00 00 */
+    msgpack_pack_fix_uint16(x, 0xFFFF); check_sbuffer(cdffff);  /* cd ff ff */
+    msgpack_pack_fix_uint32(x, 0); check_sbuffer(ce00000000);   /* ce 00 00 00 00 */
+    msgpack_pack_fix_uint32(x, 0xFFFFFFFF); check_sbuffer(ceffffffff);  /* ce ff ff ff ff */
+    msgpack_pack_fix_uint64(x, 0); check_sbuffer(cf0000000000000000);   /* cf 00 00 00 00 00 00 00 00 */
+    msgpack_pack_fix_uint64(x, 0xFFFFFFFFFFFFFFFF); check_sbuffer(cfffffffffffffffff);  /* cf ff ff ff ff ff ff ff ff */
+
+    msgpack_pack_uint8(x, 0); check_sbuffer(00);            /* 00 */
+    msgpack_pack_uint8(x, 0x7F); check_sbuffer(7f);         /* 7f */
+    msgpack_pack_uint8(x, 0x80); check_sbuffer(cc80);       /* cc 80 */
+    msgpack_pack_uint8(x, 0xFF); check_sbuffer(ccff);       /* cc ff */
+
+    msgpack_pack_uint16(x, 0); check_sbuffer(00);           /* 00 */
+    msgpack_pack_uint16(x, 0x7F); check_sbuffer(7f);        /* 7f */
+    msgpack_pack_uint16(x, 0x80); check_sbuffer(cc80);      /* cc 80 */
+    msgpack_pack_uint16(x, 0xFF); check_sbuffer(ccff);      /* cc ff */
+    msgpack_pack_uint16(x, 0x100); check_sbuffer(cd0100);   /* cd 01 00 */
+    msgpack_pack_uint16(x, 0xFFFF); check_sbuffer(cdffff);  /* cd ff ff */
+
+    msgpack_pack_uint32(x, 0); check_sbuffer(00);           /* 00 */
+    msgpack_pack_uint32(x, 0x7F); check_sbuffer(7f);        /* 7f */
+    msgpack_pack_uint32(x, 0x80); check_sbuffer(cc80);      /* cc 80 */
+    msgpack_pack_uint32(x, 0xFF); check_sbuffer(ccff);      /* cc ff */
+    msgpack_pack_uint32(x, 0x100); check_sbuffer(cd0100);   /* cd 01 00 */
+    msgpack_pack_uint32(x, 0xFFFF); check_sbuffer(cdffff);  /* cd ff ff */
+    msgpack_pack_uint32(x, 0x10000); check_sbuffer(ce00010000);     /* ce 00 01 00 00 */
+    msgpack_pack_uint32(x, 0xFFFFFFFF); check_sbuffer(ceffffffff);  /* ce ff ff ff ff */
+
+    msgpack_pack_uint64(x, 0); check_sbuffer(00);           /* 00 */
+    msgpack_pack_uint64(x, 0x7F); check_sbuffer(7f);        /* 7f */
+    msgpack_pack_uint64(x, 0x80); check_sbuffer(cc80);      /* cc 80 */
+    msgpack_pack_uint64(x, 0xFF); check_sbuffer(ccff);      /* cc ff */
+    msgpack_pack_uint64(x, 0x100); check_sbuffer(cd0100);   /* cd 01 00 */
+    msgpack_pack_uint64(x, 0xFFFF); check_sbuffer(cdffff);  /* cd ff ff */
+    msgpack_pack_uint64(x, 0x10000); check_sbuffer(ce00010000);     /* ce 00 01 00 00 */
+    msgpack_pack_uint64(x, 0xFFFFFFFF); check_sbuffer(ceffffffff);  /* ce ff ff ff ff */
+    msgpack_pack_uint64(x, 0x100000000); check_sbuffer(cf0000000100000000);         /* cf 00 00 00 01 00 00 00 00 */
+    msgpack_pack_uint64(x, 0xFFFFFFFFFFFFFFFF); check_sbuffer(cfffffffffffffffff);  /* cf ff ff ff ff ff ff ff ff */
+
+    msgpack_pack_fix_int8(x, 0x7F); check_sbuffer(d07f);            /* d0 7f */
+    msgpack_pack_fix_int8(x, -0x7F-1); check_sbuffer(d080);         /* d0 80 */
+    msgpack_pack_fix_int16(x, 0x7FFF); check_sbuffer(d17fff);       /* d1 7f ff */
+    msgpack_pack_fix_int16(x, -0x7FFF-1); check_sbuffer(d18000);    /* d1 80 00 */
+    msgpack_pack_fix_int32(x, 0x7FFFFFFF); check_sbuffer(d27fffffff);       /* d2 7f ff ff ff */
+    msgpack_pack_fix_int32(x, -0x7FFFFFFF-1); check_sbuffer(d280000000);    /* d2 80 00 00 00 */
+    msgpack_pack_fix_int64(x, 0x7FFFFFFFFFFFFFFF); check_sbuffer(d37fffffffffffffff);       /* d3 7f ff ff ff ff ff ff ff */
+    msgpack_pack_fix_int64(x, -0x7FFFFFFFFFFFFFFF-1); check_sbuffer(d38000000000000000);    /* d3 80 00 00 00 00 00 00 00 */
+
+    msgpack_pack_int8(x, -0x7F-1); check_sbuffer(d080);         /* d0 80 */
+    msgpack_pack_int8(x, -0x21); check_sbuffer(d0df);           /* d0 df */
+    msgpack_pack_int8(x, -0x20); check_sbuffer(e0);             /* e0 */
+    msgpack_pack_int8(x, -1); check_sbuffer(ff);                /* ff */
+    msgpack_pack_int8(x, 0); check_sbuffer(00);                 /* 00 */
+    msgpack_pack_int8(x, 0x7F); check_sbuffer(7f);              /* 7f */
+
+    msgpack_pack_int16(x, -0x7FFF-1); check_sbuffer(d18000);    /* d1 80 00 */
+    msgpack_pack_int16(x, -0x81); check_sbuffer(d1ff7f);        /* d1 ff 7f */
+    msgpack_pack_int16(x, -0x80); check_sbuffer(d080);          /* d0 80 */
+    msgpack_pack_int16(x, -0x21); check_sbuffer(d0df);          /* d0 df */
+    msgpack_pack_int16(x, -0x20); check_sbuffer(e0);            /* e0 */
+    msgpack_pack_int16(x, -0x1); check_sbuffer(ff);             /* ff */
+    msgpack_pack_int16(x, 0); check_sbuffer(00);                /* 00 */
+    msgpack_pack_int16(x, 0x7F); check_sbuffer(7f);             /* 7f */
+    msgpack_pack_int16(x, 0x80); check_sbuffer(cc80);           /* cc 80 */
+    msgpack_pack_int16(x, 0xFF); check_sbuffer(ccff);           /* cc ff */
+    msgpack_pack_int16(x, 0x100); check_sbuffer(cd0100);        /* cd 01 00 */
+    msgpack_pack_int16(x, 0x7FFF); check_sbuffer(cd7fff);       /* cd 7f ff */
+
+    msgpack_pack_int32(x, -0x7FFFFFFF-1); check_sbuffer(d280000000);    /* d2 80 00 00 00 */
+    msgpack_pack_int32(x, -0x8001); check_sbuffer(d2ffff7fff);          /* d2 ff ff 7f ff */
+    msgpack_pack_int32(x, -0x8000); check_sbuffer(d18000);              /* d1 80 00 */
+    msgpack_pack_int32(x, -0x81); check_sbuffer(d1ff7f);                /* d1 ff 7f */
+    msgpack_pack_int32(x, -0x80); check_sbuffer(d080);                  /* d0 80 */
+    msgpack_pack_int32(x, -0x21); check_sbuffer(d0df);                  /* d0 df */
+    msgpack_pack_int32(x, -0x20); check_sbuffer(e0);                    /* e0 */
+    msgpack_pack_int32(x, -0x1); check_sbuffer(ff);                     /* ff */
+    msgpack_pack_int32(x, 0); check_sbuffer(00);                        /* 00 */
+    msgpack_pack_int32(x, 0x7F); check_sbuffer(7f);                     /* 7f */
+    msgpack_pack_int32(x, 0x80); check_sbuffer(cc80);                   /* cc 80 */
+    msgpack_pack_int32(x, 0xFF); check_sbuffer(ccff);                   /* cc ff */
+    msgpack_pack_int32(x, 0x100); check_sbuffer(cd0100);                /* cd 01 00 */
+    msgpack_pack_int32(x, 0xFFFF); check_sbuffer(cdffff);               /* cd ff ff */
+    msgpack_pack_int32(x, 0x10000); check_sbuffer(ce00010000);          /* ce 00 01 00 00 */
+    msgpack_pack_int32(x, 0x7FFFFFFF); check_sbuffer(ce7fffffff);       /* ce 7f ff ff ff */
+
+    msgpack_pack_int64(x, -0x7FFFFFFFFFFFFFFF-1); check_sbuffer(d38000000000000000);    /* d3 80 00 00 00 00 00 00 00 */
+    msgpack_pack_int64(x, -((1LL<<31)+1)); check_sbuffer(d3ffffffff7fffffff);   /* d3 ff ff ff ff 7f ff ff ff */
+    msgpack_pack_int64(x, -(1LL<<31)); check_sbuffer(d280000000);               /* d2 80 00 00 00 */
+    msgpack_pack_int64(x, -0x8001); check_sbuffer(d2ffff7fff);                  /* d2 ff ff 7f ff */
+    msgpack_pack_int64(x, -0x8000); check_sbuffer(d18000);                      /* d1 80 00 */
+    msgpack_pack_int64(x, -0x81); check_sbuffer(d1ff7f);                        /* d1 ff 7f */
+    msgpack_pack_int64(x, -0x80); check_sbuffer(d080);                          /* d0 80 */
+    msgpack_pack_int64(x, -0x21); check_sbuffer(d0df);                          /* d0 df */
+    msgpack_pack_int64(x, -0x20); check_sbuffer(e0);                            /* e0 */
+    msgpack_pack_int64(x, -0x1); check_sbuffer(ff);                             /* ff */
+    msgpack_pack_int64(x, 0); check_sbuffer(00);                                /* 00 */
+    msgpack_pack_int64(x, 0x7F); check_sbuffer(7f);                             /* 7f */
+    msgpack_pack_int64(x, 0x80); check_sbuffer(cc80);                           /* cc 80 */
+    msgpack_pack_int64(x, 0xFF); check_sbuffer(ccff);                           /* cc ff */
+    msgpack_pack_int64(x, 0x100); check_sbuffer(cd0100);                        /* cd 01 00 */
+    msgpack_pack_int64(x, 0xFFFF); check_sbuffer(cdffff);                       /* cd ff ff */
+    msgpack_pack_int64(x, 0x10000); check_sbuffer(ce00010000);                  /* ce 00 01 00 00 */
+    msgpack_pack_int64(x, 0xFFFFFFFF); check_sbuffer(ceffffffff);               /* ce ff ff ff ff */
+    msgpack_pack_int64(x, 0x100000000); check_sbuffer(cf0000000100000000);      /* cf 00 00 00 01 00 00 00 00 */
+    msgpack_pack_int64(x, 0x7FFFFFFFFFFFFFFF); check_sbuffer(cf7fffffffffffffff);   /* cf 7f ff ff ff ff ff ff ff */
+
+    msgpack_pack_nil(x);    check_sbuffer(c0);          /* c0 */
+    msgpack_pack_false(x);  check_sbuffer(c2);          /* c2 */
+    msgpack_pack_true(x);   check_sbuffer(c3);          /* c3 */
+
+    msgpack_pack_float(x, 1.0); check_sbuffer(ca3f800000);          /* ca 3f 80 00 00 */
+    msgpack_pack_double(x, 1.0); check_sbuffer(cb3ff0000000000000); /* cb 3f f0 00 00 00 00 00 00 */
+
+    msgpack_pack_unsigned_char(x, UINT8_MAX);       /* same as msgpack_pack_uint8() */
+    msgpack_pack_unsigned_short(x, (unsigned short)UINT64_MAX);
+    msgpack_pack_unsigned_int(x, (unsigned int)UINT64_MAX);
+    msgpack_pack_unsigned_long(x, (unsigned long)UINT64_MAX);
+    msgpack_pack_unsigned_long_long(x, (unsigned long long)UINT64_MAX);
+
+    msgpack_pack_signed_char(x, INT8_MAX);          /* same as msgpack_pack_int8() */
+
+#define check_sbuffer_n(b)                                   \
+    do {                                                     \
+        size_t len = strlen(#b);                             \
+        assert(bytesncmp(sbuf.data + offset, #b, len) == 0); \
+        offset = sbuf.size;                                  \
+    } while (0)
+
+#define fill_str(n) msgpack_pack_str_body(x, data, n)
+
+    offset = sbuf.size;
+    msgpack_pack_str(x, 0); /* "" */ check_sbuffer(a0); /* a0 */
+    msgpack_pack_str(x, 31);
+    fill_str(31); check_sbuffer_n(bf);                  /* bf ... */
+    msgpack_pack_str(x, 32);
+    fill_str(32); check_sbuffer_n(d920);                /* d9 20 ... */
+    msgpack_pack_str(x, 255);
+    fill_str(255); check_sbuffer_n(d9ff);               /* d9 ff ... */
+    msgpack_pack_str(x, 256);
+    fill_str(256); check_sbuffer_n(da0100);             /* da 01 00 ... */
+    msgpack_pack_str(x, 65535);
+    fill_str(65535); check_sbuffer_n(daffff);           /* da ff ff ... */
+    msgpack_pack_str(x, 65536);
+    fill_str(65536); check_sbuffer_n(db00010000);       /* db 00 01 00 00 ... */
+
+#define fill_map(n)                                             \
+    do {                                                        \
+        size_t i = 0;                                           \
+        for (; i < n * 2; i++) { msgpack_pack_int8(x, 0x1); }   \
+    } while (0);
+
+    msgpack_pack_map(x, 0); /* {} */ check_sbuffer(80); /* 80 */
+    msgpack_pack_map(x, 1);
+    fill_map(1); check_sbuffer_n(81);                   /* 81 ... */
+    msgpack_pack_map(x, 15);
+    fill_map(15); check_sbuffer_n(8f);                  /* 8f ... */
+    msgpack_pack_map(x, 16);
+    fill_map(16); check_sbuffer_n(de0010);              /* de 00 10 ... */
+    msgpack_pack_map(x, 65535);
+    fill_map(65535); check_sbuffer_n(deffff);           /* de ff ff ... */
+    msgpack_pack_map(x, 65536);
+    fill_map(65536); check_sbuffer_n(df00010000);       /* df 00 01 00 00 ... */
+
+#define fill_array(n)                                       \
+    do {                                                    \
+        size_t i = 0;                                       \
+        for (; i < n; i++) { msgpack_pack_int8(x, 0x1); }   \
+    } while (0);
+
+    msgpack_pack_array(x, 0); /* [] */ check_sbuffer(90);   /* 90 */
+    msgpack_pack_array(x, 1);
+    fill_array(1); check_sbuffer_n(91);                 /* 91 ... */
+    msgpack_pack_array(x, 15);
+    fill_array(15); check_sbuffer_n(9f);                /* 9f ... */
+    msgpack_pack_array(x, 16);
+    fill_array(16); check_sbuffer_n(dc0010);            /* dc 00 10 ... */
+    msgpack_pack_array(x, 65535);
+    fill_array(65535); check_sbuffer_n(dcffff);         /* dc ff ff ... */
+    msgpack_pack_array(x, 65536);
+    fill_array(65536); check_sbuffer_n(dd00010000);     /* dd 00 01 00 00 ... */
+
+#define fill_bin(n) msgpack_pack_bin_body(x, data, n)
+
+    msgpack_pack_bin(x, 0); check_sbuffer(c400);        /* c4 00 */
+    msgpack_pack_bin(x, 1);
+    fill_bin(1); check_sbuffer_n(c401);                 /* c4 01 ... */
+    msgpack_pack_bin(x, 255);
+    fill_bin(255); check_sbuffer_n(c4ff);               /* c4 ff ... */
+    msgpack_pack_bin(x, 256);
+    fill_bin(256); check_sbuffer_n(c50100);             /* c5 01 00 ... */
+    msgpack_pack_bin(x, 65535);
+    fill_bin(65535); check_sbuffer_n(c5ffff);           /* c5 ff ff ... */
+    msgpack_pack_bin(x, 65536);
+    fill_bin(65536); check_sbuffer_n(c600010000);       /* c6 00 01 00 00 ... */
+
+#define fill_ext(n) msgpack_pack_ext_body(x, data, n)
+
+    msgpack_pack_ext(x, 1, 0x7F);
+    fill_ext(1); check_sbuffer_n(d47f);                 /* d4 7f ... */
+    msgpack_pack_ext(x, 2, 0x7F);
+    fill_ext(2); check_sbuffer_n(d57f);                 /* d5 7f ... */
+    msgpack_pack_ext(x, 4, 0x7F);
+    fill_ext(4); check_sbuffer_n(d67f);                 /* d6 7f ... */
+    msgpack_pack_ext(x, 8, 0x7F);
+    fill_ext(8); check_sbuffer_n(d77f);                 /* d7 7f ... */
+    msgpack_pack_ext(x, 16, 0x7F);
+    fill_ext(16); check_sbuffer_n(d87f);                /* d8 7f ... */
+
+    msgpack_pack_ext(x, 0, 0x7F); check_sbuffer(c7007f); /* c7 00 7f */
+    msgpack_pack_ext(x, 3, 0x7F);
+    fill_ext(3); check_sbuffer_n(c7037f);               /* c7 03 7f */
+    msgpack_pack_ext(x, 5, 0x7F);
+    fill_ext(5); check_sbuffer_n(c7057f);               /* c7 05 7f */
+    msgpack_pack_ext(x, 17, 0x7F);
+    fill_ext(17); check_sbuffer_n(c7117f);              /* c7 11 7f */
+    msgpack_pack_ext(x, 255, 0x7F);
+    fill_ext(255); check_sbuffer_n(c7ff7f);             /* c7 ff 7f ... */
+    msgpack_pack_ext(x, 256, 0x7F);
+    fill_ext(256); check_sbuffer_n(c801007f);           /* c8 01 00 7f ... */
+    msgpack_pack_ext(x, 65535, 0x7F);
+    fill_ext(65535); check_sbuffer_n(c8ffff7f);         /* c8 ff ff 7f ... */
+    msgpack_pack_ext(x, 65536, 0x7F);
+    fill_ext(65536); check_sbuffer_n(c9000100007f);     /* c9 00 01 00 00 7f ... */
+
+    msgpack_pack_timestamp(x, ts); check_sbuffer(d6ffffffffff); /* d6 ff ff ff ff ff */
+    msgpack_pack_timestamp(x, ts + 1); check_sbuffer(d7ff0000000100000000); /* d7 ff 00 00 00 01 00 00 00 00 */
+    msgpack_pack_timestamp(x, ts + 2); check_sbuffer(d7ff00000003ffffffff); /* d7 ff 00 00 00 03 ff ff ff ff */
+    msgpack_pack_timestamp(x, ts + 3); check_sbuffer(c70cff000000000000000400000000);   /* c7 0c ff 00 00 00 00 00 00 00 04 00 00 00 00 */
+    msgpack_pack_timestamp(x, ts + 4); check_sbuffer(c70cffffffffff7fffffffffffffff);   /* c7 0c ff ff ff ff ff 7f ff ff ff ff ff ff ff */
+
+    msgpack_sbuffer_destroy(&sbuf);
+    msgpack_packer_free(x);
+
+    return 0;
+}

example/c/CMakeLists.txt

@@ -1,44 +0,0 @@
-INCLUDE_DIRECTORIES (
-    ../include
-)
-
-LIST (APPEND exec_PROGRAMS
-    lib_buffer_unpack.c
-    simple_c.c
-    speed_test_uint32_array.c
-    speed_test_uint64_array.c
-    user_buffer_unpack.c
-)
-
-FOREACH (source_file ${exec_PROGRAMS})
-    GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
-    ADD_EXECUTABLE (
-        ${source_file_we}
-        ${source_file}
-    )
-    TARGET_LINK_LIBRARIES (${source_file_we}
-        msgpackc
-    )
-    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-        SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Werror -g -O3")
-    ENDIF ()
-
-    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-        SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
-    ENDIF ()
-
-    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-        IF ((CMAKE_CXX_COMPILER_VERSION VERSION_GREATER ${GNUCXX_NO_MISMATCHED_TAGS_SUPPORT_VERSION}) OR
-            (CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL   ${GNUCXX_NO_MISMATCHED_TAGS_SUPPORT_VERSION}))
-        SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
-        ENDIF ()
-    ENDIF ()
-
-    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-        IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
-            STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-        ELSE ()
-            SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
-        ENDIF ()
-    ENDIF ()
-ENDFOREACH ()

example/cmake/CMakeLists.txt

@@ -0,0 +1,17 @@
+cmake_minimum_required (VERSION 3.0)
+project (example)
+
+if(EXAMPLE_MSGPACK_EMBEDDED)
+    add_subdirectory(msgpack-c)
+    set(msgpack_DIR ${CMAKE_CURRENT_BINARY_DIR}/msgpack-c)
+endif()
+
+find_package(msgpack REQUIRED)
+
+add_executable (${PROJECT_NAME} ${CMAKE_CURRENT_LIST_DIR}/../simple_c.c)
+target_link_libraries(${PROJECT_NAME} msgpackc)
+
+if(TARGET msgpackc-static)
+    add_executable (${PROJECT_NAME}-static ${CMAKE_CURRENT_LIST_DIR}/../simple_c.c)
+    target_link_libraries(${PROJECT_NAME}-static msgpackc-static)
+endif()

example/cpp03/CMakeLists.txt

@@ -1,112 +0,0 @@
-LIST (APPEND exec_PROGRAMS
-    class_intrusive.cpp
-    class_intrusive_map.cpp
-    class_non_intrusive.cpp
-    custom.cpp
-    enum.cpp
-    map_based_versionup.cpp
-    protocol.cpp
-    protocol_new.cpp
-    reuse_zone.cpp
-    simple.cpp
-)
-
-IF (NOT MSVC)
-    LIST (APPEND with_pthread_PROGRAMS
-        stream.cpp
-    )
-ENDIF ()
-
-IF (MSGPACK_BOOST)
-    IF (NOT MSVC)
-        LIST (APPEND with_boost_lib_PROGRAMS
-            speed_test.cpp
-            speed_test_nested_array.cpp
-        )
-    ENDIF ()
-ENDIF ()
-
-FOREACH (source_file ${exec_PROGRAMS})
-    GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
-    ADD_EXECUTABLE (
-        ${source_file_we}
-        ${source_file}
-    )
-    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-        SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Werror -g -O3")
-    ENDIF ()
-    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-        IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
-            STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-        ELSE ()
-            SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
-        ENDIF ()
-    ENDIF ()
-ENDFOREACH ()
-
-FOREACH (source_file ${with_pthread_PROGRAMS})
-    GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
-    ADD_EXECUTABLE (
-        ${source_file_we}
-        ${source_file}
-    )
-    TARGET_LINK_LIBRARIES (${source_file_we}
-        pthread
-    )
-    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-        SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Werror -g -O3 -pthread")
-    ENDIF ()
-    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-        IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
-            STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-        ELSE ()
-            SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
-        ENDIF ()
-    ENDIF ()
-ENDFOREACH ()
-
-FOREACH (source_file ${with_boost_lib_PROGRAMS})
-    INCLUDE_DIRECTORIES (
-        ../include
-        ${Boost_INCLUDE_DIRS}
-    )
-    GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
-    ADD_EXECUTABLE (
-        ${source_file_we}
-        ${source_file}
-    )
-    LINK_DIRECTORIES(${Boost_LIBRARY_DIRS})
-    TARGET_LINK_LIBRARIES (${source_file_we}
-        ${Boost_TIMER_LIBRARY}
-        ${Boost_CHRONO_LIBRARY}
-        ${Boost_SYSTEM_LIBRARY}
-    )
-    IF (NOT MSVC AND NOT APPLE)
-        TARGET_LINK_LIBRARIES (${source_file_we}
-            rt
-        )
-    ENDIF ()
-
-    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-        SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Werror -O3")
-    ENDIF ()
-
-    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-        SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
-    ENDIF ()
-
-    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-        IF ((CMAKE_CXX_COMPILER_VERSION VERSION_GREATER ${GNUCXX_NO_MISMATCHED_TAGS_SUPPORT_VERSION}) OR
-            (CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL   ${GNUCXX_NO_MISMATCHED_TAGS_SUPPORT_VERSION}))
-        SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
-        ENDIF ()
-    ENDIF ()
-
-    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-        IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
-            STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-        ELSE ()
-            SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
-        ENDIF ()
-    ENDIF ()
-ENDFOREACH ()

example/cpp03/class_intrusive.cpp

@@ -1,103 +0,0 @@
-// MessagePack for C++ example
-//
-// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi
-//
-//    Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//    http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <string>
-#include <iostream>
-#include <iomanip>
-#include <sstream>
-#include <cassert>
-
-// When you want to adapt map instead of array, you can enable these macro definition.
-//
-// #define MSGPACK_USE_DEFINE_MAP
-
-
-#include <msgpack.hpp>
-
-struct my_base1 {
-    int a;
-    MSGPACK_DEFINE(a);
-};
-inline bool operator==(my_base1 const& lhs, my_base1 const& rhs) {
-    return lhs.a == rhs.a;
-}
-
-struct my_base2 {
-    std::string b;
-    std::string c;
-    MSGPACK_DEFINE(b, c);
-};
-inline bool operator==(my_base2 const& lhs, my_base2 const& rhs) {
-    return lhs.b == rhs.b && lhs.c == rhs.c;
-}
-
-class my_class : public my_base1, private my_base2 {
-public:
-    my_class() {} // When you want to convert from msgpack::object to my_class,
-                  // my_class should be default constractible.
-    my_class(std::string const& name, int age):name_(name), age_(age) {}
-    void set_b(std::string const& str) { b = str; }
-    void set_c(std::string const& str) { c = str; }
-    friend bool operator==(my_class const& lhs, my_class const& rhs) {
-        return
-            static_cast<my_base1 const&>(lhs) == static_cast<my_base1 const&>(rhs) &&
-            static_cast<my_base2 const&>(lhs) == static_cast<my_base2 const&>(rhs) &&
-            lhs.name_ == rhs.name_ && lhs.age_ == rhs.age_;
-    }
-
-private:
-    std::string name_;
-    int age_;
-
-public:
-    MSGPACK_DEFINE(name_, age_, MSGPACK_BASE(my_base1), MSGPACK_BASE(my_base2));
-};
-
-void print(std::string const& buf) {
-    for (std::string::const_iterator it = buf.begin(), end = buf.end();
-         it != end;
-         ++it) {
-        std::cout
-            << std::setw(2)
-            << std::hex
-            << std::setfill('0')
-            << (static_cast<int>(*it) & 0xff)
-            << ' ';
-    }
-    std::cout << std::dec << std::endl;
-}
-
-int main() {
-    {   // pack, unpack
-        my_class my("John Smith", 42);
-        my.a = 123;
-        my.set_b("ABC");
-        my.set_c("DEF");
-        std::stringstream ss;
-        msgpack::pack(ss, my);
-
-        print(ss.str());
-
-        msgpack::unpacked unp;
-        msgpack::unpack(unp, ss.str().data(), ss.str().size());
-        msgpack::object obj = unp.get();
-        std::cout << obj << std::endl;
-        assert(obj.as<my_class>() == my);
-    }
-    {   // create object with zone
-        my_class my("John Smith", 42);
-        my.a = 123;
-        my.set_b("ABC");
-        my.set_c("DEF");
-        msgpack::zone z;
-        msgpack::object obj(my, z);
-        std::cout << obj << std::endl;
-        assert(obj.as<my_class>() == my);
-    }
-}

example/cpp03/class_intrusive_map.cpp

@@ -1,75 +0,0 @@
-// MessagePack for C++ example
-//
-// Copyright (C) 2015 KONDO Takatoshi
-//
-//    Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//    http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <string>
-#include <iostream>
-#include <iomanip>
-#include <sstream>
-#include <cassert>
-
-#include <msgpack.hpp>
-
-
-class my_class {
-public:
-    my_class() {} // When you want to convert from msgpack::object to my_class,
-                  // my_class should be default constractible.
-                  // If you use C++11, you can adapt non-default constructible
-                  // classes to msgpack::object.
-                  // See https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_adaptor#non-default-constructible-class-support-c11-only
-    my_class(std::string const& name, int age):name_(name), age_(age) {}
-
-    friend bool operator==(my_class const& lhs, my_class const& rhs) {
-        return lhs.name_ == rhs.name_ && lhs.age_ == rhs.age_;
-    }
-
-private:
-    std::string name_;
-    int age_;
-
-public:
-    MSGPACK_DEFINE_MAP(name_, age_);
-};
-
-void print(std::string const& buf) {
-    for (std::string::const_iterator it = buf.begin(), end = buf.end();
-         it != end;
-         ++it) {
-        std::cout
-            << std::setw(2)
-            << std::hex
-            << std::setfill('0')
-            << (static_cast<int>(*it) & 0xff)
-            << ' ';
-    }
-    std::cout << std::dec << std::endl;
-}
-
-int main() {
-    {   // pack, unpack
-        my_class my("John Smith", 42);
-        std::stringstream ss;
-        msgpack::pack(ss, my);
-
-        print(ss.str());
-
-        msgpack::unpacked unp;
-        msgpack::unpack(unp, ss.str().data(), ss.str().size());
-        msgpack::object obj = unp.get();
-        std::cout << obj << std::endl;
-        assert(obj.as<my_class>() == my);
-    }
-    {   // create object with zone
-        my_class my("John Smith", 42);
-        msgpack::zone z;
-        msgpack::object obj(my, z);
-        std::cout << obj << std::endl;
-        assert(obj.as<my_class>() == my);
-    }
-}

example/cpp03/class_non_intrusive.cpp

@@ -1,118 +0,0 @@
-// 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));
-        o.via.array.ptr[0] = msgpack::object(v.get_name(), o.zone);
-        o.via.array.ptr[1] = msgpack::object(v.get_age(), o.zone);
-    }
-};
-
-} // namespace adaptor
-} // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
-} // namespace msgpack
-
-
-void print(std::string const& buf) {
-    for (std::string::const_iterator it = buf.begin(), end = buf.end();
-         it != end;
-         ++it) {
-        std::cout
-            << std::setw(2)
-            << std::hex
-            << std::setfill('0')
-            << (static_cast<int>(*it) & 0xff)
-            << ' ';
-    }
-    std::cout << std::dec << std::endl;
-}
-
-int main() {
-    {   // pack, unpack
-        my_class my("John Smith", 42);
-        std::stringstream ss;
-        msgpack::pack(ss, my);
-
-        print(ss.str());
-
-        msgpack::unpacked unp;
-        msgpack::unpack(unp, ss.str().data(), ss.str().size());
-        msgpack::object obj = unp.get();
-        std::cout << obj << std::endl;
-        assert(obj.as<my_class>() == my);
-    }
-    {   // create object with zone
-        my_class my("John Smith", 42);
-        msgpack::zone z;
-        msgpack::object obj(my, z);
-        std::cout << obj << std::endl;
-        assert(obj.as<my_class>() == my);
-    }
-}

example/cpp03/custom.cpp

@@ -1,67 +0,0 @@
-// 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::unpacked result;
-        msgpack::unpack(result, sbuf.str().data(), sbuf.str().size());
-        msgpack::object obj = result.get();
-
-        obj.convert(nc);
-
-        std::cout << obj << " value=" << nc.value << " flag=" << nc.flag << std::endl;
-    }
-
-    {
-        new_class nc;
-        old_class oc;
-
-        std::stringstream sbuf;
-        msgpack::pack(sbuf, nc);
-
-        msgpack::unpacked result;
-        msgpack::unpack(result, sbuf.str().data(), sbuf.str().size());
-        msgpack::object obj = result.get();
-
-        obj.convert(oc);
-
-        std::cout << obj << " value=" << oc.value << std::endl;
-    }
-}

example/cpp03/enum.cpp

@@ -1,59 +0,0 @@
-// 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::unpacked result;
-        std::size_t off = 0;
-
-        msgpack::unpack(result, sbuf.str().data(), sbuf.str().size(), off);
-        std::cout << result.get().as<my_enum>() << std::endl;
-        assert(result.get().as<my_enum>() == elem1);
-
-        msgpack::unpack(result, sbuf.str().data(), sbuf.str().size(), off);
-        std::cout << result.get().as<my_enum>() << std::endl;
-        assert(result.get().as<my_enum>() == elem2);
-
-        msgpack::unpack(result, sbuf.str().data(), sbuf.str().size(), off);
-        std::cout << result.get().as<my_enum>() << std::endl;
-        assert(result.get().as<my_enum>() == elem3);
-    }
-    {   // create object without zone
-        msgpack::object obj(elem2);
-        std::cout << obj.as<my_enum>() << std::endl;
-        assert(obj.as<my_enum>() == elem2);
-    }
-    {   // create object with zone
-        msgpack::zone z;
-        msgpack::object objz(elem3, z);
-        std::cout << objz.as<my_enum>() << std::endl;
-        assert(objz.as<my_enum>() == elem3);
-    }
-}

example/cpp03/map_based_versionup.cpp

@@ -1,111 +0,0 @@
-// MessagePack for C++ example
-//
-// Copyright (C) 2015 KONDO Takatoshi
-//
-//    Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//    http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <string>
-#include <iostream>
-#include <iomanip>
-#include <sstream>
-#include <cassert>
-
-#include <msgpack.hpp>
-
-struct base1 {
-    base1():a("default") {}
-    std::string a;
-    MSGPACK_DEFINE_MAP(a);
-};
-
-struct v1 : base1 {
-    v1():name("default"), age(0) {}
-    std::string name;
-    int age;
-    MSGPACK_DEFINE_MAP(MSGPACK_BASE_MAP(base1), name, age);
-};
-
-struct base2 {
-    base2():a("default") {}
-    std::string a;
-    MSGPACK_DEFINE_MAP(a);
-};
-
-// Removed: base1, name
-// Added  : base2, address
-struct v2 : base2 {
-    v2(): age(0), address("default") {}
-    int age;
-    std::string address;
-    MSGPACK_DEFINE_MAP(MSGPACK_BASE_MAP(base2), age, address);
-};
-
-// The member variable "age" is in common between v1 and v2.
-
-void print(std::string const& buf) {
-    for (std::string::const_iterator it = buf.begin(), end = buf.end();
-         it != end;
-         ++it) {
-        std::cout
-            << std::setw(2)
-            << std::hex
-            << std::setfill('0')
-            << (static_cast<int>(*it) & 0xff)
-            << ' ';
-    }
-    std::cout << std::dec << std::endl;
-}
-
-int main() {
-    { // pack v1, unpack, convert to v2
-        v1 v;
-        v.a = "ABC";
-        v.name = "John Smith";
-        v.age = 35;
-
-        std::stringstream ss;
-        msgpack::pack(ss, v);
-
-        print(ss.str());
-
-        msgpack::unpacked unp = msgpack::unpack(ss.str().data(), ss.str().size());
-
-        msgpack::object obj = unp.get();
-        std::cout << obj << std::endl;
-
-        v2 newv = obj.as<v2>();
-
-        std::cout << "v2::a       " << newv.a << std::endl;
-        std::cout << "v2::age     " << newv.age << std::endl;
-        std::cout << "v2::address " << newv.address << std::endl;
-
-        // "age" is set from v1
-        assert(newv.a == "default");
-        assert(newv.age == 35);
-        assert(newv.address == "default");
-    }
-    { // create v2 object with zone, convert to v1
-        v2 v;
-        v.a = "DEF";
-        v.age = 42;
-        v.address = "Tokyo";
-
-        msgpack::zone z;
-        msgpack::object obj(v, z);
-        std::cout << obj << std::endl;
-
-        v1 newv = obj.as<v1>();
-
-        std::cout << "v1::a       " << newv.a << std::endl;
-        std::cout << "v1::name    " << newv.name << std::endl;
-        std::cout << "v1::age     " << newv.age << std::endl;
-
-        // "age" is set from v2
-        assert(newv.a == "default");
-        assert(newv.name == "default");
-        assert(newv.age == 42);
-    }
-}

example/cpp03/protocol.cpp

@@ -1,97 +0,0 @@
-// 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::unpacked result;
-        msgpack::unpack(result, buffer.data(), buffer.size());
-        msgpack::object o = result.get();
-
-        myprotocol::Get req;
-        o.convert(req);
-        std::cout << "received: " << o << std::endl;
-    }
-
-
-    stream.str("");
-
-
-    // send MultiGet request
-    {
-        myprotocol::MultiGet req;
-        req.push_back( myprotocol::Get(1, "key1") );
-        req.push_back( myprotocol::Get(2, "key2") );
-        req.push_back( myprotocol::Get(3, "key3") );
-        msgpack::pack(stream, req);
-    }
-
-    stream.seekg(0);
-
-    // receive MultiGet request
-    {
-        std::string buffer(stream.str());
-
-        msgpack::unpacked result;
-        msgpack::unpack(result, buffer.data(), buffer.size());
-        msgpack::object o = result.get();
-
-
-        myprotocol::MultiGet req;
-        o.convert(req);
-        std::cout << "received: " << o << std::endl;
-    }
-}

example/cpp03/protocol_new.cpp

@@ -1,84 +0,0 @@
-// 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::unpacked result;
-        msgpack::unpack(result, buffer.data(), buffer.size());
-        msgpack::object o = result.get();
-
-        myprotocol::Get req;
-        o.convert(req);
-        std::cout << "received: " << o << std::endl;
-    }
-
-
-    stream.str("");
-
-
-    // send MultiGet request
-    {
-        myprotocol::MultiGet req;
-        req.push_back( myprotocol::Get(1, "key1") );
-        req.push_back( myprotocol::Get(2, "key2") );
-        req.push_back( myprotocol::Get(3, "key3") );
-        msgpack::pack(stream, req);
-    }
-
-    stream.seekg(0);
-
-    // receive MultiGet request
-    {
-        std::string buffer(stream.str());
-
-        msgpack::unpacked result;
-        msgpack::unpack(result, buffer.data(), buffer.size());
-        msgpack::object o = result.get();
-
-
-        myprotocol::MultiGet req;
-        o.convert(req);
-        std::cout << "received: " << o << std::endl;
-    }
-}

example/cpp03/reuse_zone.cpp

@@ -1,42 +0,0 @@
-// MessagePack for C++ example
-//
-// Copyright (C) 2015 KONDO Takatoshi
-//
-//    Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//    http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <iostream>
-#include <sstream>
-#include <cassert>
-
-#include <string>
-#include <vector>
-
-#include <msgpack.hpp>
-
-
-int main() {
-    std::vector<int> v;
-    v.push_back(1);
-    v.push_back(42);
-    std::string s("ABC");
-
-    std::stringstream ss;
-    msgpack::pack(ss, v);
-    msgpack::pack(ss, s);
-
-    msgpack::zone z;
-    std::size_t offset = 0;
-
-    // msgpack array is constructed on z.
-    msgpack::object obj = msgpack::unpack(z, ss.str().data(), ss.str().size(), offset);
-    std::cout << obj << std::endl;
-    assert(obj.as<std::vector<int> >() == v);
-
-    // msgpack str is constructed on z.
-    std::string const& str = msgpack::unpack(z, ss.str().data(), ss.str().size(), offset).as<std::string>();
-    std::cout << str << std::endl;
-    assert(str == s);
-}

example/cpp03/simple.cpp

@@ -1,46 +0,0 @@
-// 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::unpacked result;
-
-    msgpack::unpack(result, str.data(), str.size());
-
-    // deserialized object is valid during the msgpack::unpacked instance alive.
-    msgpack::object deserialized = result.get();
-
-    // msgpack::object supports ostream.
-    std::cout << deserialized << std::endl;
-
-    // convert msgpack::object instance into the original type.
-    // if the type is mismatched, it throws msgpack::type_error exception.
-    msgpack::type::tuple<int, bool, std::string> dst;
-    deserialized.convert(dst);
-
-    return 0;
-}

example/cpp03/speed_test.cpp

@@ -1,63 +0,0 @@
-// 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::unpacked unpacked;
-    std::cout << "Start unpacking...by void unpack(unpacked& result, const char* data, size_t len)" << std::endl;
-    {
-        boost::timer::cpu_timer timer;
-        msgpack::unpack(unpacked, str.data(), str.size());
-        std::string result = timer.format();
-        std::cout << result << std::endl;
-    }
-    std::cout << "Unpack finished..." << std::endl;
-    std::map<int, int> m2;
-    std::cout << "Start converting..." << std::endl;
-    {
-        boost::timer::cpu_timer timer;
-        unpacked.get().convert(m2);
-        std::string result = timer.format();
-        std::cout << result << std::endl;
-    }
-    std::cout << "Convert finished..." << std::endl;
-}
-
-int main(void)
-{
-    test_map_pack_unpack();
-}

example/cpp03/speed_test_nested_array.cpp

@@ -1,86 +0,0 @@
-// 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::unpacked unpacked;
-    std::cout << "Start unpacking...by void unpack(unpacked& result, const char* data, size_t len)" << std::endl;
-    {
-        boost::timer::cpu_timer timer;
-        msgpack::unpack(unpacked, str.data(), str.size());
-        std::string result = timer.format();
-        std::cout << result << std::endl;
-    }
-    std::cout << "Unpack finished..." << std::endl;
-    vecvec<int, depth>::type v2;
-    std::cout << "Start converting..." << std::endl;
-    {
-        boost::timer::cpu_timer timer;
-        unpacked.get().convert(v2);
-        std::string result = timer.format();
-        std::cout << result << std::endl;
-    }
-    std::cout << "Convert finished..." << std::endl;
-}
-
-int main(void)
-{
-    test_array_of_array();
-}

example/cpp03/stream.cpp

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

example/cpp11/CMakeLists.txt

@@ -1,40 +0,0 @@
-IF (MSGPACK_CXX11)
-    INCLUDE_DIRECTORIES (
-        ../include
-    )
-
-    LIST (APPEND exec_PROGRAMS
-        container.cpp
-        non_def_con_class.cpp
-    )
-
-    FOREACH (source_file ${exec_PROGRAMS})
-        GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
-        ADD_EXECUTABLE (
-            ${source_file_we}
-            ${source_file}
-        )
-        IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-            SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Werror -g -O3 ")
-        ENDIF ()
-
-        IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-            SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
-        ENDIF ()
-
-        IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-            IF ((CMAKE_CXX_COMPILER_VERSION VERSION_GREATER ${GNUCXX_NO_MISMATCHED_TAGS_SUPPORT_VERSION}) OR
-                (CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL   ${GNUCXX_NO_MISMATCHED_TAGS_SUPPORT_VERSION}))
-            SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
-            ENDIF ()
-        ENDIF ()
-
-        IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-            IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
-                STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-            ELSE ()
-                SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
-            ENDIF ()
-        ENDIF ()
-    ENDFOREACH ()
-ENDIF ()

example/cpp11/container.cpp

@@ -1,149 +0,0 @@
-// MessagePack for C++ example
-//
-// Copyright (C) 2015 KONDO Takatoshi
-//
-//    Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//    http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <iostream>
-#include <sstream>
-#include <cassert>
-
-#include <array>
-#include <tuple>
-#include <unordered_map>
-#include <unordered_set>
-#include <forward_list>
-#include <string>
-
-#include <msgpack.hpp>
-
-void array() {
-    std::array<int, 5> a { { 1, 2, 3, 4, 5 } };
-    std::stringstream ss;
-    msgpack::pack(ss, a);
-
-    msgpack::unpacked und = msgpack::unpack(ss.str().data(), ss.str().size());
-    msgpack::object obj = und.get();
-
-    std::cout << obj << std::endl;
-    assert((obj.as<std::array<int, 5>>()) == a);
-}
-
-void tuple() {
-    std::tuple<bool, std::string, int> t(true, "ABC", 42);
-    std::stringstream ss;
-    msgpack::pack(ss, t);
-
-    auto und = msgpack::unpack(ss.str().data(), ss.str().size());
-    auto obj = und.get();
-
-    std::cout << obj << std::endl;
-    assert(obj.as<decltype(t)>() == t);
-}
-
-void unordered_map() {
-    std::unordered_map<std::string, int> m { {"ABC", 1}, {"DEF", 3} };
-    std::stringstream ss;
-    msgpack::pack(ss, m);
-
-    auto und = msgpack::unpack(ss.str().data(), ss.str().size());
-    msgpack::object obj = und.get();
-
-    std::cout << obj << std::endl;
-    assert(obj.as<decltype(m)>() == m);
-}
-
-void unordered_set() {
-    std::unordered_set<std::string> s { "ABC", "DEF" };
-    std::stringstream ss;
-    msgpack::pack(ss, s);
-
-    auto und = msgpack::unpack(ss.str().data(), ss.str().size());
-    auto obj = und.get();
-
-    std::cout << obj << std::endl;
-    assert(obj.as<decltype(s)>() == s);
-}
-
-void forward_list() {
-    using type = std::forward_list<std::string>;
-    type f { "ABC", "DEF" };
-    std::stringstream ss;
-    msgpack::pack(ss, f);
-
-    auto und = msgpack::unpack(ss.str().data(), ss.str().size());
-    auto obj = und.get();
-
-    std::cout << obj << std::endl;
-    assert(obj.as<type>() == f);
-}
-
-void combi() {
-    std::array<int, 5>                   a { { 1, 2, 3, 4, 5 } };
-    std::tuple<bool, std::string, int>   t {true, "ABC", 42};
-    std::unordered_map<std::string, int> m { {"ABC", 1}, {"DEF", 3} };
-    std::unordered_set<std::string>      s { "ABC", "DEF" };
-    std::forward_list<std::string>       f { "ABC", "DEF" };
-
-    std::stringstream ss;
-    msgpack::pack(ss, a);
-    msgpack::pack(ss, t);
-    msgpack::pack(ss, m);
-    msgpack::pack(ss, s);
-    msgpack::pack(ss, f);
-
-    std::size_t offset = 0;
-    std::cout << "offset: " << offset << std::endl;
-    {
-        auto und = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
-        auto obj = und.get();
-
-        std::cout << obj << std::endl;
-        assert(obj.as<decltype(a)>() == a);
-    }
-    std::cout << "offset: " << offset << std::endl;
-    {
-        auto und = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
-        auto obj = und.get();
-
-        std::cout << obj << std::endl;
-        assert(obj.as<decltype(t)>() == t);
-    }
-    std::cout << "offset: " << offset << std::endl;
-    {
-        auto und = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
-        auto obj = und.get();
-
-        std::cout << obj << std::endl;
-        assert(obj.as<decltype(m)>() == m);
-    }
-    std::cout << "offset: " << offset << std::endl;
-    {
-        auto und = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
-        auto obj = und.get();
-
-        std::cout << obj << std::endl;
-        assert(obj.as<decltype(s)>() == s);
-    }
-    std::cout << "offset: " << offset << std::endl;
-    {
-        auto und = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
-        auto obj = und.get();
-
-        std::cout << obj << std::endl;
-        assert(obj.as<decltype(f)>() == f);
-    }
-    std::cout << "offset: " << offset << std::endl;
-}
-
-int main() {
-    array();
-    tuple();
-    unordered_map();
-    unordered_set();
-    forward_list();
-    combi();
-}

example/cpp11/non_def_con_class.cpp

@@ -1,51 +0,0 @@
-// 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/jsonconv.c

@@ -0,0 +1,419 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <msgpack.h>
+#include <cjson/cJSON.h>
+
+#if defined(_MSC_VER)
+#if _MSC_VER >= 1800
+#include <inttypes.h>
+#else
+#define PRIu64 "I64u"
+#define PRIi64 "I64i"
+#define PRIi8 "i"
+#endif
+#else
+#include <inttypes.h>
+#endif
+
+#if defined(_KERNEL_MODE)
+#  undef  snprintf
+#  define snprintf _snprintf
+#endif
+
+#define DEBUG(...) printf(__VA_ARGS__)
+
+static char *format_string(const char *input)
+{
+    const char *inptr;
+    char *output;
+    char *outptr;
+    size_t output_length = 0;
+    /* numbers of additional characters*/
+    size_t escape_characters = 0;
+
+    if (input == NULL) {
+        return NULL;
+    }
+
+    for (inptr = input; *inptr; inptr++) {
+        switch (*inptr) {
+        case '\"':
+        case '\\':
+        case '\b':
+        case '\f':
+        case '\n':
+        case '\r':
+        case '\t':
+            /* one character escape sequence */
+            escape_characters++;
+            break;
+        default:
+            break;
+        }
+    }
+    output_length = (size_t)(inptr - input) + escape_characters;
+
+    output = (char *)malloc(output_length + 1);
+    if (output == NULL) {
+        return NULL;
+    }
+
+    /* no add characters*/
+    if (escape_characters == 0) {
+        memcpy(output, input, output_length);
+        output[output_length] = '\0';
+        return output;
+    }
+
+    outptr = output;
+    /* copy string */
+    for (inptr = input; *inptr != '\0'; (void)inptr++, outptr++) {
+        if ((*inptr > 31) && (*inptr != '\"') && (*inptr != '\\')) {
+            /* normal character, copy */
+            *outptr = *inptr;
+        } else {
+            /* character needs to be escaped */
+            *outptr++ = '\\';
+            switch (*inptr)
+            {
+            case '\\':
+                *outptr = '\\';
+                break;
+            case '\"':
+                *outptr = '\"';
+                break;
+            case '\b':
+                *outptr = 'b';
+                break;
+            case '\f':
+                *outptr = 'f';
+                break;
+            case '\n':
+                *outptr = 'n';
+                break;
+            case '\r':
+                *outptr = 'r';
+                break;
+            case '\t':
+                *outptr = 't';
+                break;
+            default:
+                break;
+            }
+        }
+    }
+
+    output[output_length] = '\0';
+    return output;
+}
+
+/*
+ * Pack cJSON object.
+ * return 0 success, others failed
+ */
+static int parse_cjson_object(msgpack_packer *pk, cJSON *node)
+{
+    int ret, sz, i;
+    cJSON *child;
+    char *strvalue;
+
+    if (node == NULL) {
+        return -1;
+    }
+
+    switch (node->type & 0xFF) {
+    case cJSON_Invalid:
+        return -1;
+
+    case cJSON_False:
+        return msgpack_pack_false(pk);
+
+    case cJSON_True:
+        return msgpack_pack_true(pk);
+
+    case cJSON_NULL:
+        return msgpack_pack_nil(pk);
+
+    case cJSON_String:
+        strvalue = format_string(node->valuestring);
+        if (strvalue != NULL) {
+            ret = msgpack_pack_str_with_body(pk, strvalue, strlen(strvalue));
+            free(strvalue);
+            return ret;
+        } else {
+            return -1;
+        }
+
+    case cJSON_Number:
+        if (isnan(node->valuedouble) || isinf(node->valuedouble)) {
+            ret = msgpack_pack_nil(pk);
+        } else if (node->valuedouble == node->valueint) {
+            ret = msgpack_pack_int(pk, node->valueint);
+        } else {
+            ret = msgpack_pack_double(pk, node->valuedouble);
+        }
+        return ret;
+
+    case cJSON_Array:
+        sz = cJSON_GetArraySize(node);
+        if (msgpack_pack_array(pk, sz) != 0) {
+            return -1;
+        }
+        for (i = 0; i < sz; i++) {
+            if (parse_cjson_object(pk, cJSON_GetArrayItem(node, i)) != 0) {
+                return -1;
+            }
+        }
+        return 0;
+
+    case cJSON_Object:
+        sz = cJSON_GetArraySize(node);
+        if (msgpack_pack_map(pk, sz) != 0) {
+            return -1;
+        }
+        for (i = 0; i < sz; i++) {
+            child = cJSON_GetArrayItem(node, i);
+            strvalue = format_string(child->string);
+            if (strvalue == NULL) {
+                return -1;
+            }
+
+            if (msgpack_pack_str_with_body(pk, strvalue, strlen(strvalue)) != 0) {
+                free(strvalue);
+                return -1;
+            }
+            free(strvalue);
+            if (parse_cjson_object(pk, child) != 0) {
+                return -1;
+            }
+        }
+        return 0;
+
+    default:
+        DEBUG("unknown type.\n");
+        return -1;
+    }
+    return 0;
+}
+
+/*
+ * Pack json string to msgpack format data.
+ * return 0 success, -1 failed
+ */
+int msgpack_pack_jsonstr(msgpack_packer *pk, const char *jsonstr)
+{
+    int status;
+    cJSON *node;
+    const char *end = NULL;
+
+    if (pk == NULL || jsonstr == NULL) {
+        return -1;
+    }
+
+    node = cJSON_ParseWithOpts(jsonstr, &end, 1);
+    if (node == NULL) {
+        DEBUG("parse error: unexpected string `%s`\n", end);
+        return -1;
+    }
+    status = parse_cjson_object(pk, node);
+    cJSON_Delete(node);
+
+    return status;
+}
+
+static int bytes_contain_zero(const msgpack_object_bin *bin)
+{
+    size_t i;
+    for (i = 0; i < bin->size; i++) {
+        if (bin->ptr[i] == 0) {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+#define PRINT_JSONSTR_CALL(ret, func, aux_buffer, aux_buffer_size, ...) \
+    ret = func(aux_buffer, aux_buffer_size, __VA_ARGS__);               \
+    if (ret <= 0)                                                       \
+        return ret;                                                     \
+    if (ret > aux_buffer_size)                                          \
+        return 0;                                                       \
+    aux_buffer = aux_buffer + ret;                                      \
+    aux_buffer_size = aux_buffer_size - ret
+
+/*
+ * Convert msgpack format data to json string.
+ * return >0: success, 0: length of buffer not enough, -1: failed
+ */
+size_t msgpack_object_print_jsonstr(char *buffer, size_t length, const msgpack_object o)
+{
+    char *aux_buffer = buffer;
+    size_t aux_buffer_size = length;
+    size_t ret;
+
+    switch (o.type) {
+    case MSGPACK_OBJECT_NIL:
+        PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "null");
+        break;
+
+    case MSGPACK_OBJECT_BOOLEAN:
+        PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, (o.via.boolean ? "true" : "false"));
+        break;
+
+    case MSGPACK_OBJECT_POSITIVE_INTEGER:
+#if defined(PRIu64)
+        PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%" PRIu64, o.via.u64);
+#else
+        if (o.via.u64 > ULONG_MAX) {
+            PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%lu", ULONG_MAX);
+        } else {
+            PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%lu", (unsigned long)o.via.u64);
+        }
+#endif
+        break;
+
+    case MSGPACK_OBJECT_NEGATIVE_INTEGER:
+#if defined(PRIi64)
+        PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%" PRIi64, o.via.i64);
+#else
+        if (o.via.i64 > LONG_MAX) {
+            PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%ld", LONG_MAX);
+        } else if (o.via.i64 < LONG_MIN) {
+            PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%ld", LONG_MIN);
+        } else {
+            PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%ld", (signed long)o.via.i64);
+        }
+#endif
+        break;
+
+    case MSGPACK_OBJECT_FLOAT32:
+    case MSGPACK_OBJECT_FLOAT64:
+        PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%f", o.via.f64);
+        break;
+
+    case MSGPACK_OBJECT_STR:
+        PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\"%.*s\"", (int)o.via.str.size, o.via.str.ptr);
+        break;
+
+    case MSGPACK_OBJECT_BIN:
+        if (bytes_contain_zero(&o.via.bin)) {
+            DEBUG("the value contains zero\n");
+            return -1;
+        }
+        PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\"%.*s\"", (int)o.via.bin.size, o.via.bin.ptr);
+        break;
+
+    case MSGPACK_OBJECT_EXT:
+        DEBUG("not support type: MSGPACK_OBJECT_EXT.\n");
+        return -1;
+
+    case MSGPACK_OBJECT_ARRAY:
+        PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "[");
+        if (o.via.array.size != 0) {
+            msgpack_object *p = o.via.array.ptr;
+            msgpack_object *const pend = o.via.array.ptr + o.via.array.size;
+            PRINT_JSONSTR_CALL(ret, msgpack_object_print_jsonstr, aux_buffer, aux_buffer_size, *p);
+            ++p;
+            for (; p < pend; ++p) {
+                PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, ",");
+                PRINT_JSONSTR_CALL(ret, msgpack_object_print_jsonstr, aux_buffer, aux_buffer_size, *p);
+            }
+        }
+        PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "]");
+        break;
+
+    case MSGPACK_OBJECT_MAP:
+        PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "{");
+        if (o.via.map.size != 0) {
+            msgpack_object_kv *p = o.via.map.ptr;
+            msgpack_object_kv *const pend = o.via.map.ptr + o.via.map.size;
+
+            for (; p < pend; ++p) {
+                if (p->key.type != MSGPACK_OBJECT_STR) {
+                    DEBUG("the key of in a map must be string.\n");
+                    return -1;
+                }
+                if (p != o.via.map.ptr) {
+                    PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, ",");
+                }
+                PRINT_JSONSTR_CALL(ret, msgpack_object_print_jsonstr, aux_buffer, aux_buffer_size, p->key);
+                PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, ":");
+                PRINT_JSONSTR_CALL(ret, msgpack_object_print_jsonstr, aux_buffer, aux_buffer_size, p->val);
+            }
+        }
+        PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "}");
+        break;
+
+    default:
+        DEBUG("unknown type.\n");
+        return -1;
+    }
+
+    return length - aux_buffer_size;
+}
+#undef PRINT_JSONSTR_CALL
+
+static void test(const char *name, const char *input, const char *expect)
+{
+    msgpack_sbuffer sbuf;
+    {
+        // pack
+        msgpack_packer pk;
+        msgpack_sbuffer_init(&sbuf);
+        msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
+        if (msgpack_pack_jsonstr(&pk, input) < 0) {
+            msgpack_sbuffer_destroy(&sbuf);
+            printf("%s: invalid json string.\n", name);
+            return;
+        }
+    }
+
+    {
+        // unpack
+#define MAX_JSONLEN 1024
+        msgpack_zone z;
+        msgpack_object obj;
+        size_t jsonstrlen = MAX_JSONLEN - 1;
+        char jsonparsed[MAX_JSONLEN];
+
+        msgpack_zone_init(&z, jsonstrlen);
+        msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
+        jsonstrlen = msgpack_object_print_jsonstr(jsonparsed, jsonstrlen, obj);
+        jsonparsed[jsonstrlen] = '\0';
+
+        //compare input and output
+        if (expect == NULL) {
+            expect = input;
+        }
+        if (strcmp(expect, jsonparsed) == 0) {
+            printf("%s: ok\n", name);
+        } else {
+            printf("%s: failed\n", name);
+        }
+        msgpack_zone_destroy(&z);
+    }
+    msgpack_sbuffer_destroy(&sbuf);
+}
+
+int main()
+{
+    test("null", "null", NULL);
+    test("boolean", "false", NULL);
+    test("single string", "\"frsyuki\"", NULL);
+    test("single number", "\"100\"", NULL);
+    test("space", "[{\"valuespace\":\"\",\"\":\"keyspace\"},\"\",[\"\"]]", NULL);
+    test("quote", "\"My name is Tom (\\\"Bee\\\") Kobe\"", NULL);
+    test("escape", "\"\\\\b\\f\\n\\r\\t\"", NULL);
+    test("escape2", "\"\b\f\n\r\t\"", "\"\\b\\f\\n\\r\\t\"");
+    test("map", "{\"name\":\"Tom (\\\"Bee\\\") Kobe\",\"type\":\"image\",\"data\":{\"width\":360,\"height\":460,\"title\":\"View me\",\"ips\":[116,943,256,711]}}", NULL);
+    test("array", "[\"Sunday\",\"Monday\",\"Tuesday\",\"Wednesday\",\"Thursday\",\"Friday\",\"Saturday\"]", NULL);
+    test("number array", "[[101,121,-33],[119,911,171],[0,2,-3]]", NULL);
+    test("mix array", "[{\"name\":\"Tom\",\"city\":\"London\",\"country\":\"UK\",\"longitude\":23},{\"name\":\"Jack\",\"city\":\"Birmingham\",\"country\":\"UK\",\"longitude\":-22}]", NULL);
+    test("unicode", "\"\\u5C71\\u5DDD\\u7570\\u57DF\\u98A8\\u6708\\u540C\\u5929\"", "\"山川異域風月同天\"");
+    test("utf8", "\"山川異域風月同天\"", NULL);
+    test("double", "12.34", "12.340000");
+
+    return 0;
+}

example/lib_buffer_unpack.c

@@ -44,12 +44,13 @@ size_t receiver_recv(receiver *r, char* buf, size_t try_size) {
 size_t receiver_to_unpacker(receiver* r, size_t request_size,
         msgpack_unpacker *unpacker)
 {
+    size_t recv_len;
     // make sure there's enough room, or expand the unpacker accordingly
     if (msgpack_unpacker_buffer_capacity(unpacker) < request_size) {
         msgpack_unpacker_reserve_buffer(unpacker, request_size);
         assert(msgpack_unpacker_buffer_capacity(unpacker) >= request_size);
     }
-    size_t recv_len = receiver_recv(r, msgpack_unpacker_buffer(unpacker),
+    recv_len = receiver_recv(r, msgpack_unpacker_buffer(unpacker),
                              request_size);
     msgpack_unpacker_buffer_consumed(unpacker, recv_len);
     return recv_len;
@@ -70,7 +71,11 @@ void unpack(receiver* r) {
     while (true) {
         recv_len = receiver_to_unpacker(r, EACH_RECV_SIZE, unp);
         if (recv_len == 0) break; // (reached end of input)
+#if defined(_MSC_VER) || defined(__MINGW32__)
+        printf("receive count: %d %Id bytes received.\n", recv_count++, recv_len);
+#else // defined(_MSC_VER) || defined(__MINGW32__)
         printf("receive count: %d %zd bytes received.\n", recv_count++, recv_len);
+#endif // defined(_MSC_VER) || defined(__MINGW32__)
         ret = msgpack_unpacker_next(unp, &result);
         while (ret == MSGPACK_UNPACK_SUCCESS) {
             msgpack_object obj = result.data;

example/simple_c.c

@@ -1,7 +1,7 @@
 #include <msgpack.h>
 #include <stdio.h>
 
-void print(char const* buf, unsigned int len)
+void print(char const* buf,size_t len)
 {
     size_t i = 0;
     for(; i < len ; ++i)

example/speed_test_uint32_array.c

@@ -22,9 +22,10 @@ void test()
 
     msgpack_unpacked_init(&msg);
 
-    while (msgpack_unpack_next(&msg, buf.data, buf.size, &upk_pos)) {
+    while (msgpack_unpack_next(&msg, buf.data, buf.size, &upk_pos) == MSGPACK_UNPACK_SUCCESS) {
     }
 
+    msgpack_unpacked_destroy(&msg);
     msgpack_sbuffer_destroy(&buf);
 }
 

example/speed_test_uint64_array.c

@@ -23,9 +23,9 @@ void test()
 
     msgpack_unpacked_init(&msg);
 
-    while (msgpack_unpack_next(&msg, buf.data, buf.size, &upk_pos)) {
+    while (msgpack_unpack_next(&msg, buf.data, buf.size, &upk_pos) == MSGPACK_UNPACK_SUCCESS) {
     }
-
+    msgpack_unpacked_destroy(&msg);
     msgpack_sbuffer_destroy(&buf);
 }
 

example/user_buffer_unpack.c

@@ -2,6 +2,8 @@
 #include <stdio.h>
 #include <assert.h>
 
+#define UNPACKED_BUFFER_SIZE 2048
+
 void prepare(msgpack_sbuffer* sbuf) {
     msgpack_packer pk;
 
@@ -27,6 +29,7 @@ void unpack(char const* buf, size_t len) {
     size_t off = 0;
     msgpack_unpack_return ret;
     int i = 0;
+    char unpacked_buffer[UNPACKED_BUFFER_SIZE];
     msgpack_unpacked_init(&result);
     ret = msgpack_unpack_next(&result, buf, len, &off);
     while (ret == MSGPACK_UNPACK_SUCCESS) {
@@ -36,6 +39,8 @@ void unpack(char const* buf, size_t len) {
         printf("Object no %d:\n", ++i);
         msgpack_object_print(stdout, obj);
         printf("\n");
+        msgpack_object_print_buffer(unpacked_buffer, UNPACKED_BUFFER_SIZE, obj);
+        printf("%s\n", unpacked_buffer);
         /* If you want to allocate something on the zone, you can use zone. */
         /* msgpack_zone* zone = result.zone; */
         /* The lifetime of the obj and the zone,  */

include/msgpack.hpp

@@ -1,18 +0,0 @@
-//
-// 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/unpack.hpp"
-#include "msgpack/sbuffer.hpp"
-#include "msgpack/vrefbuffer.hpp"
-#include "msgpack/version.hpp"
-#include "msgpack/type.hpp"

include/msgpack/adaptor/adaptor_base.hpp

@@ -1,84 +0,0 @@
-//
-// 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_ADAPTOR_BASE_HPP
-#define MSGPACK_ADAPTOR_BASE_HPP
-
-#include "msgpack/object_fwd.hpp"
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-template <typename Stream>
-class packer;
-
-namespace adaptor {
-
-// Adaptor functors
-
-template <typename T, typename Enabler = void>
-struct convert {
-    msgpack::object const& operator()(msgpack::object const& o, T& v) const;
-};
-
-template <typename T, typename Enabler = void>
-struct pack {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, T const& v) const;
-};
-
-template <typename T, typename Enabler = void>
-struct object {
-    void operator()(msgpack::object& o, T const& v) const;
-};
-
-template <typename T, typename Enabler = void>
-struct object_with_zone {
-    void operator()(msgpack::object::with_zone& o, T const& v) const;
-};
-
-} // namespace adaptor
-
-// operators
-
-template <typename T>
-inline
-msgpack::object const& operator>> (msgpack::object const& o, T& v) {
-    return adaptor::convert<T>()(o, v);
-}
-
-template <typename Stream, typename T>
-inline
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, T const& v) {
-    return adaptor::pack<T>()(o, v);
-}
-
-template <typename T>
-inline
-void operator<< (msgpack::object& o, T const& v) {
-    adaptor::object<T>()(o, v);
-}
-
-template <typename T>
-inline
-void operator<< (msgpack::object::with_zone& o, T const& v) {
-    adaptor::object_with_zone<T>()(o, v);
-}
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
-
-
-#endif // MSGPACK_ADAPTOR_BASE_HPP

include/msgpack/adaptor/array_ref.hpp

@@ -1,174 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// 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)
-//
-#ifndef MSGPACK_TYPE_ARRAY_REF_HPP
-#define MSGPACK_TYPE_ARRAY_REF_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-#include <cstring>
-#include <string>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace type {
-
-template <typename T>
-struct array_ref {
-    array_ref() : data(nullptr) {}
-    array_ref(T& t) : data(&t) {}
-
-    T* data;
-
-    template <typename U>
-    bool operator==(array_ref<U> const& t) const {
-        return *data == *t.data;
-    }
-    template <typename U>
-    bool operator!=(array_ref<U> const& t) const {
-        return !(*data == *t.data);
-    }
-    template <typename U>
-    bool operator< (array_ref<U> const& t) const
-    {
-        return *data < *t.data;
-    }
-    template <typename U>
-    bool operator> (array_ref<U> const& t) const
-    {
-        return *t.data < *data;
-    }
-    template <typename U>
-    bool operator<= (array_ref<U> const& t) const
-    {
-        return !(*t.data < *data);
-    }
-    template <typename U>
-    bool operator>= (array_ref<U> const& t) const
-    {
-        return !(*data < *t.data);
-    }
-};
-
-template <typename T>
-inline array_ref<T const> make_array_ref(T const& t) {
-    return array_ref<T const>(t);
-}
-
-template <typename T>
-inline array_ref<T> make_array_ref(T& t) {
-    return array_ref<T>(t);
-}
-
-
-} // namespace type
-
-namespace adaptor {
-
-template <typename T>
-struct convert<msgpack::type::array_ref<T> > {
-    msgpack::object const& operator()(msgpack::object const& o, msgpack::type::array_ref<T>& v) const {
-        if (!v.data) { throw msgpack::type_error(); }
-        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        if (v.data->size() < o.via.bin.size) { throw msgpack::type_error(); }
-        if (o.via.array.size > 0) {
-            msgpack::object* p = o.via.array.ptr;
-            msgpack::object* const pend = o.via.array.ptr + o.via.array.size;
-            typename T::iterator it = v.data->begin();
-            do {
-                p->convert(*it);
-                ++p;
-                ++it;
-            } while(p < pend);
-        }
-        return o;
-    }
-};
-
-template <typename T>
-struct convert<msgpack::type::array_ref<std::vector<T> > > {
-    msgpack::object const& operator()(msgpack::object const& o, msgpack::type::array_ref<std::vector<T> >& v) const {
-        if (!v.data) { throw msgpack::type_error(); }
-        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        v.data->resize(o.via.bin.size);
-        if (o.via.array.size > 0) {
-            msgpack::object* p = o.via.array.ptr;
-            msgpack::object* const pend = o.via.array.ptr + o.via.array.size;
-            typename std::vector<T>::iterator it = v.data->begin();
-            do {
-                p->convert(*it);
-                ++p;
-                ++it;
-            } while(p < pend);
-        }
-        return o;
-    }
-};
-
-template <typename T>
-struct pack<msgpack::type::array_ref<T> > {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const msgpack::type::array_ref<T>& v) const {
-        if (!v.data) { throw msgpack::type_error(); }
-        uint32_t size = checked_get_container_size(v.data->size());
-        o.pack_array(size);
-        for (typename T::const_iterator it(v.data->begin()), it_end(v.data->end());
-            it != it_end; ++it) {
-            o.pack(*it);
-        }
-        return o;
-    }
-};
-
-template <typename T>
-struct object_with_zone<msgpack::type::array_ref<T> > {
-    void operator()(msgpack::object::with_zone& o, const msgpack::type::array_ref<T>& v) const {
-        if (!v.data) { throw msgpack::type_error(); }
-        o.type = msgpack::type::ARRAY;
-        if (v.data->empty()) {
-            o.via.array.ptr = nullptr;
-            o.via.array.size = 0;
-        }
-        else {
-            uint32_t size = checked_get_container_size(v.data->size());
-            msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
-            msgpack::object* const pend = p + size;
-            o.via.array.ptr = p;
-            o.via.array.size = size;
-            typename T::const_iterator it(v.data->begin());
-            do {
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
-                *p = msgpack::object(*it, o.zone);
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
-#pragma GCC diagnostic pop
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
-                ++p;
-                ++it;
-            } while(p < pend);
-        }
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
-
-#endif // MSGPACK_TYPE_ARRAY_REF_HPP

include/msgpack/adaptor/bool.hpp

@@ -1,66 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// 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)
-//
-#ifndef MSGPACK_TYPE_BOOL_HPP
-#define MSGPACK_TYPE_BOOL_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-template <>
-struct convert<bool> {
-    msgpack::object const& operator()(msgpack::object const& o, bool& v) const {
-        if(o.type != msgpack::type::BOOLEAN) { throw msgpack::type_error(); }
-        v = o.via.boolean;
-        return o;
-    }
-};
-
-template <>
-struct pack<bool> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const bool& v) const {
-        if(v) { o.pack_true(); }
-        else { o.pack_false(); }
-        return o;
-    }
-};
-
-template <>
-struct object<bool> {
-    void operator()(msgpack::object& o, bool v) const {
-        o.type = msgpack::type::BOOLEAN;
-        o.via.boolean = v;
-    }
-};
-
-template <>
-struct object_with_zone<bool> {
-    void operator()(msgpack::object::with_zone& o, bool v) const {
-        static_cast<msgpack::object&>(o) << v;
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_BOOL_HPP

include/msgpack/adaptor/boost/fusion.hpp

@@ -1,160 +0,0 @@
-//
-// 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/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-#include "msgpack/meta.hpp"
-
-#if !defined (MSGPACK_USE_CPP03)
-#include "msgpack/adaptor/cpp11/tuple.hpp"
-#endif // #if !defined (MSGPACK_USE_CPP03)
-
-#include <boost/fusion/support/is_sequence.hpp>
-#include <boost/fusion/sequence/intrinsic/size.hpp>
-#include <boost/fusion/algorithm/iteration/for_each.hpp>
-#include <boost/fusion/sequence/intrinsic/at.hpp>
-#include <boost/fusion/include/mpl.hpp>
-#include <boost/mpl/size.hpp>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-#if !defined (MSGPACK_USE_CPP03)
-
-template <typename T>
-struct as<
-    T,
-    typename msgpack::enable_if<
-        boost::fusion::traits::is_sequence<T>::value &&
-        boost::mpl::fold<
-            T,
-            boost::mpl::bool_<true>,
-            boost::mpl::if_ <
-                boost::mpl::and_<
-                    boost::mpl::_1,
-                    msgpack::has_as<boost::mpl::_2>
-                >,
-                boost::mpl::bool_<true>,
-                boost::mpl::bool_<false>
-            >
-        >::type::value
-    >::type
-> {
-    T operator()(msgpack::object const& o) const {
-        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        if (o.via.array.size != checked_get_container_size(boost::mpl::size<T>::value)) {
-            throw msgpack::type_error();
-        }
-        using tuple_t = decltype(to_tuple(std::declval<T>(), gen_seq<boost::mpl::size<T>::value>()));
-        return to_t(
-            o.as<tuple_t>(),
-            msgpack::gen_seq<boost::mpl::size<T>::value>());
-    }
-    template<std::size_t... Is, typename U>
-    static std::tuple<
-        typename std::remove_reference<
-            typename boost::fusion::result_of::at_c<T, Is>::type
-        >::type...>
-    to_tuple(U const& u, seq<Is...>) {
-        return std::make_tuple(boost::fusion::at_c<Is>(u)...);
-    }
-    template<std::size_t... Is, typename U>
-    static T to_t(U const& u, seq<Is...>) {
-        return T(std::get<Is>(u)...);
-    }
-};
-
-#endif // !defined (MSGPACK_USE_CPP03)
-
-template <typename T>
-struct convert<T, typename msgpack::enable_if<boost::fusion::traits::is_sequence<T>::value>::type > {
-    msgpack::object const& operator()(msgpack::object const& o, T& v) const {
-        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        if (o.via.array.size != checked_get_container_size(boost::fusion::size(v))) {
-            throw msgpack::type_error();
-        }
-        uint32_t index = 0;
-        boost::fusion::for_each(v, convert_imp(o, index));
-        return o;
-    }
-private:
-    struct convert_imp {
-        convert_imp(msgpack::object const& obj, uint32_t& index):obj_(obj), index_(index) {}
-        template <typename U>
-        void operator()(U& v) const {
-            msgpack::adaptor::convert<U>()(obj_.via.array.ptr[index_++], v);
-        }
-    private:
-        msgpack::object const& obj_;
-        uint32_t& index_;
-    };
-};
-
-template <typename T>
-struct pack<T, typename msgpack::enable_if<boost::fusion::traits::is_sequence<T>::value>::type > {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const T& v) const {
-        uint32_t size = checked_get_container_size(boost::fusion::size(v));
-        o.pack_array(size);
-        boost::fusion::for_each(v, pack_imp<Stream>(o));
-        return o;
-    }
-private:
-    template <typename Stream>
-    struct pack_imp {
-        pack_imp(msgpack::packer<Stream>& stream):stream_(stream) {}
-        template <typename U>
-        void operator()(U const& v) const {
-            stream_.pack(v);
-        }
-    private:
-        msgpack::packer<Stream>& stream_;
-    };
-};
-
-template <typename T>
-struct object_with_zone<T, typename msgpack::enable_if<boost::fusion::traits::is_sequence<T>::value>::type > {
-    void operator()(msgpack::object::with_zone& o, const T& v) const {
-        uint32_t size = checked_get_container_size(boost::fusion::size(v));
-        o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
-        o.via.array.size = size;
-        uint32_t count = 0;
-        boost::fusion::for_each(v, with_zone_imp(o, count));
-    }
-private:
-    struct with_zone_imp {
-        with_zone_imp(msgpack::object::with_zone const& obj, uint32_t& count):obj_(obj), count_(count) {}
-        template <typename U>
-        void operator()(U const& v) const {
-            obj_.via.array.ptr[count_++] = msgpack::object(v, obj_.zone);
-        }
-        msgpack::object::with_zone const& obj_;
-        uint32_t& count_;
-    };
-};
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
-
-#endif // MSGPACK_TYPE_BOOST_FUSION_HPP

include/msgpack/adaptor/boost/msgpack_variant.hpp

@@ -1,430 +0,0 @@
-//
-// 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_MSGPACK_VARIANT_HPP
-#define MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_HPP
-
-#if defined(MSGPACK_USE_BOOST)
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-#include "msgpack/adaptor/boost/string_ref.hpp"
-
-#include "msgpack/adaptor/nil.hpp"
-#include "msgpack/adaptor/bool.hpp"
-#include "msgpack/adaptor/int.hpp"
-#include "msgpack/adaptor/float.hpp"
-#include "msgpack/adaptor/string.hpp"
-#include "msgpack/adaptor/vector_char.hpp"
-#include "msgpack/adaptor/raw.hpp"
-#include "msgpack/adaptor/ext.hpp"
-#include "msgpack/adaptor/vector.hpp"
-#include "msgpack/adaptor/map.hpp"
-
-#include <boost/variant.hpp>
-#include <boost/operators.hpp>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace type {
-
-
-template <typename STR, typename BIN, typename EXT>
-struct basic_variant :
-    boost::variant<
-        nil_t,             // NIL
-        bool,              // BOOL
-        int64_t,           // NEGATIVE_INTEGER
-        uint64_t,          // POSITIVE_INTEGER
-        double,            // FLOAT
-        std::string,       // STR
-#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
-        boost::string_ref, // STR
-#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
-        std::vector<char>, // BIN
-        msgpack::type::raw_ref, // BIN
-        ext,               // EXT
-        ext_ref,           // EXT
-        boost::recursive_wrapper<std::vector<basic_variant<STR, BIN, EXT> > >, // ARRAY
-        boost::recursive_wrapper<std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >, // MAP
-        boost::recursive_wrapper<std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >// MAP
-    >,
-    private boost::totally_ordered<basic_variant<STR, BIN, EXT> > {
-    typedef boost::variant<
-        nil_t,             // NIL
-        bool,              // BOOL
-        int64_t,           // NEGATIVE_INTEGER
-        uint64_t,          // POSITIVE_INTEGER
-        double,            // FLOAT
-        std::string,       // STR
-#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
-        boost::string_ref, // STR
-#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
-        std::vector<char>, // BIN
-        msgpack::type::raw_ref, // BIN
-        ext,               // EXT
-        ext_ref,           // EXT
-        boost::recursive_wrapper<std::vector<basic_variant<STR, BIN, EXT> > >, // ARRAY
-        boost::recursive_wrapper<std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >, // MAP
-        boost::recursive_wrapper<std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >// MAP
-    > base;
-    basic_variant() {}
-    template <typename T>
-    basic_variant(T const& t):base(t) {}
-    basic_variant(char const* p):base(std::string(p)) {}
-    basic_variant(char v) {
-        int_init(v);
-    }
-    basic_variant(signed char v) {
-        int_init(v);
-    }
-    basic_variant(unsigned char v):base(uint64_t(v)) {}
-    basic_variant(signed int v) {
-        int_init(v);
-    }
-    basic_variant(unsigned int v):base(uint64_t(v)) {}
-    basic_variant(signed long v) {
-        int_init(v);
-    }
-    basic_variant(unsigned long v):base(uint64_t(v)) {}
-    basic_variant(signed long long v) {
-        int_init(v);
-    }
-    basic_variant(unsigned long long v):base(uint64_t(v)) {}
-
-    bool is_nil() const {
-        return boost::get<msgpack::type::nil_t>(this);
-    }
-    bool is_bool() const {
-        return boost::get<bool>(this);
-    }
-    bool is_int64_t() const {
-        return boost::get<int64_t>(this);
-    }
-    bool is_uint64_t() const {
-        return boost::get<uint64_t>(this);
-    }
-    bool is_double() const {
-        return boost::get<double>(this);
-    }
-    bool is_string() const {
-        return boost::get<std::string>(this);
-    }
-#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
-    bool is_boost_string_ref() const {
-        return boost::get<boost::string_ref>(this);
-    }
-#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
-    bool is_vector_char() const {
-        return boost::get<std::vector<char> >(this);
-    }
-    bool is_vector_char() {
-        return boost::get<std::vector<char> >(this);
-    }
-    bool is_raw_ref() const {
-        return boost::get<raw_ref>(this);
-    }
-    bool is_ext() const {
-        return boost::get<ext>(this);
-    }
-    bool is_ext_ref() const {
-        return boost::get<ext_ref>(this);
-    }
-    bool is_vector() const {
-        return boost::get<std::vector<basic_variant<STR, BIN, EXT> > >(this);
-    }
-    bool is_map() const {
-        return boost::get<std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >(this);
-    }
-    bool is_multimap() const {
-        return boost::get<std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >(this);
-    }
-
-    bool as_bool() const {
-        return boost::get<bool>(*this);
-    }
-    int64_t as_int64_t() const {
-        return boost::get<int64_t>(*this);
-    }
-    int64_t& as_int64_t() {
-        return boost::get<int64_t>(*this);
-    }
-    uint64_t as_uint64_t() const {
-        return boost::get<uint64_t>(*this);
-    }
-    uint64_t& as_uint64_t() {
-        return boost::get<uint64_t>(*this);
-    }
-    double as_double() const {
-        return boost::get<double>(*this);
-    }
-    double& as_double() {
-        return boost::get<double>(*this);
-    }
-    std::string const& as_string() const {
-        return boost::get<std::string>(*this);
-    }
-    std::string& as_string() {
-        return boost::get<std::string>(*this);
-    }
-#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
-    boost::string_ref const& as_boost_string_ref() const {
-        return boost::get<boost::string_ref>(*this);
-    }
-    boost::string_ref& as_boost_string_ref() {
-        return boost::get<boost::string_ref>(*this);
-    }
-#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
-    std::vector<char> const& as_vector_char() const {
-        return boost::get<std::vector<char> >(*this);
-    }
-    std::vector<char>& as_vector_char() {
-        return boost::get<std::vector<char> >(*this);
-    }
-    raw_ref const& as_raw_ref() const {
-        return boost::get<raw_ref>(*this);
-    }
-    ext const& as_ext() const {
-        return boost::get<ext>(*this);
-    }
-    ext& as_ext() {
-        return boost::get<ext>(*this);
-    }
-    ext_ref const& as_ext_ref() const {
-        return boost::get<ext_ref>(*this);
-    }
-    std::vector<basic_variant<STR, BIN, EXT> > const& as_vector() const {
-        return boost::get<std::vector<basic_variant<STR, BIN, EXT> > >(*this);
-    }
-    std::vector<basic_variant<STR, BIN, EXT> >& as_vector() {
-        return boost::get<std::vector<basic_variant<STR, BIN, EXT> > >(*this);
-    }
-    std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > const& as_map() const {
-        return boost::get<std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >(*this);
-    }
-    std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> >& as_map() {
-        return boost::get<std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >(*this);
-    }
-    std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > const& as_multimap() const {
-        return boost::get<std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >(*this);
-    }
-    std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> >& as_multimap() {
-        return boost::get<std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >(*this);
-    }
-private:
-    template <typename T>
-    void int_init(T v) {
-        if (v < 0) {
-            static_cast<base&>(*this) = int64_t(v);
-        }
-        else {
-            static_cast<base&>(*this) = uint64_t(v);
-        }
-    }
-};
-
-template <typename STR, typename BIN, typename EXT>
-inline bool operator<(basic_variant<STR, BIN, EXT> const& lhs, basic_variant<STR, BIN, EXT> const& rhs) {
-    return
-        static_cast<typename basic_variant<STR, BIN, EXT>::base const&>(lhs) <
-        static_cast<typename basic_variant<STR, BIN, EXT>::base const&>(rhs);
-}
-
-template <typename STR, typename BIN, typename EXT>
-inline bool operator==(basic_variant<STR, BIN, EXT> const& lhs, basic_variant<STR, BIN, EXT> const& rhs) {
-    return
-        static_cast<typename basic_variant<STR, BIN, EXT>::base const&>(lhs) ==
-        static_cast<typename basic_variant<STR, BIN, EXT>::base const&>(rhs);
-}
-
-typedef basic_variant<std::string, std::vector<char>, ext> variant;
-typedef basic_variant<
-#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
-    boost::string_ref,
-#else  // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
-    std::string,
-#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
-    raw_ref, ext_ref> variant_ref;
-
-} // namespace type
-
-namespace adaptor {
-
-#if !defined (MSGPACK_USE_CPP03)
-
-template <typename STR, typename BIN, typename EXT>
-struct as<msgpack::type::basic_variant<STR, BIN, EXT> > {
-    msgpack::type::basic_variant<STR, BIN, EXT> operator()(msgpack::object const& o) const {
-        switch(o.type) {
-        case type::NIL:
-            return o.as<msgpack::type::nil_t>();
-        case type::BOOLEAN:
-            return o.as<bool>();
-        case type::POSITIVE_INTEGER:
-            return o.as<uint64_t>();
-        case type::NEGATIVE_INTEGER:
-            return o.as<int64_t>();
-        case type::FLOAT:
-            return o.as<double>();
-        case type::STR:
-            return o.as<STR>();
-        case type::BIN:
-            return o.as<BIN>();
-        case type::EXT:
-            return o.as<EXT>();
-        case type::ARRAY:
-            return o.as<std::vector<msgpack::type::basic_variant<STR, BIN, EXT> > >();
-        case type::MAP:
-            return o.as<std::multimap<msgpack::type::basic_variant<STR, BIN, EXT>, msgpack::type::basic_variant<STR, BIN, EXT> > >();
-        default:
-            break;
-        }
-        return msgpack::type::basic_variant<STR, BIN, EXT>();
-    }
-};
-
-#endif // !defined (MSGPACK_USE_CPP03)
-
-
-template <typename STR, typename BIN, typename EXT>
-struct convert<msgpack::type::basic_variant<STR, BIN, EXT> > {
-    msgpack::object const& operator()(
-        msgpack::object const& o,
-        msgpack::type::basic_variant<STR, BIN, EXT>& v) const {
-        switch(o.type) {
-        case type::NIL:
-            v = o.as<msgpack::type::nil_t>();
-            break;
-        case type::BOOLEAN:
-            v = o.as<bool>();
-            break;
-        case type::POSITIVE_INTEGER:
-            v = o.as<uint64_t>();
-            break;
-        case type::NEGATIVE_INTEGER:
-            v = o.as<int64_t>();
-            break;
-        case type::FLOAT:
-            v = o.as<double>();
-            break;
-        case type::STR:
-            v = o.as<STR>();
-            break;
-        case type::BIN:
-            v = o.as<BIN>();
-            break;
-        case type::EXT:
-            v = o.as<EXT>();
-            break;
-        case type::ARRAY:
-            v = o.as<std::vector<msgpack::type::basic_variant<STR, BIN, EXT> > >();
-            break;
-        case type::MAP:
-            v = o.as<std::multimap<msgpack::type::basic_variant<STR, BIN, EXT>, msgpack::type::basic_variant<STR, BIN, EXT> > >();
-            break;
-        default:
-            break;
-        }
-        return o;
-    }
-};
-
-namespace detail {
-
-template <typename Stream>
-struct pack_imp : boost::static_visitor<void> {
-    template <typename T>
-    void operator()(T const& value) const {
-        pack<T>()(o_, value);
-    }
-    pack_imp(packer<Stream>& o):o_(o) {}
-    packer<Stream>& o_;
-};
-
-} // namespace detail
-
-template <typename STR, typename BIN, typename EXT>
-struct pack<msgpack::type::basic_variant<STR, BIN, EXT> > {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const msgpack::type::basic_variant<STR, BIN, EXT>& v) const {
-        boost::apply_visitor(detail::pack_imp<Stream>(o), v);
-        return o;
-    }
-};
-
-namespace detail {
-
-struct object_imp : boost::static_visitor<void> {
-    void operator()(msgpack::type::nil_t const& v) const {
-        object<msgpack::type::nil_t>()(o_, v);
-    }
-    void operator()(bool const& v) const {
-        object<bool>()(o_, v);
-    }
-    void operator()(uint64_t const& v) const {
-        object<uint64_t>()(o_, v);
-    }
-    void operator()(int64_t const& v) const {
-        object<int64_t>()(o_, v);
-    }
-    void operator()(double const& v) const {
-        object<double>()(o_, v);
-    }
-    template <typename T>
-    void operator()(T const&) const {
-        throw msgpack::type_error();
-    }
-    object_imp(msgpack::object& o):o_(o) {}
-    msgpack::object& o_;
-};
-
-} // namespace detail
-
-template <typename STR, typename BIN, typename EXT>
-struct object<msgpack::type::basic_variant<STR, BIN, EXT> > {
-    void operator()(msgpack::object& o, const msgpack::type::basic_variant<STR, BIN, EXT>& v) const {
-        boost::apply_visitor(detail::object_imp(o), v);
-    }
-};
-
-namespace detail {
-
-struct object_with_zone_imp : boost::static_visitor<void> {
-    template <typename T>
-    void operator()(T const& v) const {
-        object_with_zone<T>()(o_, v);
-    }
-    object_with_zone_imp(msgpack::object::with_zone& o):o_(o) {}
-    msgpack::object::with_zone& o_;
-};
-
-} // namespace detail
-
-template <typename STR, typename BIN, typename EXT>
-struct object_with_zone<msgpack::type::basic_variant<STR, BIN, EXT> > {
-    void operator()(msgpack::object::with_zone& o, const msgpack::type::basic_variant<STR, BIN, EXT>& v) const {
-        boost::apply_visitor(detail::object_with_zone_imp(o), v);
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
-
-#endif // MSGPACK_USE_BOOST
-#endif // MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_HPP

include/msgpack/adaptor/boost/optional.hpp

@@ -1,96 +0,0 @@
-//
-// 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_OPTIONAL_HPP
-#define MSGPACK_TYPE_BOOST_OPTIONAL_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-// To suppress warning on Boost.1.58.0
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__)
-
-#include <boost/optional.hpp>
-
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__)
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-#if !defined (MSGPACK_USE_CPP03)
-
-template <typename T>
-struct as<boost::optional<T>, typename std::enable_if<msgpack::has_as<T>::value>::type> {
-    boost::optional<T> operator()(msgpack::object const& o) const {
-        if(o.is_nil()) return boost::none;
-        return o.as<T>();
-    }
-};
-
-#endif // !defined (MSGPACK_USE_CPP03)
-
-template <typename T>
-struct convert<boost::optional<T> > {
-    msgpack::object const& operator()(msgpack::object const& o, boost::optional<T>& v) const {
-        if(o.is_nil()) v = boost::none;
-        else {
-            T t;
-            msgpack::adaptor::convert<T>()(o, t);
-            v = t;
-        }
-        return o;
-    }
-};
-
-template <typename T>
-struct pack<boost::optional<T> > {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const boost::optional<T>& v) const {
-        if (v) o.pack(*v);
-        else o.pack_nil();
-        return o;
-    }
-};
-
-template <typename T>
-struct object<boost::optional<T> > {
-    void operator()(msgpack::object& o, const boost::optional<T>& v) const {
-        if (v) msgpack::adaptor::object<T>()(o, *v);
-        else o.type = msgpack::type::NIL;
-    }
-};
-
-template <typename T>
-struct object_with_zone<boost::optional<T> > {
-    void operator()(msgpack::object::with_zone& o, const boost::optional<T>& v) const {
-        if (v) msgpack::adaptor::object_with_zone<T>()(o, *v);
-        else o.type = msgpack::type::NIL;
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
-
-#endif // MSGPACK_TYPE_BOOST_OPTIONAL_HPP

include/msgpack/adaptor/boost/string_ref.hpp

@@ -1,87 +0,0 @@
-//
-// 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_STRING_REF_HPP
-#define MSGPACK_TYPE_BOOST_STRING_REF_HPP
-
-#include <boost/version.hpp>
-#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#include <boost/utility/string_ref.hpp>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-template <>
-struct convert<boost::string_ref> {
-    msgpack::object const& operator()(msgpack::object const& o, boost::string_ref& v) const {
-        switch (o.type) {
-        case msgpack::type::BIN:
-            v = boost::string_ref(o.via.bin.ptr, o.via.bin.size);
-            break;
-        case msgpack::type::STR:
-            v = boost::string_ref(o.via.str.ptr, o.via.str.size);
-            break;
-        default:
-            throw msgpack::type_error();
-            break;
-        }
-        return o;
-    }
-};
-
-template <>
-struct pack<boost::string_ref> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const boost::string_ref& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.pack_str(size);
-        o.pack_str_body(v.data(), size);
-        return o;
-    }
-};
-
-template <>
-struct object<boost::string_ref> {
-    void operator()(msgpack::object& o, const boost::string_ref& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.type = msgpack::type::STR;
-        o.via.str.ptr = v.data();
-        o.via.str.size = size;
-    }
-};
-
-template <>
-struct object_with_zone<boost::string_ref> {
-    void operator()(msgpack::object::with_zone& o, const boost::string_ref& v) const {
-        static_cast<msgpack::object&>(o) << v;
-    }
-};
-
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
-
-#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
-
-#endif // MSGPACK_TYPE_BOOST_STRING_REF_HPP

include/msgpack/adaptor/char_ptr.hpp

@@ -1,157 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2014-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_CHAR_PTR_HPP
-#define MSGPACK_TYPE_CHAR_PTR_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#include <cstring>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-template <>
-struct pack<const char*> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const char* v) const {
-        uint32_t size = checked_get_container_size(std::strlen(v));
-        o.pack_str(size);
-        o.pack_str_body(v, size);
-        return o;
-    }
-};
-
-template <>
-struct object_with_zone<const char*> {
-    void operator()(msgpack::object::with_zone& o, const char* v) const {
-        uint32_t size = checked_get_container_size(std::strlen(v));
-        o.type = msgpack::type::STR;
-        char* ptr = static_cast<char*>(o.zone.allocate_align(size));
-        o.via.str.ptr = ptr;
-        o.via.str.size = size;
-        std::memcpy(ptr, v, size);
-    }
-};
-
-template <>
-struct object<const char*> {
-    void operator()(msgpack::object& o, const char* v) const {
-        uint32_t size = checked_get_container_size(std::strlen(v));
-        o.type = msgpack::type::STR;
-        o.via.str.ptr = v;
-        o.via.str.size = size;
-    }
-};
-
-
-template <>
-struct pack<char*> {
-    template <typename Stream>
-    packer<Stream>& operator()(packer<Stream>& o, char* v) const {
-        return o << static_cast<const char*>(v);
-    }
-};
-
-template <>
-struct object_with_zone<char*> {
-    void operator()(msgpack::object::with_zone& o, char* v) const {
-        o << static_cast<const char*>(v);
-    }
-};
-
-template <>
-struct object<char*> {
-    void operator()(msgpack::object& o, char* v) const {
-        o << static_cast<const char*>(v);
-    }
-};
-
-template <std::size_t N>
-struct pack<char[N]> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const char* v) const {
-        uint32_t size = checked_get_container_size(std::strlen(v));
-        o.pack_str(size);
-        o.pack_str_body(v, size);
-        return o;
-    }
-};
-
-template <std::size_t N>
-struct object_with_zone<char[N]> {
-    void operator()(msgpack::object::with_zone& o, const char* v) const {
-        uint32_t size = checked_get_container_size(std::strlen(v));
-        o.type = msgpack::type::STR;
-        char* ptr = static_cast<char*>(o.zone.allocate_align(size));
-        o.via.str.ptr = ptr;
-        o.via.str.size = size;
-        std::memcpy(ptr, v, size);
-    }
-};
-
-template <std::size_t N>
-struct object<char[N]> {
-    void operator()(msgpack::object& o, const char* v) const {
-        uint32_t size = checked_get_container_size(std::strlen(v));
-        o.type = msgpack::type::STR;
-        o.via.str.ptr = v;
-        o.via.str.size = size;
-    }
-};
-
-template <std::size_t N>
-struct pack<const char[N]> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const char* v) const {
-        uint32_t size = checked_get_container_size(std::strlen(v));
-        o.pack_str(size);
-        o.pack_str_body(v, size);
-        return o;
-    }
-};
-
-template <std::size_t N>
-struct object_with_zone<const char[N]> {
-    void operator()(msgpack::object::with_zone& o, const char* v) const {
-        uint32_t size = checked_get_container_size(std::strlen(v));
-        o.type = msgpack::type::STR;
-        char* ptr = static_cast<char*>(o.zone.allocate_align(size));
-        o.via.str.ptr = ptr;
-        o.via.str.size = size;
-        std::memcpy(ptr, v, size);
-    }
-};
-
-template <std::size_t N>
-struct object<const char[N]> {
-    void operator()(msgpack::object& o, const char* v) const {
-        uint32_t size = checked_get_container_size(std::strlen(v));
-        o.type = msgpack::type::STR;
-        o.via.str.ptr = v;
-        o.via.str.size = size;
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_CHAR_PTR_HPP

include/msgpack/adaptor/check_container_size.hpp

@@ -1,67 +0,0 @@
-//
-// 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_CHECK_CONTAINER_SIZE_HPP
-#define MSGPACK_CHECK_CONTAINER_SIZE_HPP
-
-#include "msgpack/versioning.hpp"
-#include <stdexcept>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-struct container_size_overflow : public std::runtime_error {
-    explicit container_size_overflow(const std::string& msg)
-        :std::runtime_error(msg) {}
-#if !defined(MSGPACK_USE_CPP03)
-    explicit container_size_overflow(const char* msg):
-        std::runtime_error(msg) {}
-#endif // !defined(MSGPACK_USE_CPP03)
-};
-
-namespace detail {
-
-template <std::size_t N>
-inline void check_container_size(std::size_t size) {
-    if (size > 0xffffffff) throw container_size_overflow("container size overflow");
-}
-
-template <>
-inline void check_container_size<4>(std::size_t /*size*/) {
-}
-
-template <std::size_t N>
-inline void check_container_size_for_ext(std::size_t size) {
-    if (size > 0xffffffff) throw container_size_overflow("container size overflow");
-}
-
-template <>
-inline void check_container_size_for_ext<4>(std::size_t size) {
-    if (size > 0xfffffffe) throw container_size_overflow("container size overflow");
-}
-
-} // namespace detail
-
-template <typename T>
-inline uint32_t checked_get_container_size(T size) {
-    detail::check_container_size<sizeof(T)>(size);
-    return static_cast<uint32_t>(size);
-}
-
-
-/// @cond
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-}  // namespace msgpack
-
-#endif // MSGPACK_CHECK_CONTAINER_SIZE_HPP

include/msgpack/adaptor/cpp11/array.hpp

@@ -1,138 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2014-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_CPP11_ARRAY_HPP
-#define MSGPACK_CPP11_ARRAY_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-#include "msgpack/meta.hpp"
-
-#include <array>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-namespace detail {
-
-namespace array {
-
-template<typename T, std::size_t N1, std::size_t... I1, std::size_t N2, std::size_t... I2>
-inline std::array<T, N1+N2> concat(
-    std::array<T, N1>&& a1,
-    std::array<T, N2>&& a2,
-    msgpack::seq<I1...>,
-    msgpack::seq<I2...>) {
-    return {{ std::move(a1[I1])..., std::move(a2[I2])... }};
-}
-
-template<typename T, std::size_t N1, std::size_t N2>
-inline std::array<T, N1+N2> concat(std::array<T, N1>&& a1, std::array<T, N2>&& a2) {
-    return concat(std::move(a1), std::move(a2), msgpack::gen_seq<N1>(), msgpack::gen_seq<N2>());
-}
-
-template <typename T, std::size_t N>
-struct as_impl {
-    static std::array<T, N> as(msgpack::object const& o) {
-        msgpack::object* p = o.via.array.ptr + N - 1;
-        return concat(as_impl<T, N-1>::as(o), std::array<T, 1>{{p->as<T>()}});
-    }
-};
-
-template <typename T>
-struct as_impl<T, 1> {
-    static std::array<T, 1> as(msgpack::object const& o) {
-        msgpack::object* p = o.via.array.ptr;
-        return std::array<T, 1>{{p->as<T>()}};
-    }
-};
-
-template <typename T>
-struct as_impl<T, 0> {
-    static std::array<T, 0> as(msgpack::object const&) {
-        return std::array<T, 0>();
-    }
-};
-
-} // namespace array
-
-} // namespace detail
-
-template <typename T, std::size_t N>
-struct as<std::array<T, N>, typename std::enable_if<msgpack::has_as<T>::value>::type> {
-    std::array<T, N> operator()(msgpack::object const& o) const {
-        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        if(o.via.array.size != N) { throw msgpack::type_error(); }
-        return detail::array::as_impl<T, N>::as(o);
-    }
-};
-
-template <typename T, std::size_t N>
-struct convert<std::array<T, N>> {
-    msgpack::object const& operator()(msgpack::object const& o, std::array<T, N>& v) const {
-        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        if(o.via.array.size != N) { throw msgpack::type_error(); }
-        if(o.via.array.size > 0) {
-            msgpack::object* p = o.via.array.ptr;
-            msgpack::object* const pend = o.via.array.ptr + o.via.array.size;
-            T* it = &v[0];
-            do {
-                p->convert(*it);
-                ++p;
-                ++it;
-            } while(p < pend);
-        }
-        return o;
-    }
-};
-
-template <typename T, std::size_t N>
-struct pack<std::array<T, N>> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::array<T, N>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.pack_array(size);
-        for(auto const& e : v) o.pack(e);
-        return o;
-    }
-};
-
-template <typename T, std::size_t N>
-struct object_with_zone<std::array<T, N>> {
-    void operator()(msgpack::object::with_zone& o, const std::array<T, N>& v) const {
-        o.type = msgpack::type::ARRAY;
-        if(v.empty()) {
-            o.via.array.ptr = nullptr;
-            o.via.array.size = 0;
-        } else {
-            uint32_t size = checked_get_container_size(v.size());
-            msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
-            o.via.array.size = size;
-            o.via.array.ptr = p;
-            for (auto const& e : v) *p++ = msgpack::object(e, o.zone);
-        }
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
-
-#endif // MSGPACK_CPP11_ARRAY_HPP

include/msgpack/adaptor/cpp11/array_char.hpp

@@ -1,89 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2014-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_ARRAY_CHAR_HPP
-#define MSGPACK_TYPE_ARRAY_CHAR_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#include <array>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-template <std::size_t N>
-struct convert<std::array<char, N>> {
-    msgpack::object const& operator()(msgpack::object const& o, std::array<char, N>& v) const {
-        switch (o.type) {
-        case msgpack::type::BIN:
-            if(o.via.bin.size != N) { throw msgpack::type_error(); }
-            std::memcpy(v.data(), o.via.bin.ptr, o.via.bin.size);
-            break;
-        case msgpack::type::STR:
-            if(o.via.str.size != N) { throw msgpack::type_error(); }
-            std::memcpy(v.data(), o.via.str.ptr, N);
-            break;
-        default:
-            throw msgpack::type_error();
-            break;
-        }
-        return o;
-    }
-};
-
-template <std::size_t N>
-struct pack<std::array<char, N>> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::array<char, N>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.pack_bin(size);
-        o.pack_bin_body(v.data(), size);
-
-        return o;
-    }
-};
-
-template <std::size_t N>
-struct object<std::array<char, N>> {
-    void operator()(msgpack::object& o, const std::array<char, N>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.type = msgpack::type::BIN;
-        o.via.bin.ptr = v.data();
-        o.via.bin.size = size;
-    }
-};
-
-template <std::size_t N>
-struct object_with_zone<std::array<char, N>> {
-    void operator()(msgpack::object::with_zone& o, const std::array<char, N>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.type = msgpack::type::BIN;
-        char* ptr = static_cast<char*>(o.zone.allocate_align(size));
-        o.via.bin.ptr = ptr;
-        o.via.bin.size = size;
-        std::memcpy(ptr, v.data(), size);
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
-
-#endif // MSGPACK_TYPE_ARRAY_CHAR_HPP

include/msgpack/adaptor/cpp11/array_unsigned_char.hpp

@@ -1,89 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2014-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_ARRAY_UNSIGNED_CHAR_HPP
-#define MSGPACK_TYPE_ARRAY_UNSIGNED_CHAR_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#include <array>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-template <std::size_t N>
-struct convert<std::array<unsigned char, N>> {
-    msgpack::object const& operator()(msgpack::object const& o, std::array<unsigned char, N>& v) const {
-        switch (o.type) {
-        case msgpack::type::BIN:
-            if(o.via.bin.size != N) { throw msgpack::type_error(); }
-            std::memcpy(v.data(), o.via.bin.ptr, o.via.bin.size);
-            break;
-        case msgpack::type::STR:
-            if(o.via.str.size != N) { throw msgpack::type_error(); }
-            std::memcpy(v.data(), o.via.str.ptr, N);
-            break;
-        default:
-            throw msgpack::type_error();
-            break;
-        }
-        return o;
-    }
-};
-
-template <std::size_t N>
-struct pack<std::array<unsigned char, N>> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::array<unsigned char, N>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.pack_bin(size);
-        o.pack_bin_body(reinterpret_cast<char const*>(v.data()), size);
-
-        return o;
-    }
-};
-
-template <std::size_t N>
-struct object<std::array<unsigned char, N>> {
-    void operator()(msgpack::object& o, const std::array<unsigned char, N>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.type = msgpack::type::BIN;
-        o.via.bin.ptr = reinterpret_cast<char const*>(v.data());
-        o.via.bin.size = size;
-    }
-};
-
-template <std::size_t N>
-struct object_with_zone<std::array<unsigned char, N>> {
-    void operator()(msgpack::object::with_zone& o, const std::array<unsigned char, N>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.type = msgpack::type::BIN;
-        char* ptr = static_cast<char*>(o.zone.allocate_align(size));
-        o.via.bin.ptr = ptr;
-        o.via.bin.size = size;
-        std::memcpy(ptr, v.data(), size);
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
-
-#endif // MSGPACK_TYPE_ARRAY_UNSIGNED_CHAR_HPP

include/msgpack/adaptor/cpp11/forward_list.hpp

@@ -1,94 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2014 KONDO-2015 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_CPP11_FORWARD_LIST_HPP
-#define MSGPACK_CPP11_FORWARD_LIST_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#include <forward_list>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-template <typename T, typename Alloc>
-    struct as<std::forward_list<T, Alloc>, typename std::enable_if<msgpack::has_as<T>::value>::type> {
-    std::forward_list<T, Alloc> operator()(msgpack::object const& o) const {
-        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        std::forward_list<T, Alloc> v;
-        msgpack::object* p = o.via.array.ptr + o.via.array.size;
-        msgpack::object* const pend = o.via.array.ptr;
-        while (p != pend) {
-            --p;
-            v.push_front(p->as<T>());
-        }
-        return v;
-    }
-};
-
-template <typename T, typename Alloc>
-struct convert<std::forward_list<T, Alloc>> {
-    msgpack::object const& operator()(msgpack::object const& o, std::forward_list<T, Alloc>& v) const {
-        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        v.resize(o.via.array.size);
-        msgpack::object* p = o.via.array.ptr;
-        for (auto &e : v) {
-            p->convert(e);
-            ++p;
-        }
-        return o;
-    }
-};
-
-template <typename T, typename Alloc>
-struct pack<std::forward_list<T, Alloc>> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::forward_list<T, Alloc>& v) const {
-        uint32_t size = checked_get_container_size(std::distance(v.begin(), v.end()));
-        o.pack_array(size);
-        for(auto const& e : v) o.pack(e);
-        return o;
-    }
-};
-
-template <typename T, typename Alloc>
-struct object_with_zone<std::forward_list<T, Alloc>> {
-    void operator()(msgpack::object::with_zone& o, const std::forward_list<T, Alloc>& v) const {
-        o.type = msgpack::type::ARRAY;
-        if(v.empty()) {
-            o.via.array.ptr = nullptr;
-            o.via.array.size = 0;
-        } else {
-            uint32_t size = checked_get_container_size(std::distance(v.begin(), v.end()));
-            o.via.array.size = size;
-            msgpack::object* p = static_cast<msgpack::object*>(
-                o.zone.allocate_align(sizeof(msgpack::object)*size));
-            o.via.array.ptr = p;
-            for(auto const& e : v) *p++ = msgpack::object(e, o.zone);
-        }
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
-
-#endif // MSGPACK_CPP11_FORWARD_LIST_HPP

include/msgpack/adaptor/cpp11/reference_wrapper.hpp

@@ -1,68 +0,0 @@
-//
-// 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_CPP11_REFERENCE_WRAPPER_HPP
-#define MSGPACK_CPP11_REFERENCE_WRAPPER_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#include <memory>
-#include <type_traits>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-template <typename T>
-struct convert<std::reference_wrapper<T>> {
-    msgpack::object const& operator()(msgpack::object const& o, std::reference_wrapper<T>& v) const {
-        msgpack::adaptor::convert<T>()(o, v.get());
-        return o;
-    }
-};
-
-template <typename T>
-struct pack<std::reference_wrapper<T>> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::reference_wrapper<T>& v) const {
-        o.pack(v.get());
-        return o;
-    }
-};
-
-template <typename T>
-struct object<std::reference_wrapper<T> > {
-    void operator()(msgpack::object& o, const std::reference_wrapper<T>& v) const {
-        msgpack::adaptor::object<typename std::remove_const<T>::type>()(o, v.get());
-    }
-};
-
-template <typename T>
-struct object_with_zone<std::reference_wrapper<T>> {
-    void operator()(msgpack::object::with_zone& o, const std::reference_wrapper<T>& v) const {
-        msgpack::adaptor::object_with_zone<typename std::remove_const<T>::type>()(o, v.get());
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
-
-#endif // MSGPACK_CPP11_REFERENCE_WRAPPER_HPP

include/msgpack/adaptor/cpp11/shared_ptr.hpp

@@ -1,82 +0,0 @@
-//
-// 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_CPP11_SHARED_PTR_HPP
-#define MSGPACK_CPP11_SHARED_PTR_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#include <memory>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-template <typename T>
-struct as<std::shared_ptr<T>, typename std::enable_if<msgpack::has_as<T>::value>::type> {
-    std::shared_ptr<T> operator()(msgpack::object const& o) const {
-        if(o.is_nil()) return nullptr;
-        return std::make_shared<T>(o.as<T>());
-    }
-};
-
-template <typename T>
-struct convert<std::shared_ptr<T>> {
-    msgpack::object const& operator()(msgpack::object const& o, std::shared_ptr<T>& v) const {
-        if(o.is_nil()) v.reset();
-        else {
-            v = std::make_shared<T>();
-            msgpack::adaptor::convert<T>()(o, *v);
-        }
-        return o;
-    }
-};
-
-template <typename T>
-struct pack<std::shared_ptr<T>> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::shared_ptr<T>& v) const {
-        if (v) o.pack(*v);
-        else o.pack_nil();
-        return o;
-    }
-};
-
-template <typename T>
-struct object<std::shared_ptr<T> > {
-    void operator()(msgpack::object& o, const std::shared_ptr<T>& v) const {
-        if (v) msgpack::adaptor::object<T>()(o, *v);
-        else o.type = msgpack::type::NIL;
-    }
-};
-
-template <typename T>
-struct object_with_zone<std::shared_ptr<T>> {
-    void operator()(msgpack::object::with_zone& o, const std::shared_ptr<T>& v) const {
-        if (v) msgpack::adaptor::object_with_zone<T>()(o, *v);
-        else o.type = msgpack::type::NIL;
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
-
-#endif // MSGPACK_CPP11_SHARED_PTR_HPP

include/msgpack/adaptor/cpp11/tuple.hpp

@@ -1,176 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// 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)
-//
-#ifndef MSGPACK_CPP11_TUPLE_HPP
-#define MSGPACK_CPP11_TUPLE_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-#include "msgpack/meta.hpp"
-
-#include <tuple>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-// --- Pack from tuple to packer stream ---
-template <typename Stream, typename Tuple, std::size_t N>
-struct StdTuplePacker {
-    static void pack(
-        msgpack::packer<Stream>& o,
-        const Tuple& v) {
-        StdTuplePacker<Stream, Tuple, N-1>::pack(o, v);
-        o.pack(std::get<N-1>(v));
-    }
-};
-
-template <typename Stream, typename Tuple>
-struct StdTuplePacker<Stream, Tuple, 0> {
-    static void pack (
-        msgpack::packer<Stream>&,
-        const Tuple&) {
-    }
-};
-
-namespace adaptor {
-
-template <typename... Args>
-struct pack<std::tuple<Args...>> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(
-        msgpack::packer<Stream>& o,
-        const std::tuple<Args...>& v) const {
-        uint32_t size = checked_get_container_size(sizeof...(Args));
-        o.pack_array(size);
-        StdTuplePacker<Stream, decltype(v), sizeof...(Args)>::pack(o, v);
-        return o;
-    }
-};
-
-} // namespace adaptor
-
-// --- Convert from tuple to object ---
-
-template <typename... Args>
-struct StdTupleAs;
-
-template <typename T, typename... Args>
-struct StdTupleAsImpl {
-    static std::tuple<T, Args...> as(msgpack::object const& o) {
-        return std::tuple_cat(
-            std::make_tuple(o.via.array.ptr[o.via.array.size - sizeof...(Args) - 1].as<T>()),
-            StdTupleAs<Args...>::as(o));
-    }
-};
-
-template <typename... Args>
-struct StdTupleAs {
-    static std::tuple<Args...> as(msgpack::object const& o) {
-        return StdTupleAsImpl<Args...>::as(o);
-    }
-};
-
-template <>
-struct StdTupleAs<> {
-    static std::tuple<> as (msgpack::object const&) {
-        return std::tuple<>();
-    }
-};
-
-template <typename Tuple, std::size_t N>
-struct StdTupleConverter {
-    static void convert(
-        msgpack::object const& o,
-        Tuple& v) {
-        StdTupleConverter<Tuple, N-1>::convert(o, v);
-        o.via.array.ptr[N-1].convert<typename std::remove_reference<decltype(std::get<N-1>(v))>::type>(std::get<N-1>(v));
-    }
-};
-
-template <typename Tuple>
-struct StdTupleConverter<Tuple, 0> {
-    static void convert (
-        msgpack::object const&,
-        Tuple&) {
-    }
-};
-
-namespace adaptor {
-
-template <typename... Args>
-struct as<std::tuple<Args...>, typename std::enable_if<msgpack::all_of<msgpack::has_as, Args...>::value>::type>  {
-    std::tuple<Args...> operator()(
-        msgpack::object const& o) const {
-        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        if (o.via.array.size < sizeof...(Args)) { throw msgpack::type_error(); }
-        return StdTupleAs<Args...>::as(o);
-    }
-};
-
-template <typename... Args>
-struct convert<std::tuple<Args...>> {
-    msgpack::object const& operator()(
-        msgpack::object const& o,
-        std::tuple<Args...>& v) const {
-        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        if(o.via.array.size < sizeof...(Args)) { throw msgpack::type_error(); }
-        StdTupleConverter<decltype(v), sizeof...(Args)>::convert(o, v);
-        return o;
-    }
-};
-
-} // namespace adaptor
-
-// --- Convert from tuple to object with zone ---
-template <typename Tuple, std::size_t N>
-struct StdTupleToObjectWithZone {
-    static void convert(
-        msgpack::object::with_zone& o,
-        const Tuple& v) {
-        StdTupleToObjectWithZone<Tuple, N-1>::convert(o, v);
-        o.via.array.ptr[N-1] = msgpack::object(std::get<N-1>(v), o.zone);
-    }
-};
-
-template <typename Tuple>
-struct StdTupleToObjectWithZone<Tuple, 0> {
-    static void convert (
-        msgpack::object::with_zone&,
-        const Tuple&) {
-    }
-};
-
-namespace adaptor {
-
-template <typename... Args>
-struct object_with_zone<std::tuple<Args...>> {
-    void operator()(
-        msgpack::object::with_zone& o,
-        std::tuple<Args...> const& v) const {
-        uint32_t size = checked_get_container_size(sizeof...(Args));
-        o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
-        o.via.array.size = size;
-        StdTupleToObjectWithZone<decltype(v), sizeof...(Args)>::convert(o, v);
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
-
-#endif // MSGPACK_CPP11_TUPLE_HPP

include/msgpack/adaptor/cpp11/unique_ptr.hpp

@@ -1,82 +0,0 @@
-//
-// 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_CPP11_UNIQUE_PTR_HPP
-#define MSGPACK_CPP11_UNIQUE_PTR_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#include <memory>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-template <typename T>
-struct as<std::unique_ptr<T>, typename std::enable_if<msgpack::has_as<T>::value>::type> {
-    std::unique_ptr<T> operator()(msgpack::object const& o) const {
-        if(o.is_nil()) return nullptr;
-        return std::unique_ptr<T>(new T(o.as<T>()));
-    }
-};
-
-template <typename T>
-struct convert<std::unique_ptr<T>> {
-    msgpack::object const& operator()(msgpack::object const& o, std::unique_ptr<T>& v) const {
-        if(o.is_nil()) v.reset();
-        else {
-            v.reset(new T);
-            msgpack::adaptor::convert<T>()(o, *v);
-        }
-        return o;
-    }
-};
-
-template <typename T>
-struct pack<std::unique_ptr<T>> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::unique_ptr<T>& v) const {
-        if (v) o.pack(*v);
-        else o.pack_nil();
-        return o;
-    }
-};
-
-template <typename T>
-struct object<std::unique_ptr<T> > {
-    void operator()(msgpack::object& o, const std::unique_ptr<T>& v) const {
-        if (v) msgpack::adaptor::object<T>()(o, *v);
-        else o.type = msgpack::type::NIL;
-    }
-};
-
-template <typename T>
-struct object_with_zone<std::unique_ptr<T>> {
-    void operator()(msgpack::object::with_zone& o, const std::unique_ptr<T>& v) const {
-        if (v) msgpack::adaptor::object_with_zone<T>()(o, *v);
-        else o.type = msgpack::type::NIL;
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
-
-#endif // MSGPACK_CPP11_UNIQUE_PTR_HPP

include/msgpack/adaptor/cpp11/unordered_map.hpp

@@ -1,182 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2014-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_UNORDERED_MAP_HPP
-#define MSGPACK_TYPE_UNORDERED_MAP_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#include <unordered_map>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
-struct as<
-    std::unordered_map<K, V, Hash, Compare, Alloc>,
-    typename std::enable_if<msgpack::has_as<K>::value && msgpack::has_as<V>::value>::type> {
-    std::unordered_map<K, V, Hash, Compare, Alloc> operator()(msgpack::object const& o) const {
-        if (o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
-        msgpack::object_kv* p(o.via.map.ptr);
-        msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
-        std::unordered_map<K, V, Hash, Compare, Alloc> v;
-        for (; p != pend; ++p) {
-            v.emplace(p->key.as<K>(), p->val.as<V>());
-        }
-        return v;
-    }
-};
-
-template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
-struct convert<std::unordered_map<K, V, Hash, Compare, Alloc>> {
-    msgpack::object const& operator()(msgpack::object const& o, std::unordered_map<K, V, Hash, Compare, Alloc>& v) const {
-        if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
-        msgpack::object_kv* p(o.via.map.ptr);
-        msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
-        std::unordered_map<K, V, Hash, Compare, Alloc> tmp;
-        for(; p != pend; ++p) {
-            K key;
-            p->key.convert(key);
-            p->val.convert(tmp[std::move(key)]);
-        }
-        v = std::move(tmp);
-        return o;
-    }
-};
-
-template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
-struct pack<std::unordered_map<K, V, Hash, Compare, Alloc>> {
-    template <typename Stream>
-        msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::unordered_map<K, V, Hash, Compare, Alloc>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.pack_map(size);
-        for(typename std::unordered_map<K, V, Hash, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
-            it != it_end; ++it) {
-            o.pack(it->first);
-            o.pack(it->second);
-        }
-        return o;
-    }
-};
-
-template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
-struct object_with_zone<std::unordered_map<K, V, Hash, Compare, Alloc>> {
-    void operator()(msgpack::object::with_zone& o, const std::unordered_map<K, V, Hash, Compare, Alloc>& v) const {
-        o.type = msgpack::type::MAP;
-        if(v.empty()) {
-            o.via.map.ptr  = nullptr;
-            o.via.map.size = 0;
-        } else {
-            uint32_t size = checked_get_container_size(v.size());
-            msgpack::object_kv* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size));
-            msgpack::object_kv* const pend = p + size;
-            o.via.map.ptr  = p;
-            o.via.map.size = size;
-            typename std::unordered_map<K, V, Hash, Compare, Alloc>::const_iterator it(v.begin());
-            do {
-                p->key = msgpack::object(it->first, o.zone);
-                p->val = msgpack::object(it->second, o.zone);
-                ++p;
-                ++it;
-            } while(p < pend);
-        }
-    }
-};
-
-
-template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
-struct as<
-    std::unordered_multimap<K, V, Hash, Compare, Alloc>,
-    typename std::enable_if<msgpack::has_as<K>::value && msgpack::has_as<V>::value>::type> {
-    std::unordered_multimap<K, V, Hash, Compare, Alloc> operator()(msgpack::object const& o) const {
-        if (o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
-        msgpack::object_kv* p(o.via.map.ptr);
-        msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
-        std::unordered_multimap<K, V, Hash, Compare, Alloc> v;
-        for (; p != pend; ++p) {
-            v.emplace(p->key.as<K>(), p->val.as<V>());
-        }
-        return v;
-    }
-};
-
-template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
-struct convert<std::unordered_multimap<K, V, Hash, Compare, Alloc>> {
-    msgpack::object const& operator()(msgpack::object const& o, std::unordered_multimap<K, V, Hash, Compare, Alloc>& v) const {
-        if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
-        msgpack::object_kv* p(o.via.map.ptr);
-        msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
-        std::unordered_multimap<K, V, Hash, Compare, Alloc> tmp;
-        for(; p != pend; ++p) {
-            std::pair<K, V> value;
-            p->key.convert(value.first);
-            p->val.convert(value.second);
-            tmp.insert(std::move(value));
-        }
-        v = std::move(tmp);
-        return o;
-    }
-};
-
-template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
-struct pack<std::unordered_multimap<K, V, Hash, Compare, Alloc>> {
-    template <typename Stream>
-        msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::unordered_multimap<K, V, Hash, Compare, Alloc>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.pack_map(size);
-        for(typename std::unordered_multimap<K, V, Hash, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
-            it != it_end; ++it) {
-            o.pack(it->first);
-            o.pack(it->second);
-        }
-        return o;
-    }
-};
-
-template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
-struct object_with_zone<std::unordered_multimap<K, V, Hash, Compare, Alloc>> {
-    void operator()(msgpack::object::with_zone& o, const std::unordered_multimap<K, V, Hash, Compare, Alloc>& v) const {
-        o.type = msgpack::type::MAP;
-        if(v.empty()) {
-            o.via.map.ptr  = nullptr;
-            o.via.map.size = 0;
-        } else {
-            uint32_t size = checked_get_container_size(v.size());
-            msgpack::object_kv* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size));
-            msgpack::object_kv* const pend = p + size;
-            o.via.map.ptr  = p;
-            o.via.map.size = size;
-            typename std::unordered_multimap<K, V, Hash, Compare, Alloc>::const_iterator it(v.begin());
-            do {
-                p->key = msgpack::object(it->first, o.zone);
-                p->val = msgpack::object(it->second, o.zone);
-                ++p;
-                ++it;
-            } while(p < pend);
-        }
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
-
-
-#endif // MSGPACK_TYPE_UNORDERED_MAP_HPP

include/msgpack/adaptor/cpp11/unordered_set.hpp

@@ -1,172 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2014-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_UNORDERED_SET_HPP
-#define MSGPACK_TYPE_UNORDERED_SET_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#include <unordered_set>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-template <typename Key, typename Hash, typename Compare, typename Alloc>
-struct as<std::unordered_set<Key, Hash, Compare, Alloc>, typename std::enable_if<msgpack::has_as<Key>::value>::type> {
-    std::unordered_set<Key, Hash, Compare, Alloc> operator()(msgpack::object const& o) const {
-        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        msgpack::object* p = o.via.array.ptr + o.via.array.size;
-        msgpack::object* const pbegin = o.via.array.ptr;
-        std::unordered_set<Key, Hash, Compare, Alloc> v;
-        while (p > pbegin) {
-            --p;
-            v.insert(p->as<Key>());
-        }
-        return v;
-    }
-};
-
-template <typename Key, typename Hash, typename Compare, typename Alloc>
-struct convert<std::unordered_set<Key, Hash, Compare, Alloc>> {
-    msgpack::object const& operator()(msgpack::object const& o, std::unordered_set<Key, Hash, Compare, Alloc>& v) const {
-        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        msgpack::object* p = o.via.array.ptr + o.via.array.size;
-        msgpack::object* const pbegin = o.via.array.ptr;
-        std::unordered_set<Key, Hash, Compare, Alloc> tmp;
-        while(p > pbegin) {
-            --p;
-            tmp.insert(p->as<Key>());
-        }
-        v = std::move(tmp);
-        return o;
-    }
-};
-
-template <typename Key, typename Hash, typename Compare, typename Alloc>
-struct pack<std::unordered_set<Key, Hash, Compare, Alloc>> {
-    template <typename Stream>
-        msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::unordered_set<Key, Hash, Compare, Alloc>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.pack_array(size);
-        for(typename std::unordered_set<Key, Hash, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
-            it != it_end; ++it) {
-            o.pack(*it);
-        }
-        return o;
-    }
-};
-
-template <typename Key, typename Hash, typename Compare, typename Alloc>
-struct object_with_zone<std::unordered_set<Key, Hash, Compare, Alloc>> {
-    void operator()(msgpack::object::with_zone& o, const std::unordered_set<Key, Hash, Compare, Alloc>& v) const {
-        o.type = msgpack::type::ARRAY;
-        if(v.empty()) {
-            o.via.array.ptr = nullptr;
-            o.via.array.size = 0;
-        } else {
-            uint32_t size = checked_get_container_size(v.size());
-            msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
-            msgpack::object* const pend = p + size;
-            o.via.array.ptr = p;
-            o.via.array.size = size;
-            typename std::unordered_set<Key, Hash, Compare, Alloc>::const_iterator it(v.begin());
-            do {
-                *p = msgpack::object(*it, o.zone);
-                ++p;
-                ++it;
-            } while(p < pend);
-        }
-    }
-};
-
-
-template <typename Key, typename Hash, typename Compare, typename Alloc>
-struct as<std::unordered_multiset<Key, Hash, Compare, Alloc>, typename std::enable_if<msgpack::has_as<Key>::value>::type> {
-    std::unordered_multiset<Key, Hash, Compare, Alloc> operator()(msgpack::object const& o) const {
-        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        msgpack::object* p = o.via.array.ptr + o.via.array.size;
-        msgpack::object* const pbegin = o.via.array.ptr;
-        std::unordered_multiset<Key, Hash, Compare, Alloc> v;
-        while (p > pbegin) {
-            --p;
-            v.insert(p->as<Key>());
-        }
-        return v;
-    }
-};
-
-template <typename Key, typename Hash, typename Compare, typename Alloc>
-struct convert<std::unordered_multiset<Key, Hash, Compare, Alloc>> {
-    msgpack::object const& operator()(msgpack::object const& o, std::unordered_multiset<Key, Hash, Compare, Alloc>& v) const {
-        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        msgpack::object* p = o.via.array.ptr + o.via.array.size;
-        msgpack::object* const pbegin = o.via.array.ptr;
-        std::unordered_multiset<Key, Hash, Compare, Alloc> tmp;
-        while(p > pbegin) {
-            --p;
-            tmp.insert(p->as<Key>());
-        }
-        v = std::move(tmp);
-        return o;
-    }
-};
-
-template <typename Key, typename Hash, typename Compare, typename Alloc>
-struct pack<std::unordered_multiset<Key, Hash, Compare, Alloc>> {
-    template <typename Stream>
-        msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::unordered_multiset<Key, Hash, Compare, Alloc>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.pack_array(size);
-        for(typename std::unordered_multiset<Key, Hash, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
-            it != it_end; ++it) {
-            o.pack(*it);
-        }
-        return o;
-    }
-};
-
-template <typename Key, typename Hash, typename Compare, typename Alloc>
-struct object_with_zone<std::unordered_multiset<Key, Hash, Compare, Alloc>> {
-    void operator()(msgpack::object::with_zone& o, const std::unordered_multiset<Key, Hash, Compare, Alloc>& v) const {
-        o.type = msgpack::type::ARRAY;
-        if(v.empty()) {
-            o.via.array.ptr = nullptr;
-            o.via.array.size = 0;
-        } else {
-            uint32_t size = checked_get_container_size(v.size());
-            msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
-            msgpack::object* const pend = p + size;
-            o.via.array.ptr = p;
-            o.via.array.size = size;
-            typename std::unordered_multiset<Key, Hash, Compare, Alloc>::const_iterator it(v.begin());
-            do {
-                *p = msgpack::object(*it, o.zone);
-                ++p;
-                ++it;
-            } while(p < pend);
-        }
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
-
-#endif // MSGPACK_TYPE_UNORDERED_SET_HPP

include/msgpack/adaptor/define.hpp

@@ -1,31 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2014 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_DEFINE_HPP
-#define MSGPACK_DEFINE_HPP
-
-#include "msgpack/cpp_config.hpp"
-
-#if defined(MSGPACK_USE_CPP03)
-#include "detail/cpp03_define_array.hpp"
-#include "detail/cpp03_define_map.hpp"
-#else  // MSGPACK_USE_CPP03
-#include "detail/cpp11_define_array.hpp"
-#include "detail/cpp11_define_map.hpp"
-#endif // MSGPACK_USE_CPP03
-
-#if defined(MSGPACK_USE_DEFINE_MAP)
-#define MSGPACK_DEFINE MSGPACK_DEFINE_MAP
-#define MSGPACK_BASE MSGPACK_BASE_MAP
-#else  // defined(MSGPACK_USE_DEFINE_MAP)
-#define MSGPACK_DEFINE MSGPACK_DEFINE_ARRAY
-#define MSGPACK_BASE MSGPACK_BASE_ARRAY
-#endif // defined(MSGPACK_USE_DEFINE_MAP)
-
-#endif // MSGPACK_DEFINE_HPP

include/msgpack/adaptor/deque.hpp

@@ -1,108 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2015 FURUHASHI Sadayuki
-//
-//    Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//    http://www.boost.org/LICENSE_1_0.txt)
-//
-#ifndef MSGPACK_TYPE_DEQUE_HPP
-#define MSGPACK_TYPE_DEQUE_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#include <deque>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-#if !defined(MSGPACK_USE_CPP03)
-
-template <typename T, typename Alloc>
-struct as<std::deque<T, Alloc>, typename std::enable_if<msgpack::has_as<T>::value>::type> {
-    std::deque<T, Alloc> operator()(const msgpack::object& o) const {
-        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        std::deque<T, Alloc> v;
-        if (o.via.array.size > 0) {
-            msgpack::object* p = o.via.array.ptr;
-            msgpack::object* const pend = o.via.array.ptr + o.via.array.size;
-            do {
-                v.push_back(p->as<T>());
-                ++p;
-            } while (p < pend);
-        }
-        return v;
-    }
-};
-
-#endif // !defined(MSGPACK_USE_CPP03)
-
-template <typename T, typename Alloc>
-struct convert<std::deque<T, Alloc> > {
-    msgpack::object const& operator()(msgpack::object const& o, std::deque<T, Alloc>& v) const {
-        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        v.resize(o.via.array.size);
-        msgpack::object* p = o.via.array.ptr;
-        msgpack::object* const pend = o.via.array.ptr + o.via.array.size;
-        typename std::deque<T, Alloc>::iterator it = v.begin();
-        for(; p < pend; ++p, ++it) {
-            p->convert(*it);
-        }
-        return o;
-    }
-};
-
-template <typename T, typename Alloc>
-struct pack<std::deque<T, Alloc> > {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::deque<T, Alloc>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.pack_array(size);
-        for(typename std::deque<T, Alloc>::const_iterator it(v.begin()), it_end(v.end());
-            it != it_end; ++it) {
-            o.pack(*it);
-        }
-        return o;
-    }
-};
-
-template <typename T, typename Alloc>
-struct object_with_zone<std::deque<T, Alloc> > {
-    void operator()(msgpack::object::with_zone& o, const std::deque<T, Alloc>& v) const {
-        o.type = msgpack::type::ARRAY;
-        if(v.empty()) {
-            o.via.array.ptr = nullptr;
-            o.via.array.size = 0;
-        } else {
-            uint32_t size = checked_get_container_size(v.size());
-            msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
-            msgpack::object* const pend = p + size;
-            o.via.array.ptr = p;
-            o.via.array.size = size;
-            typename std::deque<T, Alloc>::const_iterator it(v.begin());
-            do {
-                *p = msgpack::object(*it, o.zone);
-                ++p;
-                ++it;
-            } while(p < pend);
-        }
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-}  // namespace msgpack
-
-#endif /* msgpack/type/deque.hpp */

include/msgpack/adaptor/detail/cpp11_define_array.hpp

@@ -1,193 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2013 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_CPP11_DEFINE_ARRAY_HPP
-#define MSGPACK_CPP11_DEFINE_ARRAY_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-
-// for MSGPACK_ADD_ENUM
-#include "msgpack/adaptor/int.hpp"
-
-#include <type_traits>
-#include <tuple>
-
-#define MSGPACK_DEFINE_ARRAY(...) \
-    template <typename Packer> \
-    void msgpack_pack(Packer& pk) const \
-    { \
-        msgpack::type::make_define_array(__VA_ARGS__).msgpack_pack(pk); \
-    } \
-    void msgpack_unpack(msgpack::object const& o) \
-    { \
-        msgpack::type::make_define_array(__VA_ARGS__).msgpack_unpack(o); \
-    }\
-    template <typename MSGPACK_OBJECT> \
-    void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone& z) const \
-    { \
-        msgpack::type::make_define_array(__VA_ARGS__).msgpack_object(o, z); \
-    }
-
-#define MSGPACK_BASE_ARRAY(base) (*const_cast<base *>(static_cast<base const*>(this)))
-
-// MSGPACK_ADD_ENUM must be used in the global namespace.
-#define MSGPACK_ADD_ENUM(enum_name) \
-  namespace msgpack { \
-  /** @cond */ \
-  MSGPACK_API_VERSION_NAMESPACE(v1) { \
-  /** @endcond */ \
-  namespace adaptor { \
-    template<> \
-    struct convert<enum_name> { \
-      msgpack::object const& operator()(msgpack::object const& o, enum_name& v) const { \
-        std::underlying_type<enum_name>::type tmp; \
-        o >> tmp; \
-        v = static_cast<enum_name>(tmp);   \
-        return o; \
-      } \
-    }; \
-    template<> \
-    struct object<enum_name> { \
-      void operator()(msgpack::object& o, const enum_name& v) const { \
-        auto tmp = static_cast<std::underlying_type<enum_name>::type>(v); \
-        o << tmp; \
-      } \
-    }; \
-    template<> \
-    struct object_with_zone<enum_name> { \
-      void operator()(msgpack::object::with_zone& o, const enum_name& v) const {  \
-        auto tmp = static_cast<std::underlying_type<enum_name>::type>(v); \
-        o << tmp; \
-      } \
-    }; \
-    template <> \
-    struct pack<enum_name> { \
-      template <typename Stream> \
-      msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const enum_name& v) const { \
-        return o << static_cast<std::underlying_type<enum_name>::type>(v); \
-      } \
-    }; \
-  } \
-  /** @cond */ \
-  } \
-  /** @endcond */ \
-  }
-
-namespace msgpack {
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-namespace type {
-
-template <typename Tuple, std::size_t N>
-struct define_array_imp {
-    template <typename Packer>
-    static void pack(Packer& pk, Tuple const& t) {
-        define_array_imp<Tuple, N-1>::pack(pk, t);
-        pk.pack(std::get<N-1>(t));
-    }
-    static void unpack(msgpack::object const& o, Tuple& t) {
-        define_array_imp<Tuple, N-1>::unpack(o, t);
-        const size_t size = o.via.array.size;
-        if(size <= N-1) { return; }
-        o.via.array.ptr[N-1].convert(std::get<N-1>(t));
-    }
-    static void object(msgpack::object* o, msgpack::zone& z, Tuple const& t) {
-        define_array_imp<Tuple, N-1>::object(o, z, t);
-        o->via.array.ptr[N-1] = msgpack::object(std::get<N-1>(t), z);
-    }
-};
-
-template <typename Tuple>
-struct define_array_imp<Tuple, 1> {
-    template <typename Packer>
-    static void pack(Packer& pk, Tuple const& t) {
-        pk.pack(std::get<0>(t));
-    }
-    static void unpack(msgpack::object const& o, Tuple& t) {
-        const size_t size = o.via.array.size;
-        if(size <= 0) { return; }
-        o.via.array.ptr[0].convert(std::get<0>(t));
-    }
-    static void object(msgpack::object* o, msgpack::zone& z, Tuple const& t) {
-        o->via.array.ptr[0] = msgpack::object(std::get<0>(t), z);
-    }
-};
-
-template <typename... Args>
-struct define_array {
-    typedef define_array<Args...> value_type;
-    typedef std::tuple<Args...> tuple_type;
-    define_array(Args&... args) :
-        a(args...) {}
-    template <typename Packer>
-    void msgpack_pack(Packer& pk) const
-    {
-        pk.pack_array(sizeof...(Args));
-
-        define_array_imp<std::tuple<Args&...>, sizeof...(Args)>::pack(pk, a);
-    }
-    void msgpack_unpack(msgpack::object const& o)
-    {
-        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-
-        define_array_imp<std::tuple<Args&...>, sizeof...(Args)>::unpack(o, a);
-    }
-    void msgpack_object(msgpack::object* o, msgpack::zone& z) const
-    {
-        o->type = msgpack::type::ARRAY;
-        o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*sizeof...(Args)));
-        o->via.array.size = sizeof...(Args);
-
-        define_array_imp<std::tuple<Args&...>, sizeof...(Args)>::object(o, z, a);
-    }
-
-    std::tuple<Args&...> a;
-};
-
-template <>
-struct define_array<> {
-    typedef define_array<> value_type;
-    typedef std::tuple<> tuple_type;
-    template <typename Packer>
-    void msgpack_pack(Packer& pk) const
-    {
-        pk.pack_array(0);
-    }
-    void msgpack_unpack(msgpack::object const& o)
-    {
-        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-    }
-    void msgpack_object(msgpack::object* o, msgpack::zone&) const
-    {
-        o->type = msgpack::type::ARRAY;
-        o->via.array.ptr = NULL;
-        o->via.array.size = 0;
-    }
-};
-
-inline define_array<> make_define_array()
-{
-    return define_array<>();
-}
-
-template <typename... Args>
-inline define_array<Args...> make_define_array(Args&... args)
-{
-    return define_array<Args...>(args...);
-}
-
-}  // namespace type
-/// @cond
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-}  // namespace msgpack
-
-#endif // MSGPACK_CPP11_DEFINE_ARRAY_HPP

include/msgpack/adaptor/detail/cpp11_define_map.hpp

@@ -1,163 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2013 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_CPP11_DEFINE_MAP_HPP
-#define MSGPACK_CPP11_DEFINE_MAP_HPP
-
-// BOOST_PP_VARIADICS is defined in boost/preprocessor/config/config.hpp
-// http://www.boost.org/libs/preprocessor/doc/ref/variadics.html
-// However, supporting compiler detection is not complete. msgpack-c requires
-// variadic macro arguments support. So BOOST_PP_VARIADICS is defined here explicitly.
-#if !defined(MSGPACK_PP_VARIADICS)
-#define MSGPACK_PP_VARIADICS
-#endif
-
-#include <msgpack/preprocessor.hpp>
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-
-// for MSGPACK_ADD_ENUM
-#include "msgpack/adaptor/int.hpp"
-
-#include <type_traits>
-#include <tuple>
-
-#define MSGPACK_DEFINE_MAP_EACH_PROC(r, data, elem) \
-    MSGPACK_PP_IF( \
-        MSGPACK_PP_IS_BEGIN_PARENS(elem), \
-        elem, \
-        (MSGPACK_PP_STRINGIZE(elem))(elem) \
-    )
-
-#define MSGPACK_DEFINE_MAP_IMPL(...) \
-    MSGPACK_PP_SEQ_TO_TUPLE( \
-        MSGPACK_PP_SEQ_FOR_EACH( \
-            MSGPACK_DEFINE_MAP_EACH_PROC, \
-            0, \
-            MSGPACK_PP_VARIADIC_TO_SEQ(__VA_ARGS__) \
-        ) \
-    )
-
-#define MSGPACK_DEFINE_MAP(...) \
-    template <typename Packer> \
-    void msgpack_pack(Packer& pk) const \
-    { \
-        msgpack::type::make_define_map \
-            MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \
-            .msgpack_pack(pk); \
-    } \
-    void msgpack_unpack(msgpack::object const& o) \
-    { \
-        msgpack::type::make_define_map \
-            MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \
-            .msgpack_unpack(o); \
-    }\
-    template <typename MSGPACK_OBJECT> \
-    void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone& z) const \
-    { \
-        msgpack::type::make_define_map \
-            MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \
-            .msgpack_object(o, z); \
-    }
-
-#define MSGPACK_BASE_MAP(base) \
-    (MSGPACK_PP_STRINGIZE(base))(*const_cast<base *>(static_cast<base const*>(this)))
-
-namespace msgpack {
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-namespace type {
-
-template <typename Tuple, std::size_t N>
-struct define_map_imp {
-    template <typename Packer>
-    static void pack(Packer& pk, Tuple const& t) {
-        define_map_imp<Tuple, N-1>::pack(pk, t);
-        pk.pack(std::get<N-1>(t));
-    }
-    static void unpack(
-        msgpack::object const& o, Tuple const& t,
-        std::map<std::string, msgpack::object const*> const& kvmap) {
-        define_map_imp<Tuple, N-2>::unpack(o, t, kvmap);
-        auto it = kvmap.find(std::get<N-2>(t));
-        if (it != kvmap.end()) {
-            it->second->convert(std::get<N-1>(t));
-        }
-    }
-    static void object(msgpack::object* o, msgpack::zone& z, Tuple const& t) {
-        define_map_imp<Tuple, N-2>::object(o, z, t);
-        o->via.map.ptr[(N-1)/2].key = msgpack::object(std::get<N-2>(t), z);
-        o->via.map.ptr[(N-1)/2].val = msgpack::object(std::get<N-1>(t), z);
-    }
-};
-
-template <typename Tuple>
-struct define_map_imp<Tuple, 0> {
-    template <typename Packer>
-    static void pack(Packer&, Tuple const&) {}
-    static void unpack(
-        msgpack::object const&, Tuple const&,
-        std::map<std::string, msgpack::object const*> const&) {}
-    static void object(msgpack::object*, msgpack::zone&, Tuple const&) {}
-};
-
-template <typename... Args>
-struct define_map {
-    define_map(Args&... args) :
-        a(args...) {}
-    template <typename Packer>
-    void msgpack_pack(Packer& pk) const
-    {
-        static_assert(sizeof...(Args) % 2 == 0, "");
-        pk.pack_map(sizeof...(Args) / 2);
-
-        define_map_imp<std::tuple<Args&...>, sizeof...(Args)>::pack(pk, a);
-    }
-    void msgpack_unpack(msgpack::object const& o) const
-    {
-        if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
-        std::map<std::string, msgpack::object const*> kvmap;
-        for (uint32_t i = 0; i < o.via.map.size; ++i) {
-            kvmap.emplace(
-                std::string(
-                    o.via.map.ptr[i].key.via.str.ptr,
-                    o.via.map.ptr[i].key.via.str.size),
-                &o.via.map.ptr[i].val);
-        }
-        define_map_imp<std::tuple<Args&...>, sizeof...(Args)>::unpack(o, a, kvmap);
-    }
-    void msgpack_object(msgpack::object* o, msgpack::zone& z) const
-    {
-        static_assert(sizeof...(Args) % 2 == 0, "");
-        o->type = msgpack::type::MAP;
-        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*sizeof...(Args)/2));
-        o->via.map.size = sizeof...(Args) / 2;
-
-        define_map_imp<std::tuple<Args&...>, sizeof...(Args)>::object(o, z, a);
-    }
-
-    std::tuple<Args&...> a;
-};
-
-
-template <typename... Args>
-define_map<Args...> make_define_map(Args&... args)
-{
-    return define_map<Args...>(args...);
-}
-
-}  // namespace type
-/// @cond
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-}  // namespace msgpack
-
-#endif // MSGPACK_CPP11_DEFINE_MAP_HPP

include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp

@@ -1,275 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// 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)
-//
-#ifndef MSGPACK_CPP11_MSGPACK_TUPLE_HPP
-#define MSGPACK_CPP11_MSGPACK_TUPLE_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include "msgpack/meta.hpp"
-
-#include <tuple>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace type {
-    // tuple
-    using std::get;
-    using std::tuple_size;
-    using std::tuple_element;
-    using std::uses_allocator;
-    using std::ignore;
-    using std::swap;
-
-    template< class... Types >
-    class tuple : public std::tuple<Types...> {
-    public:
-        using base = std::tuple<Types...>;
-
-        using base::base;
-
-        tuple() = default;
-        tuple(tuple const&) = default;
-        tuple(tuple&&) = default;
-
-        template<typename... OtherTypes>
-        tuple(tuple<OtherTypes...> const& other):base(static_cast<std::tuple<OtherTypes...> const&>(other)) {}
-        template<typename... OtherTypes>
-        tuple(tuple<OtherTypes...> && other):base(static_cast<std::tuple<OtherTypes...> &&>(other)) {}
-
-        tuple& operator=(tuple const&) = default;
-        tuple& operator=(tuple&&) = default;
-
-        template<typename... OtherTypes>
-        tuple& operator=(tuple<OtherTypes...> const& other) {
-            *static_cast<base*>(this) = static_cast<std::tuple<OtherTypes...> const&>(other);
-            return *this;
-        }
-        template<typename... OtherTypes>
-        tuple& operator=(tuple<OtherTypes...> && other) {
-            *static_cast<base*>(this) = static_cast<std::tuple<OtherTypes...> &&>(other);
-            return *this;
-        }
-
-        template< std::size_t I>
-        typename tuple_element<I, base >::type&
-        get() & { return std::get<I>(*this); }
-
-        template< std::size_t I>
-        typename tuple_element<I, base >::type const&
-        get() const& { return std::get<I>(*this); }
-
-        template< std::size_t I>
-        typename tuple_element<I, base >::type&&
-        get() && { return std::get<I>(*this); }
-    };
-
-    template <class... Args>
-    inline tuple<Args...> make_tuple(Args&&... args) {
-        return tuple<Args...>(args...);
-    }
-
-    template<class... Args>
-    inline tuple<Args&&...> forward_as_tuple (Args&&... args) noexcept {
-        return tuple<Args&&...>(std::forward<Args>(args)...);
-    }
-
-    template <class... Tuples>
-    inline auto tuple_cat(Tuples&&... args) ->
-        decltype(
-            std::tuple_cat(std::forward<typename std::remove_reference<Tuples>::type::base>(args)...)
-        ) {
-        return std::tuple_cat(std::forward<typename std::remove_reference<Tuples>::type::base>(args)...);
-    }
-    template <class... Args>
-    inline tuple<Args&...> tie(Args&... args) {
-        return tuple<Args&...>(args...);
-    }
-} // namespace type
-
-// --- Pack from tuple to packer stream ---
-template <typename Stream, typename Tuple, std::size_t N>
-struct MsgpackTuplePacker {
-    static void pack(
-        msgpack::packer<Stream>& o,
-        const Tuple& v) {
-        MsgpackTuplePacker<Stream, Tuple, N-1>::pack(o, v);
-        o.pack(type::get<N-1>(v));
-    }
-};
-
-template <typename Stream, typename Tuple>
-struct MsgpackTuplePacker<Stream, Tuple, 1> {
-    static void pack (
-        msgpack::packer<Stream>& o,
-        const Tuple& v) {
-        o.pack(type::get<0>(v));
-    }
-};
-
-template <typename Stream, typename Tuple>
-struct MsgpackTuplePacker<Stream, Tuple, 0> {
-    static void pack (
-        msgpack::packer<Stream>&,
-        const Tuple&) {
-    }
-};
-
-namespace adaptor {
-
-template <typename... Args>
-struct pack<msgpack::type::tuple<Args...>> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(
-        msgpack::packer<Stream>& o,
-        const msgpack::type::tuple<Args...>& v) const {
-        o.pack_array(sizeof...(Args));
-        MsgpackTuplePacker<Stream, decltype(v), sizeof...(Args)>::pack(o, v);
-        return o;
-    }
-};
-
-} // namespace adaptor
-
-// --- Convert from tuple to object ---
-
-template <typename... Args>
-struct MsgpackTupleAs;
-
-template <typename T, typename... Args>
-struct MsgpackTupleAsImpl {
-    static msgpack::type::tuple<T, Args...> as(msgpack::object const& o) {
-        return msgpack::type::tuple_cat(
-            msgpack::type::make_tuple(o.via.array.ptr[o.via.array.size - sizeof...(Args) - 1].as<T>()),
-            MsgpackTupleAs<Args...>::as(o));
-    }
-};
-
-template <typename... Args>
-struct MsgpackTupleAs {
-    static msgpack::type::tuple<Args...> as(msgpack::object const& o) {
-        return MsgpackTupleAsImpl<Args...>::as(o);
-    }
-};
-
-template <>
-struct MsgpackTupleAs<> {
-    static msgpack::type::tuple<> as (msgpack::object const&) {
-        return msgpack::type::tuple<>();
-    }
-};
-
-template <typename Tuple, std::size_t N>
-struct MsgpackTupleConverter {
-    static void convert(
-        msgpack::object const& o,
-        Tuple& v) {
-        MsgpackTupleConverter<Tuple, N-1>::convert(o, v);
-        o.via.array.ptr[N-1].convert<typename std::remove_reference<decltype(type::get<N-1>(v))>::type>(type::get<N-1>(v));
-    }
-};
-
-template <typename Tuple>
-struct MsgpackTupleConverter<Tuple, 1> {
-    static void convert (
-        msgpack::object const& o,
-        Tuple& v) {
-        o.via.array.ptr[0].convert<typename std::remove_reference<decltype(type::get<0>(v))>::type>(type::get<0>(v));
-    }
-};
-
-template <typename Tuple>
-struct MsgpackTupleConverter<Tuple, 0> {
-    static void convert (
-        msgpack::object const&,
-        Tuple&) {
-    }
-};
-
-namespace adaptor {
-
-template <typename... Args>
-struct as<msgpack::type::tuple<Args...>, typename std::enable_if<msgpack::all_of<msgpack::has_as, Args...>::value>::type>  {
-    msgpack::type::tuple<Args...> operator()(
-        msgpack::object const& o) const {
-        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        if (o.via.array.size < sizeof...(Args)) { throw msgpack::type_error(); }
-        return MsgpackTupleAs<Args...>::as(o);
-    }
-};
-
-template <typename... Args>
-struct convert<msgpack::type::tuple<Args...>> {
-    msgpack::object const& operator()(
-        msgpack::object const& o,
-        msgpack::type::tuple<Args...>& v) const {
-        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        if(o.via.array.size < sizeof...(Args)) { throw msgpack::type_error(); }
-        MsgpackTupleConverter<decltype(v), sizeof...(Args)>::convert(o, v);
-        return o;
-    }
-};
-
-} // namespace adaptor
-
-// --- Convert from tuple to object with zone ---
-template <typename Tuple, std::size_t N>
-struct MsgpackTupleToObjectWithZone {
-    static void convert(
-        msgpack::object::with_zone& o,
-        const Tuple& v) {
-        MsgpackTupleToObjectWithZone<Tuple, N-1>::convert(o, v);
-        o.via.array.ptr[N-1] = msgpack::object(type::get<N-1>(v), o.zone);
-    }
-};
-
-template <typename Tuple>
-struct MsgpackTupleToObjectWithZone<Tuple, 1> {
-    static void convert (
-        msgpack::object::with_zone& o,
-        const Tuple& v) {
-        o.via.array.ptr[0] = msgpack::object(type::get<0>(v), o.zone);
-    }
-};
-
-template <typename Tuple>
-struct MsgpackTupleToObjectWithZone<Tuple, 0> {
-    static void convert (
-        msgpack::object::with_zone&,
-        const Tuple&) {
-    }
-};
-
-namespace adaptor {
-
-template <typename... Args>
-    struct object_with_zone<msgpack::type::tuple<Args...>> {
-    void operator()(
-        msgpack::object::with_zone& o,
-        msgpack::type::tuple<Args...> const& v) const {
-        o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*sizeof...(Args)));
-        o.via.array.size = sizeof...(Args);
-        MsgpackTupleToObjectWithZone<decltype(v), sizeof...(Args)>::convert(o, v);
-    }
-};
-
-}  // namespace adaptor
-
-/// @cond
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-///@endcond
-
-}  // namespace msgpack
-
-#endif // MSGPACK_CPP11_MSGPACK_TUPLE_HPP

include/msgpack/adaptor/ext.hpp

@@ -1,237 +0,0 @@
-//
-// 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_EXT_HPP
-#define MSGPACK_TYPE_EXT_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include <cstring>
-#include <string>
-#include <cassert>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace type {
-class ext_ref;
-
-class ext {
-public:
-    ext() : m_data(1, 0) {}
-    ext(int8_t t, const char* p, uint32_t s) {
-        detail::check_container_size_for_ext<sizeof(std::size_t)>(s);
-        m_data.reserve(static_cast<std::size_t>(s) + 1);
-        m_data.push_back(static_cast<char>(t));
-        m_data.insert(m_data.end(), p, p + s);
-    }
-    ext(int8_t t, uint32_t s) {
-        detail::check_container_size_for_ext<sizeof(std::size_t)>(s);
-        m_data.resize(static_cast<std::size_t>(s) + 1);
-        m_data[0] = static_cast<char>(t);
-    }
-    ext(ext_ref const&);
-    int8_t type() const {
-        return static_cast<int8_t>(m_data[0]);
-    }
-    const char* data() const {
-        return &m_data[1];
-    }
-    char* data() {
-        return &m_data[1];
-    }
-    uint32_t size() const {
-        return static_cast<uint32_t>(m_data.size()) - 1;
-    }
-    bool operator== (const ext& x) const {
-        return m_data == x.m_data;
-    }
-
-    bool operator!= (const ext& x) const {
-        return !(*this == x);
-    }
-
-    bool operator< (const ext& x) const {
-        return m_data < x.m_data;
-    }
-
-    bool operator> (const ext& x) const {
-        return m_data > x.m_data;
-    }
-private:
-    std::vector<char> m_data;
-    friend class ext_ref;
-};
-
-} // namespace type
-
-namespace adaptor {
-
-template <>
-struct convert<msgpack::type::ext> {
-    msgpack::object const& operator()(msgpack::object const& o, msgpack::type::ext& v) const {
-        if(o.type != msgpack::type::EXT) {
-            throw msgpack::type_error();
-        }
-        v = msgpack::type::ext(o.via.ext.type(), o.via.ext.data(), o.via.ext.size);
-        return o;
-    }
-};
-
-template <>
-struct pack<msgpack::type::ext> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const msgpack::type::ext& v) const {
-        // size limit has already been checked at ext's constructor
-        uint32_t size = v.size();
-        o.pack_ext(size, v.type());
-        o.pack_ext_body(v.data(), size);
-        return o;
-    }
-};
-
-template <>
-struct object_with_zone<msgpack::type::ext> {
-    void operator()(msgpack::object::with_zone& o, const msgpack::type::ext& v) const {
-        // size limit has already been checked at ext's constructor
-        uint32_t size = v.size();
-        o.type = msgpack::type::EXT;
-        char* ptr = static_cast<char*>(o.zone.allocate_align(size + 1));
-        o.via.ext.ptr = ptr;
-        o.via.ext.size = size;
-        ptr[0] = static_cast<char>(v.type());
-        std::memcpy(ptr + 1, v.data(), size);
-    }
-};
-
-} // namespace adaptor
-
-namespace type {
-
-class ext_ref {
-public:
-    // ext_ref should be default constructible to support 'convert'.
-    // A default constructed ext_ref object::m_ptr doesn't have the buffer to point to.
-    // In order to avoid nullptr checking branches, m_ptr points to m_size.
-    // So type() returns unspecified but valid value. It might be a zero because m_size
-    // is initialized as zero, but shouldn't assume that.
-    ext_ref() : m_ptr(static_cast<char*>(static_cast<void*>(&m_size))), m_size(0) {}
-    ext_ref(const char* p, uint32_t s) :
-        m_ptr(s == 0 ? static_cast<char*>(static_cast<void*>(&m_size)) : p),
-        m_size(s == 0 ? 0 : s - 1) {
-        detail::check_container_size_for_ext<sizeof(std::size_t)>(s);
-    }
-
-    // size limit has already been checked at ext's constructor
-    ext_ref(ext const& x) : m_ptr(&x.m_data[0]), m_size(x.size()) {}
-
-    const char* data() const {
-        return m_ptr + 1;
-    }
-
-    uint32_t size() const {
-        return m_size;
-    }
-
-    int8_t type() const {
-        return static_cast<int8_t>(m_ptr[0]);
-    }
-
-    std::string str() const {
-        return std::string(m_ptr + 1, m_size);
-    }
-
-    bool operator== (const ext_ref& x) const {
-        return m_size == x.m_size && std::memcmp(m_ptr, x.m_ptr, m_size) == 0;
-    }
-
-    bool operator!= (const ext_ref& x) const {
-        return !(*this == x);
-    }
-
-    bool operator< (const ext_ref& x) const {
-        if (m_size < x.m_size) return true;
-        if (m_size > x.m_size) return false;
-        return std::memcmp(m_ptr, x.m_ptr, m_size) < 0;
-    }
-
-    bool operator> (const ext_ref& x) const {
-        if (m_size > x.m_size) return true;
-        if (m_size < x.m_size) return false;
-        return std::memcmp(m_ptr, x.m_ptr, m_size) > 0;
-    }
-private:
-    const char* m_ptr;
-    uint32_t m_size;
-    friend struct msgpack::adaptor::object<msgpack::type::ext_ref>;
-};
-
-inline ext::ext(ext_ref const& x) {
-    // size limit has already been checked at ext_ref's constructor
-    m_data.reserve(x.size() + 1);
-
-    m_data.push_back(x.type());
-    m_data.insert(m_data.end(), x.data(), x.data() + x.size());
-}
-
-} // namespace type
-
-namespace adaptor {
-
-template <>
-struct convert<msgpack::type::ext_ref> {
-    msgpack::object const& operator()(msgpack::object const& o, msgpack::type::ext_ref& v) const {
-        if(o.type != msgpack::type::EXT) { throw msgpack::type_error(); }
-        v = msgpack::type::ext_ref(o.via.ext.ptr, o.via.ext.size + 1);
-        return o;
-    }
-};
-
-template <>
-struct pack<msgpack::type::ext_ref> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const msgpack::type::ext_ref& v) const {
-        // size limit has already been checked at ext_ref's constructor
-        uint32_t size = v.size();
-        o.pack_ext(size, v.type());
-        o.pack_ext_body(v.data(), size);
-        return o;
-    }
-};
-
-template <>
-struct object<msgpack::type::ext_ref> {
-    void operator()(msgpack::object& o, const msgpack::type::ext_ref& v) const {
-        // size limit has already been checked at ext_ref's constructor
-        uint32_t size = v.size();
-        o.type = msgpack::type::EXT;
-        o.via.ext.ptr = v.m_ptr;
-        o.via.ext.size = size;
-    }
-};
-
-template <>
-struct object_with_zone<msgpack::type::ext_ref> {
-    void operator()(msgpack::object::with_zone& o, const msgpack::type::ext_ref& v) const {
-        static_cast<msgpack::object&>(o) << v;
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
-
-#endif // MSGPACK_TYPE_EXT_HPP

include/msgpack/adaptor/fixint.hpp

@@ -1,298 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2020 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)
-//
-#ifndef MSGPACK_TYPE_FIXINT_HPP
-#define MSGPACK_TYPE_FIXINT_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/int.hpp"
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace type {
-
-
-template <typename T>
-struct fix_int {
-    fix_int() : value(0) { }
-    fix_int(T value) : value(value) { }
-
-    operator T() const { return value; }
-
-    T get() const { return value; }
-
-private:
-    T value;
-};
-
-
-typedef fix_int<uint8_t>  fix_uint8;
-typedef fix_int<uint16_t> fix_uint16;
-typedef fix_int<uint32_t> fix_uint32;
-typedef fix_int<uint64_t> fix_uint64;
-
-typedef fix_int<int8_t>  fix_int8;
-typedef fix_int<int16_t> fix_int16;
-typedef fix_int<int32_t> fix_int32;
-typedef fix_int<int64_t> fix_int64;
-
-
-}  // namespace type
-
-namespace adaptor {
-
-template <>
-struct convert<type::fix_int8> {
-    msgpack::object const& operator()(msgpack::object const& o, type::fix_int8& v) const
-    { v = type::detail::convert_integer<int8_t>(o); return o; }
-};
-
-template <>
-struct convert<type::fix_int16> {
-    msgpack::object const& operator()(msgpack::object const& o, type::fix_int16& v) const
-    { v = type::detail::convert_integer<int16_t>(o); return o; }
-};
-
-template <>
-struct convert<type::fix_int32> {
-    msgpack::object const& operator()(msgpack::object const& o, type::fix_int32& v) const
-    { v = type::detail::convert_integer<int32_t>(o); return o; }
-};
-
-template <>
-struct convert<type::fix_int64> {
-    msgpack::object const& operator()(msgpack::object const& o, type::fix_int64& v) const
-    { v = type::detail::convert_integer<int64_t>(o); return o; }
-};
-
-
-template <>
-struct convert<type::fix_uint8> {
-    msgpack::object const& operator()(msgpack::object const& o, type::fix_uint8& v) const
-    { v = type::detail::convert_integer<uint8_t>(o); return o; }
-};
-
-template <>
-struct convert<type::fix_uint16> {
-    msgpack::object const& operator()(msgpack::object const& o, type::fix_uint16& v) const
-    { v = type::detail::convert_integer<uint16_t>(o); return o; }
-};
-
-template <>
-struct convert<type::fix_uint32> {
-    msgpack::object const& operator()(msgpack::object const& o, type::fix_uint32& v) const
-    { v = type::detail::convert_integer<uint32_t>(o); return o; }
-};
-
-template <>
-struct convert<type::fix_uint64> {
-    msgpack::object const& operator()(msgpack::object const& o, type::fix_uint64& v) const
-    { v = type::detail::convert_integer<uint64_t>(o); return o; }
-};
-
-template <>
-struct pack<type::fix_int8> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const type::fix_int8& v) const
-    { o.pack_fix_int8(v); return o; }
-};
-
-template <>
-struct pack<type::fix_int16> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const type::fix_int16& v) const
-    { o.pack_fix_int16(v); return o; }
-};
-
-template <>
-struct pack<type::fix_int32> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const type::fix_int32& v) const
-    { o.pack_fix_int32(v); return o; }
-};
-
-template <>
-struct pack<type::fix_int64> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const type::fix_int64& v) const
-    { o.pack_fix_int64(v); return o; }
-};
-
-
-template <>
-struct pack<type::fix_uint8> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const type::fix_uint8& v) const
-    { o.pack_fix_uint8(v); return o; }
-};
-
-template <>
-struct pack<type::fix_uint16> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const type::fix_uint16& v) const
-    { o.pack_fix_uint16(v); return o; }
-};
-
-template <>
-struct pack<type::fix_uint32> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const type::fix_uint32& v) const
-    { o.pack_fix_uint32(v); return o; }
-};
-
-template <>
-struct pack<type::fix_uint64> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const type::fix_uint64& v) const
-    { o.pack_fix_uint64(v); return o; }
-};
-
-template <>
-struct object<type::fix_int8> {
-    void operator()(msgpack::object& o, type::fix_int8 v) const {
-        if (v.get() < 0) {
-            o.type = msgpack::type::NEGATIVE_INTEGER;
-            o.via.i64 = v.get();
-        }
-        else {
-            o.type = msgpack::type::POSITIVE_INTEGER;
-            o.via.u64 = v.get();
-        }
-    }
-};
-
-template <>
-struct object<type::fix_int16> {
-    void operator()(msgpack::object& o, type::fix_int16 v) const {
-        if(v.get() < 0) {
-            o.type = msgpack::type::NEGATIVE_INTEGER;
-            o.via.i64 = v.get();
-        }
-        else {
-            o.type = msgpack::type::POSITIVE_INTEGER;
-            o.via.u64 = v.get();
-        }
-    }
-};
-
-template <>
-struct object<type::fix_int32> {
-    void operator()(msgpack::object& o, type::fix_int32 v) const {
-        if (v.get() < 0) {
-            o.type = msgpack::type::NEGATIVE_INTEGER;
-            o.via.i64 = v.get();
-        }
-        else {
-            o.type = msgpack::type::POSITIVE_INTEGER;
-            o.via.u64 = v.get();
-        }
-    }
-};
-
-template <>
-struct object<type::fix_int64> {
-    void operator()(msgpack::object& o, type::fix_int64 v) const {
-        if (v.get() < 0) {
-            o.type = msgpack::type::NEGATIVE_INTEGER;
-            o.via.i64 = v.get();
-        }
-        else {
-            o.type = msgpack::type::POSITIVE_INTEGER;
-            o.via.u64 = v.get();
-        }
-    }
-};
-
-template <>
-struct object<type::fix_uint8> {
-    void operator()(msgpack::object& o, type::fix_uint8 v) const
-    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v.get(); }
-};
-
-template <>
-struct object<type::fix_uint16> {
-    void operator()(msgpack::object& o, type::fix_uint16 v) const
-    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v.get(); }
-};
-
-template <>
-struct object<type::fix_uint32> {
-    void operator()(msgpack::object& o, type::fix_uint32 v) const
-    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v.get(); }
-};
-
-template <>
-struct object<type::fix_uint64> {
-    void operator()(msgpack::object& o, type::fix_uint64 v) const
-    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v.get(); }
-};
-
-template <>
-struct object_with_zone<type::fix_int8> {
-    void operator()(msgpack::object::with_zone& o, type::fix_int8 v) const
-    { static_cast<msgpack::object&>(o) << v; }
-};
-
-template <>
-struct object_with_zone<type::fix_int16> {
-    void operator()(msgpack::object::with_zone& o, type::fix_int16 v) const
-    { static_cast<msgpack::object&>(o) << v; }
-};
-
-template <>
-struct object_with_zone<type::fix_int32> {
-    void operator()(msgpack::object::with_zone& o, type::fix_int32 v) const
-    { static_cast<msgpack::object&>(o) << v; }
-};
-
-template <>
-struct object_with_zone<type::fix_int64> {
-    void operator()(msgpack::object::with_zone& o, type::fix_int64 v) const
-    { static_cast<msgpack::object&>(o) << v; }
-};
-
-
-template <>
-struct object_with_zone<type::fix_uint8> {
-    void operator()(msgpack::object::with_zone& o, type::fix_uint8 v) const
-    { static_cast<msgpack::object&>(o) << v; }
-};
-
-template <>
-struct object_with_zone<type::fix_uint16> {
-    void operator()(msgpack::object::with_zone& o, type::fix_uint16 v) const
-    { static_cast<msgpack::object&>(o) << v; }
-};
-
-template <>
-struct object_with_zone<type::fix_uint32> {
-    void operator()(msgpack::object::with_zone& o, type::fix_uint32 v) const
-    { static_cast<msgpack::object&>(o) << v; }
-};
-
-template <>
-struct object_with_zone<type::fix_uint64> {
-    void operator()(msgpack::object::with_zone& o, type::fix_uint64 v) const
-    { static_cast<msgpack::object&>(o) << v; }
-};
-
-} // namespace adaptor
-
-/// @cond
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-}  // namespace msgpack
-
-#endif /* msgpack/type/fixint.hpp */

include/msgpack/adaptor/float.hpp

@@ -1,123 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// 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)
-//
-#ifndef MSGPACK_TYPE_FLOAT_HPP
-#define MSGPACK_TYPE_FLOAT_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include <vector>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-// FIXME check overflow, underflow
-
-namespace adaptor {
-
-template <>
-struct convert<float> {
-    msgpack::object const& operator()(msgpack::object const& o, float& v) const {
-        if(o.type == msgpack::type::FLOAT) {
-            v = static_cast<float>(o.via.f64);
-        }
-        else if (o.type == msgpack::type::POSITIVE_INTEGER) {
-            v = static_cast<float>(o.via.u64);
-        }
-        else if (o.type == msgpack::type::NEGATIVE_INTEGER) {
-            v = static_cast<float>(o.via.i64);
-        }
-        else {
-            throw msgpack::type_error();
-        }
-        return o;
-    }
-};
-
-template <>
-struct pack<float> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const float& v) const {
-        o.pack_float(v);
-        return o;
-    }
-};
-
-
-template <>
-struct convert<double> {
-    msgpack::object const& operator()(msgpack::object const& o, double& v) const {
-        if(o.type == msgpack::type::FLOAT) {
-            v = o.via.f64;
-        }
-        else if (o.type == msgpack::type::POSITIVE_INTEGER) {
-            v = static_cast<double>(o.via.u64);
-        }
-        else if (o.type == msgpack::type::NEGATIVE_INTEGER) {
-            v = static_cast<double>(o.via.i64);
-        }
-        else {
-            throw msgpack::type_error();
-        }
-        return o;
-    }
-};
-
-template <>
-struct pack<double> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const double& v) const {
-        o.pack_double(v);
-        return o;
-    }
-};
-
-
-template <>
-struct object<float> {
-    void operator()(msgpack::object& o, float v) const {
-        o.type = msgpack::type::FLOAT;
-        o.via.f64 = static_cast<double>(v);
-    }
-};
-
-template <>
-struct object<double> {
-    void operator()(msgpack::object& o, double v) const {
-        o.type = msgpack::type::FLOAT;
-        o.via.f64 = v;
-    }
-};
-
-template <>
-struct object_with_zone<float> {
-    void operator()(msgpack::object::with_zone& o, float v) const {
-        static_cast<msgpack::object&>(o) << v;
-    }
-};
-
-template <>
-struct object_with_zone<double> {
-    void operator()(msgpack::object::with_zone& o, double v) const {
-        static_cast<msgpack::object&>(o) << v;
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_FLOAT_HPP

include/msgpack/adaptor/int.hpp

@@ -1,430 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// 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)
-//
-#ifndef MSGPACK_TYPE_INT_HPP
-#define MSGPACK_TYPE_INT_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include <limits>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1){
-/// @endcond
-
-namespace type {
-namespace detail {
-    template <typename T, bool Signed>
-    struct convert_integer_sign;
-
-    template <typename T>
-    struct convert_integer_sign<T, true> {
-        static T convert(msgpack::object const& o) {
-            if(o.type == msgpack::type::POSITIVE_INTEGER) {
-                if(o.via.u64 > static_cast<uint64_t>(std::numeric_limits<T>::max()))
-                    { throw msgpack::type_error(); }
-                return static_cast<T>(o.via.u64);
-            } else if(o.type == msgpack::type::NEGATIVE_INTEGER) {
-                if(o.via.i64 < static_cast<int64_t>(std::numeric_limits<T>::min()))
-                    { throw msgpack::type_error(); }
-                return static_cast<T>(o.via.i64);
-            }
-            throw msgpack::type_error();
-        }
-    };
-
-    template <typename T>
-    struct convert_integer_sign<T, false> {
-        static T convert(msgpack::object const& o) {
-            if(o.type == msgpack::type::POSITIVE_INTEGER) {
-                if(o.via.u64 > static_cast<uint64_t>(std::numeric_limits<T>::max()))
-                    { throw msgpack::type_error(); }
-                return static_cast<T>(o.via.u64);
-            }
-            throw msgpack::type_error();
-        }
-    };
-
-    template <typename T>
-    struct is_signed {
-        static const bool value = std::numeric_limits<T>::is_signed;
-    };
-
-    template <typename T>
-    static inline T convert_integer(msgpack::object const& o)
-    {
-        return detail::convert_integer_sign<T, is_signed<T>::value>::convert(o);
-    }
-
-    template <bool Signed>
-    struct object_char_sign;
-
-    template <>
-    struct object_char_sign<true> {
-        template <typename T>
-        static typename msgpack::enable_if<msgpack::is_same<T, char>::value>::type
-        make(msgpack::object& o, T v) {
-            if (v < 0) {
-                o.type = msgpack::type::NEGATIVE_INTEGER;
-                o.via.i64 = v;
-            }
-            else {
-                o.type = msgpack::type::POSITIVE_INTEGER;
-                o.via.u64 = v;
-            }
-        }
-    };
-
-    template <>
-    struct object_char_sign<false> {
-        static void make(msgpack::object& o, char v) {
-            o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v;
-        }
-    };
-
-    static inline void object_char(msgpack::object& o, char v) {
-        return object_char_sign<is_signed<char>::value>::make(o, v);
-    }
-
-}  // namespace detail
-}  // namespace type
-
-namespace adaptor {
-
-template <>
-struct convert<char> {
-    msgpack::object const& operator()(msgpack::object const& o, char& v) const
-    { v = type::detail::convert_integer<char>(o); return o; }
-};
-
-template <>
-struct convert<signed char> {
-    msgpack::object const& operator()(msgpack::object const& o, signed char& v) const
-    { v = type::detail::convert_integer<signed char>(o); return o; }
-};
-
-template <>
-struct convert<signed short> {
-    msgpack::object const& operator()(msgpack::object const& o, signed short& v) const
-    { v = type::detail::convert_integer<signed short>(o); return o; }
-};
-
-template <>
-struct convert<signed int> {
-    msgpack::object const& operator()(msgpack::object const& o, signed int& v) const
-    { v = type::detail::convert_integer<signed int>(o); return o; }
-};
-
-template <>
-struct convert<signed long> {
-    msgpack::object const& operator()(msgpack::object const& o, signed long& v) const
-    { v = type::detail::convert_integer<signed long>(o); return o; }
-};
-
-template <>
-struct convert<signed long long> {
-    msgpack::object const& operator()(msgpack::object const& o, signed long long& v) const
-    { v = type::detail::convert_integer<signed long long>(o); return o; }
-};
-
-
-template <>
-struct convert<unsigned char> {
-    msgpack::object const& operator()(msgpack::object const& o, unsigned char& v) const
-    { v = type::detail::convert_integer<unsigned char>(o); return o; }
-};
-
-template <>
-struct convert<unsigned short> {
-    msgpack::object const& operator()(msgpack::object const& o, unsigned short& v) const
-    { v = type::detail::convert_integer<unsigned short>(o); return o; }
-};
-
-template <>
-struct convert<unsigned int> {
-    msgpack::object const& operator()(msgpack::object const& o, unsigned int& v) const
-    { v = type::detail::convert_integer<unsigned int>(o); return o; }
-};
-
-template <>
-struct convert<unsigned long> {
-    msgpack::object const& operator()(msgpack::object const& o, unsigned long& v) const
-    { v = type::detail::convert_integer<unsigned long>(o); return o; }
-};
-
-template <>
-struct convert<unsigned long long> {
-    msgpack::object const& operator()(msgpack::object const& o, unsigned long long& v) const
-    { v = type::detail::convert_integer<unsigned long long>(o); return o; }
-};
-
-
-template <>
-struct pack<char> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, char v) const
-    { o.pack_char(v); return o; }
-};
-
-template <>
-struct pack<signed char> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, signed char v) const
-    { o.pack_signed_char(v); return o; }
-};
-
-template <>
-struct pack<signed short> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, signed short v) const
-    { o.pack_short(v); return o; }
-};
-
-template <>
-struct pack<signed int> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, signed int v) const
-    { o.pack_int(v); return o; }
-};
-
-template <>
-struct pack<signed long> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, signed long v) const
-    { o.pack_long(v); return o; }
-};
-
-template <>
-struct pack<signed long long> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, signed long long v) const
-    { o.pack_long_long(v); return o; }
-};
-
-
-template <>
-struct pack<unsigned char> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, unsigned char v) const
-    { o.pack_unsigned_char(v); return o; }
-};
-
-template <>
-struct pack<unsigned short> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, unsigned short v) const
-    { o.pack_unsigned_short(v); return o; }
-};
-
-template <>
-struct pack<unsigned int> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, unsigned int v) const
-    { o.pack_unsigned_int(v); return o; }
-};
-
-template <>
-struct pack<unsigned long> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, unsigned long v) const
-    { o.pack_unsigned_long(v); return o; }
-};
-
-template <>
-struct pack<unsigned long long> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, unsigned long long v) const
-    { o.pack_unsigned_long_long(v); return o; }
-};
-
-
-template <>
-struct object<char> {
-    void operator()(msgpack::object& o, char v) const
-    { type::detail::object_char(o, v); }
-};
-
-template <>
-struct object<signed char> {
-    void operator()(msgpack::object& o, signed char v) const {
-        if (v < 0) {
-            o.type = msgpack::type::NEGATIVE_INTEGER;
-            o.via.i64 = v;
-        }
-        else {
-            o.type = msgpack::type::POSITIVE_INTEGER;
-            o.via.u64 = v;
-        }
-    }
-};
-
-template <>
-struct object<signed short> {
-    void operator()(msgpack::object& o, signed short v) const {
-        if (v < 0) {
-            o.type = msgpack::type::NEGATIVE_INTEGER;
-            o.via.i64 = v;
-        }
-        else {
-            o.type = msgpack::type::POSITIVE_INTEGER;
-            o.via.u64 = v;
-        }
-    }
-};
-
-template <>
-struct object<signed int> {
-    void operator()(msgpack::object& o, signed int v) const {
-        if (v < 0) {
-            o.type = msgpack::type::NEGATIVE_INTEGER;
-            o.via.i64 = v;
-        }
-        else {
-            o.type = msgpack::type::POSITIVE_INTEGER;
-            o.via.u64 = v;
-        }
-    }
-};
-
-template <>
-struct object<signed long> {
-    void operator()(msgpack::object& o, signed long v) const {
-        if (v < 0) {
-            o.type = msgpack::type::NEGATIVE_INTEGER;
-            o.via.i64 = v;
-        }
-        else {
-            o.type = msgpack::type::POSITIVE_INTEGER;
-            o.via.u64 = v;
-        }
-    }
-};
-
-template <>
-struct object<signed long long> {
-    void operator()(msgpack::object& o, signed long long v) const {
-        if (v < 0) {
-            o.type = msgpack::type::NEGATIVE_INTEGER;
-            o.via.i64 = v;
-        }
-        else{
-            o.type = msgpack::type::POSITIVE_INTEGER;
-            o.via.u64 = v;
-        }
-    }
-};
-
-template <>
-struct object<unsigned char> {
-    void operator()(msgpack::object& o, unsigned char v) const
-    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; }
-};
-
-template <>
-struct object<unsigned short> {
-    void operator()(msgpack::object& o, unsigned short v) const
-    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; }
-};
-
-template <>
-struct object<unsigned int> {
-    void operator()(msgpack::object& o, unsigned int v) const
-    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; }
-};
-
-template <>
-struct object<unsigned long> {
-    void operator()(msgpack::object& o, unsigned long v) const
-    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; }
-};
-
-template <>
-struct object<unsigned long long> {
-    void operator()(msgpack::object& o, unsigned long long v) const
-    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; }
-};
-
-
-template <>
-struct object_with_zone<char> {
-    void operator()(msgpack::object::with_zone& o, char v) const
-    { static_cast<msgpack::object&>(o) << v; }
-};
-
-template <>
-struct object_with_zone<signed char> {
-    void operator()(msgpack::object::with_zone& o, signed char v) const
-    { static_cast<msgpack::object&>(o) << v; }
-};
-
-template <>
-struct object_with_zone<signed short> {
-    void operator()(msgpack::object::with_zone& o, signed short v) const
-    { static_cast<msgpack::object&>(o) << v; }
-};
-
-template <>
-struct object_with_zone<signed int> {
-    void operator()(msgpack::object::with_zone& o, signed int v) const
-    { static_cast<msgpack::object&>(o) << v; }
-};
-
-template <>
-struct object_with_zone<signed long> {
-    void operator()(msgpack::object::with_zone& o, signed long v) const
-    { static_cast<msgpack::object&>(o) << v; }
-};
-
-template <>
-struct object_with_zone<signed long long> {
-    void operator()(msgpack::object::with_zone& o, const signed long long& v) const
-    { static_cast<msgpack::object&>(o) << v; }
-};
-
-template <>
-struct object_with_zone<unsigned char> {
-    void operator()(msgpack::object::with_zone& o, unsigned char v) const
-    { static_cast<msgpack::object&>(o) << v; }
-};
-
-template <>
-struct object_with_zone<unsigned short> {
-    void operator()(msgpack::object::with_zone& o, unsigned short v) const
-    { static_cast<msgpack::object&>(o) << v; }
-};
-
-template <>
-struct object_with_zone<unsigned int> {
-    void operator()(msgpack::object::with_zone& o, unsigned int v) const
-    { static_cast<msgpack::object&>(o) << v; }
-};
-
-template <>
-struct object_with_zone<unsigned long> {
-    void operator()(msgpack::object::with_zone& o, unsigned long v) const
-    { static_cast<msgpack::object&>(o) << v; }
-};
-
-template <>
-struct object_with_zone<unsigned long long> {
-    void operator()(msgpack::object::with_zone& o, const unsigned long long& v) const
-    { static_cast<msgpack::object&>(o) << v; }
-};
-
-} // namespace adaptor
-
-/// @cond
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-}  // namespace msgpack
-
-#endif /* msgpack/type/int.hpp */

include/msgpack/adaptor/list.hpp

@@ -1,106 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2015 FURUHASHI Sadayuki
-//
-//    Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//    http://www.boost.org/LICENSE_1_0.txt)
-//
-#ifndef MSGPACK_TYPE_LIST_HPP
-#define MSGPACK_TYPE_LIST_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#include <list>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-#if !defined(MSGPACK_USE_CPP03)
-
-template <typename T, typename Alloc>
-struct as<std::list<T, Alloc>, typename std::enable_if<msgpack::has_as<T>::value>::type> {
-    std::list<T, Alloc> operator()(msgpack::object const& o) const {
-        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        std::list<T, Alloc> v;
-        msgpack::object* p = o.via.array.ptr;
-        msgpack::object* const pend = o.via.array.ptr + o.via.array.size;
-        for (; p < pend; ++p) {
-            v.push_back(p->as<T>());
-        }
-        return v;
-    }
-};
-
-#endif // !defined(MSGPACK_USE_CPP03)
-
-template <typename T, typename Alloc>
-struct convert<std::list<T, Alloc> > {
-    msgpack::object const& operator()(msgpack::object const& o, std::list<T, Alloc>& v) const {
-        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        v.resize(o.via.array.size);
-        msgpack::object* p = o.via.array.ptr;
-        msgpack::object* const pend = o.via.array.ptr + o.via.array.size;
-        typename std::list<T, Alloc>::iterator it = v.begin();
-        for (; p < pend; ++p, ++it) {
-            p->convert(*it);
-        }
-        return o;
-    }
-};
-
-template <typename T, typename Alloc>
-struct pack<std::list<T, Alloc> > {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::list<T, Alloc>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.pack_array(size);
-        for (typename std::list<T, Alloc>::const_iterator it(v.begin()), it_end(v.end());
-            it != it_end; ++it) {
-            o.pack(*it);
-        }
-        return o;
-    }
-};
-
-template <typename T, typename Alloc>
-struct object_with_zone<std::list<T, Alloc> > {
-    void operator()(msgpack::object::with_zone& o, const std::list<T, Alloc>& v) const {
-        o.type = msgpack::type::ARRAY;
-        if (v.empty()) {
-            o.via.array.ptr = nullptr;
-            o.via.array.size = 0;
-        }
-        else {
-            uint32_t size = checked_get_container_size(v.size());
-            msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
-            msgpack::object* const pend = p + size;
-            o.via.array.ptr = p;
-            o.via.array.size = size;
-            typename std::list<T, Alloc>::const_iterator it(v.begin());
-            do {
-                *p = msgpack::object(*it, o.zone);
-                ++p;
-                ++it;
-            } while(p < pend);
-        }
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_LIST_HPP

include/msgpack/adaptor/map.hpp

@@ -1,306 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2015 FURUHASHI Sadayuki
-//
-//    Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//    http://www.boost.org/LICENSE_1_0.txt)
-//
-#ifndef MSGPACK_TYPE_MAP_HPP
-#define MSGPACK_TYPE_MAP_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#include <map>
-#include <vector>
-#include <algorithm>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace type {
-
-template <typename K, typename V, typename Compare = std::less<K>, typename Alloc = std::allocator<std::pair<K, V> > >
-class assoc_vector : public std::vector< std::pair<K, V>, Alloc > {
-#if !defined(MSGPACK_USE_CPP03)
-    using std::vector<std::pair<K, V>, Alloc>::vector;
-#endif // !defined(MSGPACK_USE_CPP03)
-};
-
-namespace detail {
-    template <typename K, typename V, typename Compare, typename Alloc>
-    struct pair_first_less {
-        bool operator() (const std::pair<K, V>& x, const std::pair<K, V>& y) const
-            { return Compare()(x.first, y.first); }
-    };
-}
-
-}  //namespace type
-
-namespace adaptor {
-
-#if !defined(MSGPACK_USE_CPP03)
-
-template <typename K, typename V, typename Compare, typename Alloc>
-struct as<
-    type::assoc_vector<K, V, Compare, Alloc>,
-    typename std::enable_if<msgpack::has_as<K>::value && msgpack::has_as<V>::value>::type> {
-    type::assoc_vector<K, V, Compare, Alloc> operator()(msgpack::object const& o) const {
-        if (o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
-        type::assoc_vector<K, V, Compare, Alloc> v;
-        v.reserve(o.via.map.size);
-        msgpack::object_kv* p = o.via.map.ptr;
-        msgpack::object_kv* const pend = o.via.map.ptr + o.via.map.size;
-        for (; p < pend; ++p) {
-            v.emplace_back(p->key.as<K>(), p->val.as<V>());
-        }
-        std::sort(v.begin(), v.end(), type::detail::pair_first_less<K, V, Compare, Alloc>());
-        return v;
-    }
-};
-
-#endif // !defined(MSGPACK_USE_CPP03)
-
-template <typename K, typename V, typename Compare, typename Alloc>
-struct convert<type::assoc_vector<K, V, Compare, Alloc> > {
-    msgpack::object const& operator()(msgpack::object const& o, type::assoc_vector<K, V, Compare, Alloc>& v) const {
-        if (o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
-        v.resize(o.via.map.size);
-        msgpack::object_kv* p = o.via.map.ptr;
-        msgpack::object_kv* const pend = o.via.map.ptr + o.via.map.size;
-        std::pair<K, V>* it(&v.front());
-        for (; p < pend; ++p, ++it) {
-            p->key.convert(it->first);
-            p->val.convert(it->second);
-        }
-        std::sort(v.begin(), v.end(), type::detail::pair_first_less<K, V, Compare, Alloc>());
-        return o;
-    }
-};
-
-template <typename K, typename V, typename Compare, typename Alloc>
-struct pack<type::assoc_vector<K, V, Compare, Alloc> > {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const type::assoc_vector<K, V, Compare, Alloc>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.pack_map(size);
-        for (typename type::assoc_vector<K, V, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
-            it != it_end; ++it) {
-            o.pack(it->first);
-            o.pack(it->second);
-        }
-        return o;
-    }
-};
-
-template <typename K, typename V, typename Compare, typename Alloc>
-struct object_with_zone<type::assoc_vector<K, V, Compare, Alloc> > {
-    void operator()(msgpack::object::with_zone& o, const type::assoc_vector<K, V, Compare, Alloc>& v) const {
-        o.type = msgpack::type::MAP;
-        if (v.empty()) {
-            o.via.map.ptr  = nullptr;
-            o.via.map.size = 0;
-        }
-        else {
-            uint32_t size = checked_get_container_size(v.size());
-            msgpack::object_kv* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size));
-            msgpack::object_kv* const pend = p + size;
-            o.via.map.ptr  = p;
-            o.via.map.size = size;
-            typename type::assoc_vector<K, V, Compare, Alloc>::const_iterator it(v.begin());
-            do {
-                p->key = msgpack::object(it->first, o.zone);
-                p->val = msgpack::object(it->second, o.zone);
-                ++p;
-                ++it;
-            } while(p < pend);
-        }
-    }
-};
-
-#if !defined(MSGPACK_USE_CPP03)
-
-template <typename K, typename V, typename Compare, typename Alloc>
-struct as<
-    std::map<K, V, Compare, Alloc>,
-    typename std::enable_if<msgpack::has_as<K>::value && msgpack::has_as<V>::value>::type> {
-    std::map<K, V, Compare, Alloc> operator()(msgpack::object const& o) const {
-        if (o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
-        msgpack::object_kv* p(o.via.map.ptr);
-        msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
-        std::map<K, V, Compare, Alloc> v;
-        for (; p != pend; ++p) {
-            v.emplace(p->key.as<K>(), p->val.as<V>());
-        }
-        return v;
-    }
-};
-
-#endif // !defined(MSGPACK_USE_CPP03)
-
-template <typename K, typename V, typename Compare, typename Alloc>
-struct convert<std::map<K, V, Compare, Alloc> > {
-    msgpack::object const& operator()(msgpack::object const& o, std::map<K, V, Compare, Alloc>& v) const {
-        if (o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
-        msgpack::object_kv* p(o.via.map.ptr);
-        msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
-        std::map<K, V, Compare, Alloc> tmp;
-        for (; p != pend; ++p) {
-            K key;
-            p->key.convert(key);
-#if __cplusplus >= 201103L
-            p->val.convert(tmp[std::move(key)]);
-#else
-            p->val.convert(tmp[key]);
-#endif
-        }
-#if __cplusplus >= 201103L
-        v = std::move(tmp);
-#else
-        tmp.swap(v);
-#endif
-        return o;
-    }
-};
-
-template <typename K, typename V, typename Compare, typename Alloc>
-struct pack<std::map<K, V, Compare, Alloc> > {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::map<K, V, Compare, Alloc>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.pack_map(size);
-        for (typename std::map<K, V, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
-            it != it_end; ++it) {
-            o.pack(it->first);
-            o.pack(it->second);
-        }
-        return o;
-    }
-};
-
-template <typename K, typename V, typename Compare, typename Alloc>
-struct object_with_zone<std::map<K, V, Compare, Alloc> > {
-    void operator()(msgpack::object::with_zone& o, const std::map<K, V, Compare, Alloc>& v) const {
-        o.type = msgpack::type::MAP;
-        if (v.empty()) {
-            o.via.map.ptr  = nullptr;
-            o.via.map.size = 0;
-        }
-        else {
-            uint32_t size = checked_get_container_size(v.size());
-            msgpack::object_kv* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size));
-            msgpack::object_kv* const pend = p + size;
-            o.via.map.ptr  = p;
-            o.via.map.size = size;
-            typename std::map<K, V, Compare, Alloc>::const_iterator it(v.begin());
-            do {
-                p->key = msgpack::object(it->first, o.zone);
-                p->val = msgpack::object(it->second, o.zone);
-                ++p;
-                ++it;
-            } while(p < pend);
-        }
-    }
-};
-
-#if !defined(MSGPACK_USE_CPP03)
-
-template <typename K, typename V, typename Compare, typename Alloc>
-struct as<
-    std::multimap<K, V, Compare, Alloc>,
-    typename std::enable_if<msgpack::has_as<K>::value && msgpack::has_as<V>::value>::type> {
-    std::multimap<K, V, Compare, Alloc> operator()(msgpack::object const& o) const {
-        if (o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
-        msgpack::object_kv* p(o.via.map.ptr);
-        msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
-        std::multimap<K, V, Compare, Alloc> v;
-        for (; p != pend; ++p) {
-            v.emplace(p->key.as<K>(), p->val.as<V>());
-        }
-        return v;
-    }
-};
-
-#endif // !defined(MSGPACK_USE_CPP03)
-
-template <typename K, typename V, typename Compare, typename Alloc>
-struct convert<std::multimap<K, V, Compare, Alloc> > {
-    msgpack::object const& operator()(msgpack::object const& o, std::multimap<K, V, Compare, Alloc>& v) const {
-        if (o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
-        msgpack::object_kv* p(o.via.map.ptr);
-        msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
-        std::multimap<K, V, Compare, Alloc> tmp;
-        for (; p != pend; ++p) {
-            std::pair<K, V> value;
-            p->key.convert(value.first);
-            p->val.convert(value.second);
-#if __cplusplus >= 201103L
-            tmp.insert(std::move(value));
-#else
-            tmp.insert(value);
-#endif
-        }
-#if __cplusplus >= 201103L
-        v = std::move(tmp);
-#else
-        tmp.swap(v);
-#endif
-        return o;
-    }
-};
-
-template <typename K, typename V, typename Compare, typename Alloc>
-struct pack<std::multimap<K, V, Compare, Alloc> > {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::multimap<K, V, Compare, Alloc>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.pack_map(size);
-        for (typename std::multimap<K, V, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
-            it != it_end; ++it) {
-            o.pack(it->first);
-            o.pack(it->second);
-        }
-        return o;
-    }
-};
-
-template <typename K, typename V, typename Compare, typename Alloc>
-struct object_with_zone<std::multimap<K, V, Compare, Alloc> > {
-    void operator()(msgpack::object::with_zone& o, const std::multimap<K, V, Compare, Alloc>& v) const {
-        o.type = msgpack::type::MAP;
-        if (v.empty()) {
-            o.via.map.ptr  = nullptr;
-            o.via.map.size = 0;
-        }
-        else {
-            uint32_t size = checked_get_container_size(v.size());
-            msgpack::object_kv* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size));
-            msgpack::object_kv* const pend = p + size;
-            o.via.map.ptr  = p;
-            o.via.map.size = size;
-            typename std::multimap<K, V, Compare, Alloc>::const_iterator it(v.begin());
-            do {
-                p->key = msgpack::object(it->first, o.zone);
-                p->val = msgpack::object(it->second, o.zone);
-                ++p;
-                ++it;
-            } while(p < pend);
-        }
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_MAP_HPP

include/msgpack/adaptor/msgpack_tuple.hpp

@@ -1,21 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2014 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_MSGPACK_TUPLE_HPP
-#define MSGPACK_MSGPACK_TUPLE_HPP
-
-#include "msgpack/cpp_config.hpp"
-
-#if defined(MSGPACK_USE_CPP03)
-#include "detail/cpp03_msgpack_tuple.hpp"
-#else  // MSGPACK_USE_CPP03
-#include "detail/cpp11_msgpack_tuple.hpp"
-#endif // MSGPACK_USE_CPP03
-
-#endif // MSGPACK_MSGPACK_TUPLE_HPP

include/msgpack/adaptor/nil.hpp

@@ -1,90 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// 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)
-//
-#ifndef MSGPACK_TYPE_NIL_HPP
-#define MSGPACK_TYPE_NIL_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace type {
-
-struct nil_t { };
-
-#if !defined(MSGPACK_DISABLE_LEGACY_NIL)
-
-typedef nil_t nil;
-
-#endif // !defined(MSGPACK_DISABLE_LEGACY_NIL)
-
-inline bool operator<(nil_t const& lhs, nil_t const& rhs) {
-    return &lhs < &rhs;
-}
-
-inline bool operator==(nil_t const& lhs, nil_t const& rhs) {
-    return &lhs == &rhs;
-}
-
-}  // namespace type
-
-namespace adaptor {
-
-template <>
-struct convert<type::nil_t> {
-    msgpack::object const& operator()(msgpack::object const& o, type::nil_t&) const {
-        if(o.type != msgpack::type::NIL) { throw msgpack::type_error(); }
-        return o;
-    }
-};
-
-template <>
-struct pack<type::nil_t> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const type::nil_t&) const {
-        o.pack_nil();
-        return o;
-    }
-};
-
-template <>
-struct object<type::nil_t> {
-    void operator()(msgpack::object& o, type::nil_t) const {
-        o.type = msgpack::type::NIL;
-    }
-};
-
-template <>
-struct object_with_zone<type::nil_t> {
-    void operator()(msgpack::object::with_zone& o, type::nil_t v) const {
-        static_cast<msgpack::object&>(o) << v;
-    }
-};
-
-} // namespace adaptor
-
-template <>
-inline void msgpack::object::as<void>() const
-{
-    msgpack::type::nil_t v;
-    convert(v);
-}
-
-/// @cond
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_NIL_HPP

include/msgpack/adaptor/pair.hpp

@@ -1,83 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// 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)
-//
-#ifndef MSGPACK_TYPE_PAIR_HPP
-#define MSGPACK_TYPE_PAIR_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/meta.hpp"
-
-#include <utility>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-#if !defined(MSGPACK_USE_CPP03)
-
-template <typename T1, typename T2>
-struct as<std::pair<T1, T2>,
-          typename std::enable_if<msgpack::all_of<msgpack::has_as, T1, T2>::value>::type> {
-    std::pair<T1, T2> operator()(msgpack::object const& o) const {
-        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        if (o.via.array.size != 2) { throw msgpack::type_error(); }
-        return std::make_pair(o.via.array.ptr[0].as<T1>(), o.via.array.ptr[1].as<T2>());
-    }
-};
-
-#endif // !defined(MSGPACK_USE_CPP03)
-
-template <typename T1, typename T2>
-struct convert<std::pair<T1, T2> > {
-    msgpack::object const& operator()(msgpack::object const& o, std::pair<T1, T2>& v) const {
-        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        if(o.via.array.size != 2) { throw msgpack::type_error(); }
-        o.via.array.ptr[0].convert(v.first);
-        o.via.array.ptr[1].convert(v.second);
-        return o;
-    }
-};
-
-template <typename T1, typename T2>
-struct pack<std::pair<T1, T2> > {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::pair<T1, T2>& v) const {
-        o.pack_array(2);
-        o.pack(v.first);
-        o.pack(v.second);
-        return o;
-    }
-};
-
-template <typename T1, typename T2>
-struct object_with_zone<std::pair<T1, T2> > {
-    void operator()(msgpack::object::with_zone& o, const std::pair<T1, T2>& v) const {
-        o.type = msgpack::type::ARRAY;
-        msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*2));
-        o.via.array.ptr = p;
-        o.via.array.size = 2;
-        p[0] = msgpack::object(v.first, o.zone);
-        p[1] = msgpack::object(v.second, o.zone);
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_PAIR_HPP

include/msgpack/adaptor/raw.hpp

@@ -1,106 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// 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)
-//
-#ifndef MSGPACK_TYPE_RAW_HPP
-#define MSGPACK_TYPE_RAW_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include <cstring>
-#include <string>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace type {
-
-struct raw_ref {
-    raw_ref() : size(0), ptr(nullptr) {}
-    raw_ref(const char* p, uint32_t s) : size(s), ptr(p) {}
-
-    uint32_t size;
-    const char* ptr;
-
-    std::string str() const { return std::string(ptr, size); }
-
-    bool operator== (const raw_ref& x) const
-    {
-        return size == x.size && std::memcmp(ptr, x.ptr, size) == 0;
-    }
-
-    bool operator!= (const raw_ref& x) const
-    {
-        return !(*this == x);
-    }
-
-    bool operator< (const raw_ref& x) const
-    {
-        if(size == x.size) { return std::memcmp(ptr, x.ptr, size) < 0; }
-        else { return size < x.size; }
-    }
-
-    bool operator> (const raw_ref& x) const
-    {
-        if(size == x.size) { return std::memcmp(ptr, x.ptr, size) > 0; }
-        else { return size > x.size; }
-    }
-};
-
-} // namespace type
-
-namespace adaptor {
-
-template <>
-struct convert<msgpack::type::raw_ref> {
-    msgpack::object const& operator()(msgpack::object const& o, msgpack::type::raw_ref& v) const {
-        if(o.type != msgpack::type::BIN) { throw msgpack::type_error(); }
-        v.ptr  = o.via.bin.ptr;
-        v.size = o.via.bin.size;
-        return o;
-    }
-};
-
-template <>
-struct pack<msgpack::type::raw_ref> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const msgpack::type::raw_ref& v) const {
-        o.pack_bin(v.size);
-        o.pack_bin_body(v.ptr, v.size);
-        return o;
-    }
-};
-
-template <>
-struct object<msgpack::type::raw_ref> {
-    void operator()(msgpack::object& o, const msgpack::type::raw_ref& v) const {
-        o.type = msgpack::type::BIN;
-        o.via.bin.ptr = v.ptr;
-        o.via.bin.size = v.size;
-    }
-};
-
-template <>
-struct object_with_zone<msgpack::type::raw_ref> {
-    void operator()(msgpack::object::with_zone& o, const msgpack::type::raw_ref& v) const {
-        static_cast<msgpack::object&>(o) << v;
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
-
-#endif // MSGPACK_TYPE_RAW_HPP

include/msgpack/adaptor/set.hpp

@@ -1,188 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2015 FURUHASHI Sadayuki
-//
-//    Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//    http://www.boost.org/LICENSE_1_0.txt)
-//
-#ifndef MSGPACK_TYPE_SET_HPP
-#define MSGPACK_TYPE_SET_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#include <set>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-#if !defined(MSGPACK_USE_CPP03)
-
-template <typename T, typename Compare, typename Alloc>
-struct as<std::set<T, Compare, Alloc>, typename std::enable_if<msgpack::has_as<T>::value>::type> {
-    std::set<T, Compare, Alloc> operator()(msgpack::object const& o) const {
-        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        msgpack::object* p = o.via.array.ptr + o.via.array.size;
-        msgpack::object* const pbegin = o.via.array.ptr;
-        std::set<T, Compare, Alloc> v;
-        while (p > pbegin) {
-            --p;
-            v.insert(p->as<T>());
-        }
-        return v;
-    }
-};
-
-#endif // !defined(MSGPACK_USE_CPP03)
-
-template <typename T, typename Compare, typename Alloc>
-struct convert<std::set<T, Compare, Alloc> > {
-    msgpack::object const& operator()(msgpack::object const& o, std::set<T, Compare, Alloc>& v) const {
-        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        msgpack::object* p = o.via.array.ptr + o.via.array.size;
-        msgpack::object* const pbegin = o.via.array.ptr;
-        std::set<T, Compare, Alloc> tmp;
-        while (p > pbegin) {
-            --p;
-            tmp.insert(p->as<T>());
-        }
-#if __cplusplus >= 201103L
-        v = std::move(tmp);
-#else
-        tmp.swap(v);
-#endif
-        return o;
-    }
-};
-
-template <typename T, typename Compare, typename Alloc>
-struct pack<std::set<T, Compare, Alloc> > {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::set<T, Compare, Alloc>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.pack_array(size);
-        for (typename std::set<T, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
-            it != it_end; ++it) {
-            o.pack(*it);
-        }
-        return o;
-    }
-};
-
-template <typename T, typename Compare, typename Alloc>
-struct object_with_zone<std::set<T, Compare, Alloc> > {
-    void operator()(msgpack::object::with_zone& o, const std::set<T, Compare, Alloc>& v) const {
-        o.type = msgpack::type::ARRAY;
-        if (v.empty()) {
-            o.via.array.ptr = nullptr;
-            o.via.array.size = 0;
-        }
-        else {
-            uint32_t size = checked_get_container_size(v.size());
-            msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
-            msgpack::object* const pend = p + size;
-            o.via.array.ptr = p;
-            o.via.array.size = size;
-            typename std::set<T, Compare, Alloc>::const_iterator it(v.begin());
-            do {
-                *p = msgpack::object(*it, o.zone);
-                ++p;
-                ++it;
-            } while(p < pend);
-        }
-    }
-};
-
-#if !defined(MSGPACK_USE_CPP03)
-
-template <typename T, typename Compare, typename Alloc>
-struct as<std::multiset<T, Compare, Alloc>, typename std::enable_if<msgpack::has_as<T>::value>::type> {
-    std::multiset<T, Compare, Alloc> operator()(msgpack::object const& o) const {
-        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        msgpack::object* p = o.via.array.ptr + o.via.array.size;
-        msgpack::object* const pbegin = o.via.array.ptr;
-        std::multiset<T, Compare, Alloc> v;
-        while (p > pbegin) {
-            --p;
-            v.insert(p->as<T>());
-        }
-        return v;
-    }
-};
-
-#endif // !defined(MSGPACK_USE_CPP03)
-
-template <typename T, typename Compare, typename Alloc>
-struct convert<std::multiset<T, Compare, Alloc> > {
-    msgpack::object const& operator()(msgpack::object const& o, std::multiset<T, Compare, Alloc>& v) const {
-        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        msgpack::object* p = o.via.array.ptr + o.via.array.size;
-        msgpack::object* const pbegin = o.via.array.ptr;
-        std::multiset<T, Compare, Alloc> tmp;
-        while (p > pbegin) {
-            --p;
-            tmp.insert(p->as<T>());
-        }
-#if __cplusplus >= 201103L
-        v = std::move(tmp);
-#else
-        tmp.swap(v);
-#endif
-        return o;
-    }
-};
-
-template <typename T, typename Compare, typename Alloc>
-struct pack<std::multiset<T, Compare, Alloc> > {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::multiset<T, Compare, Alloc>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.pack_array(size);
-        for (typename std::multiset<T, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
-            it != it_end; ++it) {
-            o.pack(*it);
-        }
-        return o;
-    }
-};
-
-template <typename T, typename Compare, typename Alloc>
-struct object_with_zone<std::multiset<T, Compare, Alloc> > {
-    void operator()(msgpack::object::with_zone& o, const std::multiset<T, Compare, Alloc>& v) const {
-        o.type = msgpack::type::ARRAY;
-        if (v.empty()) {
-            o.via.array.ptr = nullptr;
-            o.via.array.size = 0;
-        } else {
-            uint32_t size = checked_get_container_size(v.size());
-            msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
-            msgpack::object* const pend = p + size;
-            o.via.array.ptr = p;
-            o.via.array.size = size;
-            typename std::multiset<T, Compare, Alloc>::const_iterator it(v.begin());
-            do {
-                *p = msgpack::object(*it, o.zone);
-                ++p;
-                ++it;
-            } while(p < pend);
-        }
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_SET_HPP

include/msgpack/adaptor/string.hpp

@@ -1,86 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2015 FURUHASHI Sadayuki
-//
-//    Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//    http://www.boost.org/LICENSE_1_0.txt)
-//
-#ifndef MSGPACK_TYPE_STRING_HPP
-#define MSGPACK_TYPE_STRING_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#include <string>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-template <>
-struct convert<std::string> {
-    msgpack::object const& operator()(msgpack::object const& o, std::string& v) const {
-        switch (o.type) {
-        case msgpack::type::BIN:
-            v.assign(o.via.bin.ptr, o.via.bin.size);
-            break;
-        case msgpack::type::STR:
-            v.assign(o.via.str.ptr, o.via.str.size);
-            break;
-        default:
-            throw msgpack::type_error();
-            break;
-        }
-        return o;
-    }
-};
-
-template <>
-struct pack<std::string> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::string& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.pack_str(size);
-        o.pack_str_body(v.data(), size);
-        return o;
-    }
-};
-
-template <>
-struct object<std::string> {
-    void operator()(msgpack::object& o, const std::string& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.type = msgpack::type::STR;
-        o.via.str.ptr = v.data();
-        o.via.str.size = size;
-    }
-};
-
-template <>
-struct object_with_zone<std::string> {
-    void operator()(msgpack::object::with_zone& o, const std::string& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.type = msgpack::type::STR;
-        char* ptr = static_cast<char*>(o.zone.allocate_align(size));
-        o.via.str.ptr = ptr;
-        o.via.str.size = size;
-        std::memcpy(ptr, v.data(), v.size());
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-}  // namespace msgpack
-
-#endif // MSGPACK_TYPE_STRING_HPP

include/msgpack/adaptor/tr1/unordered_map.hpp

@@ -1,171 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2015 FURUHASHI Sadayuki
-//
-//    Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//    http://www.boost.org/LICENSE_1_0.txt)
-//
-#ifndef MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP
-#define MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
-
-#define MSGPACK_HAS_STD_UNORDERED_MAP
-#include <unordered_map>
-#define MSGPACK_STD_TR1 std
-
-#else   // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
-
-#if __GNUC__ >= 4
-
-#define MSGPACK_HAS_STD_TR1_UNORDERED_MAP
-
-#include <tr1/unordered_map>
-#define MSGPACK_STD_TR1 std::tr1
-
-#endif // __GNUC__ >= 4
-
-#endif  // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
-
-#if defined(MSGPACK_STD_TR1)
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-template <typename K, typename V, typename Hash, typename Pred, typename Alloc>
-struct convert<MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc> > {
-    msgpack::object const& operator()(msgpack::object const& o, MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc>& v) const {
-        if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
-        msgpack::object_kv* p(o.via.map.ptr);
-        msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
-        MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc> tmp;
-        for(; p != pend; ++p) {
-            K key;
-            p->key.convert(key);
-            p->val.convert(tmp[key]);
-        }
-        tmp.swap(v);
-        return o;
-    }
-};
-
-template <typename K, typename V, typename Hash, typename Pred, typename Alloc>
-struct pack<MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc> > {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.pack_map(size);
-        for(typename MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc>::const_iterator it(v.begin()), it_end(v.end());
-            it != it_end; ++it) {
-            o.pack(it->first);
-            o.pack(it->second);
-        }
-        return o;
-    }
-};
-
-template <typename K, typename V, typename Hash, typename Pred, typename Alloc>
-struct object_with_zone<MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc> > {
-    void operator()(msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc>& v) const {
-        o.type = msgpack::type::MAP;
-        if(v.empty()) {
-            o.via.map.ptr  = nullptr;
-            o.via.map.size = 0;
-        } else {
-            uint32_t size = checked_get_container_size(v.size());
-            msgpack::object_kv* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size));
-            msgpack::object_kv* const pend = p + size;
-            o.via.map.ptr  = p;
-            o.via.map.size = size;
-            typename MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc>::const_iterator it(v.begin());
-            do {
-                p->key = msgpack::object(it->first, o.zone);
-                p->val = msgpack::object(it->second, o.zone);
-                ++p;
-                ++it;
-            } while(p < pend);
-        }
-    }
-};
-
-template <typename K, typename V, typename Hash, typename Pred, typename Alloc>
-struct convert<MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Alloc> > {
-    msgpack::object const& operator()(msgpack::object const& o, MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Alloc>& v) const {
-        if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
-        msgpack::object_kv* p(o.via.map.ptr);
-        msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
-        MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Alloc> tmp;
-        for(; p != pend; ++p) {
-            std::pair<K, V> value;
-            p->key.convert(value.first);
-            p->val.convert(value.second);
-            tmp.insert(value);
-        }
-        tmp.swap(v);
-        return o;
-    }
-};
-
-template <typename K, typename V, typename Hash, typename Pred, typename Alloc>
-struct pack<MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Alloc> > {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Alloc>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.pack_map(size);
-        for(typename MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Alloc>::const_iterator it(v.begin()), it_end(v.end());
-            it != it_end; ++it) {
-            o.pack(it->first);
-            o.pack(it->second);
-        }
-        return o;
-    }
-};
-
-template <typename K, typename V, typename Hash, typename Pred, typename Alloc>
-struct object_with_zone<MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Alloc> > {
-    void operator()(msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Alloc>& v) const {
-        o.type = msgpack::type::MAP;
-        if(v.empty()) {
-            o.via.map.ptr  = nullptr;
-            o.via.map.size = 0;
-        } else {
-            uint32_t size = checked_get_container_size(v.size());
-            msgpack::object_kv* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size));
-            msgpack::object_kv* const pend = p + size;
-            o.via.map.ptr  = p;
-            o.via.map.size = size;
-            typename MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Alloc>::const_iterator it(v.begin());
-            do {
-                p->key = msgpack::object(it->first, o.zone);
-                p->val = msgpack::object(it->second, o.zone);
-                ++p;
-                ++it;
-            } while(p < pend);
-        }
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
-
-#undef MSGPACK_STD_TR1
-
-#endif // MSGPACK_STD_TR1
-
-#endif // MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP

include/msgpack/adaptor/tr1/unordered_set.hpp

@@ -1,165 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2015 FURUHASHI Sadayuki
-//
-//    Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//    http://www.boost.org/LICENSE_1_0.txt)
-//
-#ifndef MSGPACK_TYPE_TR1_UNORDERED_SET_HPP
-#define MSGPACK_TYPE_TR1_UNORDERED_SET_HPP
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
-
-#define MSGPACK_HAS_STD_UNORDERED_SET
-#include <unordered_set>
-#define MSGPACK_STD_TR1 std
-
-#else   // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
-
-#if __GNUC__ >= 4
-
-#define MSGPACK_HAS_STD_TR1_UNORDERED_SET
-
-#include <tr1/unordered_set>
-#define MSGPACK_STD_TR1 std::tr1
-
-#endif // __GNUC__ >= 4
-
-#endif  // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
-
-#if defined(MSGPACK_STD_TR1)
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-template <typename T, typename Hash, typename Compare, typename Alloc>
-struct convert<MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc> > {
-    msgpack::object const& operator()(msgpack::object const& o, MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc>& v) const {
-        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        msgpack::object* p = o.via.array.ptr + o.via.array.size;
-        msgpack::object* const pbegin = o.via.array.ptr;
-        MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc> tmp;
-        while(p > pbegin) {
-            --p;
-            tmp.insert(p->as<T>());
-        }
-        tmp.swap(v);
-        return o;
-    }
-};
-
-template <typename T, typename Hash, typename Compare, typename Alloc>
-struct pack<MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc> > {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.pack_array(size);
-        for(typename MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
-            it != it_end; ++it) {
-            o.pack(*it);
-        }
-        return o;
-    }
-};
-
-template <typename T, typename Hash, typename Compare, typename Alloc>
-struct object_with_zone<MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc> > {
-    void operator()(msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc>& v) const {
-        o.type = msgpack::type::ARRAY;
-        if(v.empty()) {
-            o.via.array.ptr = nullptr;
-            o.via.array.size = 0;
-        } else {
-            uint32_t size = checked_get_container_size(v.size());
-            msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
-            msgpack::object* const pend = p + size;
-            o.via.array.ptr = p;
-            o.via.array.size = size;
-            typename MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc>::const_iterator it(v.begin());
-            do {
-                *p = msgpack::object(*it, o.zone);
-                ++p;
-                ++it;
-            } while(p < pend);
-        }
-    }
-};
-
-
-template <typename T, typename Hash, typename Compare, typename Alloc>
-struct convert<MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Alloc> > {
-    msgpack::object const& operator()(msgpack::object const& o, MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Alloc>& v) const {
-        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        msgpack::object* p = o.via.array.ptr + o.via.array.size;
-        msgpack::object* const pbegin = o.via.array.ptr;
-        MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Alloc> tmp;
-        while(p > pbegin) {
-            --p;
-            tmp.insert(p->as<T>());
-        }
-        tmp.swap(v);
-        return o;
-    }
-};
-
-template <typename T, typename Hash, typename Compare, typename Alloc>
-struct pack<MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Alloc> > {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Alloc>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.pack_array(size);
-        for(typename MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
-            it != it_end; ++it) {
-            o.pack(*it);
-        }
-        return o;
-    }
-};
-
-template <typename T, typename Hash, typename Compare, typename Alloc>
-struct object_with_zone<MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Alloc> > {
-    void operator()(msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Alloc>& v) const {
-        o.type = msgpack::type::ARRAY;
-        if(v.empty()) {
-            o.via.array.ptr = nullptr;
-            o.via.array.size = 0;
-        } else {
-            uint32_t size = checked_get_container_size(v.size());
-            msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
-            msgpack::object* const pend = p + size;
-            o.via.array.ptr = p;
-            o.via.array.size = size;
-            typename MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Alloc>::const_iterator it(v.begin());
-            do {
-                *p = msgpack::object(*it, o.zone);
-                ++p;
-                ++it;
-            } while(p < pend);
-        }
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
-
-#undef MSGPACK_STD_TR1
-
-#endif // MSGPACK_STD_TR1
-
-#endif // MSGPACK_TYPE_TR1_UNORDERED_SET_HPP