Added string view to file list.

Updated the version to 2.1.1.

.travis.yml

@@ -1,103 +1,206 @@
 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
+sudo: false
+
 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_cmake.sh"     VERSION="cpp03" ARCH="64" LIBPATH="/usr/local/lib"   BOOST="boost" BOOST_INC="/usr/local/boost" CHAR_SIGN="unsigned"              API_VERSION="1"
-  - ACTION="ci/build_cmake.sh"     VERSION="cpp03" ARCH="32" LIBPATH="/usr/local/lib32" BOOST=""      BOOST_INC=""                 CHAR_SIGN="signed"                API_VERSION="2"
-  - ACTION="ci/build_cmake.sh"     VERSION="cpp11" ARCH="64" LIBPATH="/usr/local/lib"   BOOST="boost" BOOST_INC="/usr/local/boost" CHAR_SIGN="signed"                API_VERSION="2"
-  - ACTION="ci/build_cmake.sh"     VERSION="cpp11" ARCH="32" LIBPATH="/usr/local/lib32" BOOST=""      BOOST_INC=""                 SHARED="OFF" CHAR_SIGN="unsigned" API_VERSION="2"
-  - ACTION="ci/build_cmake.sh"     VERSION="cpp11" ARCH="64" LIBPATH="/usr/local/lib"   BOOST=""      BOOST_INC=""                 CHAR_SIGN="signed"                API_VERSION="2"
-  - ACTION="ci/build_cmake.sh"     VERSION="cpp11" ARCH="32" LIBPATH="/usr/local/lib32" BOOST="boost" BOOST_INC="/usr/local/boost" CHAR_SIGN="unsigned"              API_VERSION="2"
-  - ACTION="ci/build_cmake.sh"     VERSION="cpp03" ARCH="64" LIBPATH="/usr/local/lib"   BOOST=""      BOOST_INC=""                 CHAR_SIGN="unsigned"              API_VERSION="2"
-  - 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"   API_VERSION="1"
-  - 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"   API_VERSION="2"
-
-before_script:
- - export PATH=/usr/local/bin:$PATH && rm -rf install
+ - export BASE=`pwd`
+ - mkdir ${BASE}/usr
+ - if [ "$TRAVIS_OS_NAME" == "linux" ]; then wget --no-check-certificate https://cmake.org/files/v3.7/cmake-3.7.1-Linux-x86_64.sh -O cmake-3.7.1-Linux-x86_64.sh; fi
+ - if [ "$TRAVIS_OS_NAME" == "linux" ]; then chmod a+x cmake-3.7.1-Linux-x86_64.sh; fi
+ - if [ "$TRAVIS_OS_NAME" == "linux" ]; then ./cmake-3.7.1-Linux-x86_64.sh --prefix=${BASE}/usr --skip-license; fi
+ - if [ "$TRAVIS_OS_NAME" == "linux" ]; then export PATH="${BASE}/usr/bin:$PATH"; fi
+ - if [ "$TRAVIS_OS_NAME" == "linux" ]; then export LD_LIBRARY_PATH="${BASE}/usr/lib:$LD_LIBRARY_PATH"; fi
+ - if [ "$CXX" = "g++" ]; then export CXX="g++-6" CC="gcc-6"; fi
+ - if [ "$CXX" = "clang++" ] && [ "$TRAVIS_OS_NAME" == "linux" ]; then export CXX="clang++-3.7" CC="clang-3.7"; fi
+#gtest
+ - wget https://github.com/google/googletest/archive/release-1.7.0.zip -O googletest-release-1.7.0.zip
+ - unzip -q googletest-release-1.7.0.zip
+ - cd googletest-release-1.7.0
+ - $CXX -m${ARCH} src/gtest-all.cc -I. -Iinclude -c
+ - $CXX -m${ARCH} src/gtest_main.cc -I. -Iinclude -c
+ - ar -rv libgtest.a gtest-all.o
+ - ar -rv libgtest_main.a gtest_main.o
+ - mkdir -p ${BASE}/usr/include
+ - cp -r include/gtest ${BASE}/usr/include
+ - mkdir -p ${BASE}/usr/lib
+ - mv *.a ${BASE}/usr/lib
+ - cd ..
+# valgrind
+ - if [ "$TRAVIS_OS_NAME" == "linux" ]; then wget http://valgrind.org/downloads/valgrind-3.12.0.tar.bz2 && tar xjf valgrind-3.12.0.tar.bz2 && cd valgrind-3.12.0 && ./configure --prefix=${BASE}/usr > /dev/null && make -j3 > /dev/null && make install > /dev/null && cd ..; fi
+# boost
+ - if [ "$BOOST" == "ON" ]; then wget http://sourceforge.net/projects/boost/files/boost/1.63.0/boost_1_63_0.zip && unzip -q boost_1_63_0.zip && cd boost_1_63_0 && ./bootstrap.sh && ./b2 -j3 --prefix=${BASE}/usr --with-timer --with-chrono address-model=${ARCH} install > /dev/null && cd ..; fi
 
 matrix:
-  exclude:
+  include:
     - os: osx
-      compiler: gcc
+      compiler: clang
+      env: ACTION="ci/build_cmake.sh"  CXX11="ON" ARCH="64"   BOOST="ON" SHARED="ON"  CHAR_SIGN="unsigned" API_VERSION="1"
     - 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"   API_VERSION="1"
+      compiler: clang
+      env:  ACTION="ci/build_cmake.sh" CXX11="ON" ARCH="64"   BOOST="ON" SHARED="ON"  CHAR_SIGN="signed"   API_VERSION="2" X3_PARSE="ON"
     - os: osx
-      env: ACTION="ci/build_cmake.sh"     VERSION="cpp03" ARCH="32" LIBPATH="/usr/local/lib32" BOOST=""      BOOST_INC=""                 CHAR_SIGN="signed"                API_VERSION="2"
+      compiler: clang
+      env: ACTION="ci/build_cmake.sh"  CXX11="ON" ARCH="64"              SHARED="ON"  CHAR_SIGN="signed"   API_VERSION="2"
     - os: osx
-      env: ACTION="ci/build_cmake.sh"     VERSION="cpp11" ARCH="32" LIBPATH="/usr/local/lib32" BOOST=""      BOOST_INC=""                 SHARED="OFF" CHAR_SIGN="unsigned" API_VERSION="2"
-    - os: osx
-      env: ACTION="ci/build_cmake.sh"     VERSION="cpp11" ARCH="32" LIBPATH="/usr/local/lib32" BOOST="boost" BOOST_INC="/usr/local/boost" CHAR_SIGN="unsigned"              API_VERSION="2"
-    - 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"   API_VERSION="2"
-
-    - os: linux
-      compiler: gcc
-      env: ACTION="ci/build_cmake.sh"     VERSION="cpp03" ARCH="64" LIBPATH="/usr/local/lib"   BOOST="boost" BOOST_INC="/usr/local/boost" CHAR_SIGN="unsigned"              API_VERSION="1"
-    - os: linux
-      compiler: gcc
-      env: ACTION="ci/build_cmake.sh"     VERSION="cpp03" ARCH="64" LIBPATH="/usr/local/lib"   BOOST="boost" BOOST_INC="/usr/local/boost" CHAR_SIGN="unsigned"              API_VERSION="2"
-    - os: linux
-      compiler: gcc
-      env: ACTION="ci/build_cmake.sh"     VERSION="cpp03" ARCH="32" LIBPATH="/usr/local/lib32" BOOST=""      BOOST_INC=""                 CHAR_SIGN="signed"                API_VERSION="2"
-    - 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"                API_VERSION="2"
-    - 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" API_VERSION="2"
-
+      compiler: clang
+      env: ACTION="ci/build_cmake.sh"             ARCH="64"              SHARED="ON"  CHAR_SIGN="unsigned" API_VERSION="2"
     - os: linux
       compiler: clang
-      env: ACTION="ci/build_cmake.sh"     VERSION="cpp11" ARCH="64" LIBPATH="/usr/local/lib"   BOOST=""      BOOST_INC=""                 CHAR_SIGN="signed"                API_VERSION="2"
+      env: ACTION="ci/build_cmake.sh"             ARCH="64"   BOOST="ON" SHARED="ON"  CHAR_SIGN="unsigned" API_VERSION="1"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.7
+            - llvm-toolchain-precise
+          packages:
+            - g++-multilib
+            - gcc-multilib
+            - gcc-5-multilib
+            - g++-5-multilib
+            - bzip2
+            - clang-3.7
+            - libc6-dbg
     - os: linux
       compiler: clang
-      env: ACTION="ci/build_cmake.sh"     VERSION="cpp11" ARCH="32" LIBPATH="/usr/local/lib32" BOOST="boost" BOOST_INC="/usr/local/boost" CHAR_SIGN="unsigned"              API_VERSION="2"
+      env: ACTION="ci/build_cmake.sh"             ARCH="32"              SHARED="ON"  CHAR_SIGN="signed"   API_VERSION="2"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.7
+            - llvm-toolchain-precise
+          packages:
+            - g++-multilib
+            - gcc-multilib
+            - gcc-5-multilib
+            - g++-5-multilib
+            - lib32stdc++6-6-dbg
+            - lib32gcc1
+            - libc6-i386
+            - lib32z1-dev
+            - bzip2
+            - clang-3.7
+            - libc6-dbg
     - os: linux
       compiler: clang
-      env: ACTION="ci/build_cmake.sh"     VERSION="cpp11" ARCH="32" LIBPATH="/usr/local/lib32" BOOST="boost" BOOST_INC="/usr/local/boost" CHAR_SIGN="unsigned"              API_VERSION="2"
+      env: ACTION="ci/build_cmake.sh"  CXX11="ON" ARCH="64"   BOOST="ON" SHARED="ON"  CHAR_SIGN="signed"   API_VERSION="2" X3_PARSE="ON"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.7
+            - llvm-toolchain-precise
+          packages:
+            - g++-multilib
+            - gcc-multilib
+            - gcc-5-multilib
+            - g++-5-multilib
+            - bzip2
+            - clang-3.7
+            - libc6-dbg
     - os: linux
       compiler: clang
-      env: ACTION="ci/build_cmake.sh"     VERSION="cpp03" ARCH="64" LIBPATH="/usr/local/lib"   BOOST=""      BOOST_INC=""                 CHAR_SIGN="unsigned"              API_VERSION="2"
+      env: ACTION="ci/build_cmake.sh"  CXX11="ON" ARCH="32"              SHARED="OFF" CHAR_SIGN="unsigned" API_VERSION="2"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.7
+            - llvm-toolchain-precise
+          packages:
+            - g++-multilib
+            - gcc-multilib
+            - gcc-5-multilib
+            - g++-5-multilib
+            - lib32stdc++6-6-dbg
+            - lib32gcc1
+            - libc6-i386
+            - lib32z1-dev
+            - bzip2
+            - clang-3.7
+            - libc6-dbg
     - 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"   API_VERSION="1"
+      compiler: gcc
+      env: ACTION="ci/build_cmake.sh"  CXX11="ON" ARCH="64"              SHARED="ON"  CHAR_SIGN="signed"   API_VERSION="2"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-multilib
+            - gcc-multilib
+            - gcc-6-multilib
+            - g++-6-multilib
+            - bzip2
+            - libc6-dbg
     - 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"   API_VERSION="2"
+      compiler: gcc
+      env: ACTION="ci/build_cmake.sh"  CXX11="ON" ARCH="32"   BOOST="ON" SHARED="ON"  CHAR_SIGN="unsigned" API_VERSION="2" X3_PARSE="ON"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-multilib
+            - gcc-multilib
+            - gcc-6-multilib
+            - g++-6-multilib
+            - lib32stdc++6-6-dbg
+            - lib32gcc1
+            - libc6-i386
+            - lib32z1-dev
+            - bzip2
+            - libc6-dbg
+    - os: linux
+      compiler: gcc
+      env: ACTION="ci/build_cmake.sh"             ARCH="64"              SHARED="ON"  CHAR_SIGN="unsigned" API_VERSION="2"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-multilib
+            - gcc-multilib
+            - gcc-6-multilib
+            - g++-6-multilib
+            - bzip2
+            - libc6-dbg
+    - os: linux
+      compiler: gcc
+      env: ACTION="ci/build_cmake.sh"             ARCH="32"   BOOST="ON" SHARED="OFF" CHAR_SIGN="signed"   API_VERSION="1"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-multilib
+            - gcc-multilib
+            - gcc-6-multilib
+            - g++-6-multilib
+            - lib32stdc++6-6-dbg
+            - lib32gcc1
+            - libc6-i386
+            - lib32z1-dev
+            - bzip2
+            - libc6-dbg
+    - os: linux
+      compiler: gcc
+      env: ACTION="ci/build_cmake.sh"             ARCH="32"   BOOST="ON" SHARED="OFF" CHAR_SIGN="signed"   API_VERSION="2"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-multilib
+            - gcc-multilib
+            - gcc-6-multilib
+            - g++-6-multilib
+            - lib32stdc++6-6-dbg
+            - lib32gcc1
+            - libc6-i386
+            - lib32z1-dev
+            - bzip2
+            - libc6-dbg
 
 script:
-  - git clean -xdf && CMAKE_LIBRARY_PATH=${LIBPATH} ${ACTION} ${VERSION} ${ARCH} ${BOOST} ${BOOST_INC} ${CHAR_SIGN}
+  - CMAKE_CXX_COMPILER="${CXX}" CMAKE_C_COMPILER="${CC}" CMAKE_LIBRARY_PATH="${BASE}/usr/lib:${BASE}/build" GTEST_ROOT="${BASE}/usr" BOOST_ROOT="${BASE}/usr" ${ACTION}

CHANGELOG.md

@@ -1,3 +1,40 @@
+# 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 >>

CMakeLists.txt

@@ -21,7 +21,6 @@ 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)
@@ -39,27 +38,40 @@ IF (APPLE)
     ENDIF ()
 ENDIF ()
 
-IF (MSGPACK_CXX11)
+IF (MSGPACK_USE_X3_PARSE)
    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-      SET (CMAKE_CXX_FLAGS "-std=c++11 ${CMAKE_CXX_FLAGS}")
+      SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_X3_PARSE -std=c++14 ${CMAKE_CXX_FLAGS}")
    ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-      SET (CMAKE_CXX_FLAGS "-std=c++11 ${CMAKE_CXX_FLAGS}")
+      SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_X3_PARSE -std=c++14 ${CMAKE_CXX_FLAGS}")
    ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+      SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_X3_PARSE ${CMAKE_CXX_FLAGS}")
       IF (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19)
-          MESSAGE ( FATAL_ERROR "MSVC doesn't support C++11.")
+          MESSAGE ( FATAL_ERROR "MSVC doesn't support C++14.")
       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}")
+   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 ()
-   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}")
+   ELSE ()
+      IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+         IF ((CMAKE_CXX_COMPILER_VERSION VERSION_GREATER ${GNUCXX_STD_SUPPORT_VERSION}) OR
+             (CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL   ${GNUCXX_STD_SUPPORT_VERSION}))
+             SET (CMAKE_CXX_FLAGS "-std=c++98 ${CMAKE_CXX_FLAGS}")
+         ENDIF ()
+      ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+         SET (CMAKE_CXX_FLAGS "-std=c++98 ${CMAKE_CXX_FLAGS}")
+      ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+         IF (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 18)
+             SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_CPP03 ${CMAKE_CXX_FLAGS}")
+         ENDIF ()
       ENDIF ()
    ENDIF ()
 ENDIF ()
@@ -76,15 +88,25 @@ IF (MSGPACK_32BIT)
    ENDIF ()
 ENDIF ()
 
+OPTION (MSGPACK_BUILD_EXAMPLES "Build msgpack examples." ON)
+
 IF (MSGPACK_BOOST)
    SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_BOOST ${CMAKE_CXX_FLAGS}")
-   SET (Boost_USE_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 ()
+
+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 context timer system)
+IF (Boost_INCLUDE_DIRS)
+    INCLUDE_DIRECTORIES (
+        ${Boost_INCLUDE_DIRS}
+    )
+ENDIF ()
+IF (MSGPACK_BOOST_DIR)
+    INCLUDE_DIRECTORIES (
+        ${MSGPACK_BOOST_DIR}
+    )
 ENDIF ()
 
 IF (MSGPACK_CHAR_SIGN)
@@ -124,7 +146,6 @@ FIND_PACKAGE (Threads)
 IF (GTEST_FOUND AND ZLIB_FOUND AND THREADS_FOUND)
     OPTION (MSGPACK_BUILD_TESTS "Build msgpack tests." ON)
 ENDIF ()
-OPTION (MSGPACK_BUILD_EXAMPLES "Build msgpack examples." ON)
 
 OPTION (MSGPACK_ENABLE_CXX "Enable C++ interface." ON)
 OPTION (MSGPACK_ENABLE_SHARED "Build shared libaries in addition to static libraries." ON)
@@ -204,16 +225,6 @@ IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
     SET_PROPERTY (TARGET msgpackc-static 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}))
-        IF (MSGPACK_ENABLE_SHARED)
-            SET_PROPERTY (TARGET msgpackc APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
-        ENDIF ()
-        SET_PROPERTY (TARGET msgpackc-static APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
-    ENDIF ()
-ENDIF ()
-
 IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
     IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
         STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")

Files.cmake

@@ -153,7 +153,7 @@ LIST (APPEND msgpackc_HEADERS
     include/msgpack/zone.h
 )
 IF (MSGPACK_ENABLE_CXX)
-    LIST (APPEND msgpack_HEADERS
+    LIST (APPEND msgpackc_HEADERS
         include/msgpack.hpp
         include/msgpack/adaptor/adaptor_base.hpp
         include/msgpack/adaptor/adaptor_base_decl.hpp
@@ -165,6 +165,7 @@ IF (MSGPACK_ENABLE_CXX)
         include/msgpack/adaptor/boost/msgpack_variant_decl.hpp
         include/msgpack/adaptor/boost/optional.hpp
         include/msgpack/adaptor/boost/string_ref.hpp
+        include/msgpack/adaptor/boost/string_view.hpp
         include/msgpack/adaptor/carray.hpp
         include/msgpack/adaptor/char_ptr.hpp
         include/msgpack/adaptor/check_container_size.hpp
@@ -226,6 +227,7 @@ IF (MSGPACK_ENABLE_CXX)
         include/msgpack/object_fwd_decl.hpp
         include/msgpack/pack.hpp
         include/msgpack/pack_decl.hpp
+        include/msgpack/parse_return.hpp
         include/msgpack/preprocessor.hpp
         include/msgpack/preprocessor/arithmetic.hpp
         include/msgpack/preprocessor/arithmetic/add.hpp
@@ -500,6 +502,7 @@ IF (MSGPACK_ENABLE_CXX)
         include/msgpack/type.hpp
         include/msgpack/unpack.hpp
         include/msgpack/unpack_decl.hpp
+        include/msgpack/unpack_exception.hpp
         include/msgpack/v1/adaptor/adaptor_base.hpp
         include/msgpack/v1/adaptor/adaptor_base_decl.hpp
         include/msgpack/v1/adaptor/array_ref.hpp
@@ -510,6 +513,7 @@ IF (MSGPACK_ENABLE_CXX)
         include/msgpack/v1/adaptor/boost/msgpack_variant_decl.hpp
         include/msgpack/v1/adaptor/boost/optional.hpp
         include/msgpack/v1/adaptor/boost/string_ref.hpp
+        include/msgpack/v1/adaptor/boost/string_view.hpp
         include/msgpack/v1/adaptor/carray.hpp
         include/msgpack/v1/adaptor/char_ptr.hpp
         include/msgpack/v1/adaptor/check_container_size.hpp
@@ -586,11 +590,13 @@ IF (MSGPACK_ENABLE_CXX)
         include/msgpack/v1/object_fwd_decl.hpp
         include/msgpack/v1/pack.hpp
         include/msgpack/v1/pack_decl.hpp
+        include/msgpack/v1/parse_return.hpp
         include/msgpack/v1/preprocessor.hpp
         include/msgpack/v1/sbuffer.hpp
         include/msgpack/v1/sbuffer_decl.hpp
         include/msgpack/v1/unpack.hpp
         include/msgpack/v1/unpack_decl.hpp
+        include/msgpack/v1/unpack_exception.hpp
         include/msgpack/v1/version.hpp
         include/msgpack/v1/versioning.hpp
         include/msgpack/v1/vrefbuffer.hpp
@@ -621,20 +627,26 @@ IF (MSGPACK_ENABLE_CXX)
         include/msgpack/v2/adaptor/size_equal_only_decl.hpp
         include/msgpack/v2/adaptor/v4raw_decl.hpp
         include/msgpack/v2/cpp_config_decl.hpp
+        include/msgpack/v2/create_object_visitor.hpp
         include/msgpack/v2/detail/cpp03_zone_decl.hpp
         include/msgpack/v2/detail/cpp11_zone_decl.hpp
         include/msgpack/v2/fbuffer_decl.hpp
         include/msgpack/v2/iterator_decl.hpp
         include/msgpack/v2/meta_decl.hpp
+        include/msgpack/v2/null_visitor.hpp
         include/msgpack/v2/object.hpp
         include/msgpack/v2/object_decl.hpp
         include/msgpack/v2/object_fwd.hpp
         include/msgpack/v2/object_fwd_decl.hpp
         include/msgpack/v2/pack_decl.hpp
+        include/msgpack/v2/parse.hpp
+        include/msgpack/v2/parse_return.hpp
         include/msgpack/v2/sbuffer_decl.hpp
         include/msgpack/v2/unpack.hpp
         include/msgpack/v2/unpack_decl.hpp
         include/msgpack/v2/vrefbuffer_decl.hpp
+        include/msgpack/v2/x3_parse.hpp
+        include/msgpack/v2/x3_unpack.hpp
         include/msgpack/v2/zbuffer_decl.hpp
         include/msgpack/v2/zone_decl.hpp
         include/msgpack/version.hpp

README.md

@@ -1,7 +1,7 @@
 `msgpack` for C/C++
 ===================
 
-Version 2.0.0 (under development)[![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 2.1.1 [![Build Status](https://travis-ci.org/msgpack/msgpack-c.svg?branch=master)](https://travis-ci.org/msgpack/msgpack-c) [![Build status](https://ci.appveyor.com/api/projects/status/8kstcgt79qj123mw/branch/master?svg=true)](https://ci.appveyor.com/project/redboltz/msgpack-c/branch/master)
 
 It's like JSON but small and fast.
 
@@ -120,36 +120,7 @@ also install the C and C++ versions of msgpack.
 
 #### Install from git repository
 
-##### Using autotools
-
-You will need:
-
- - `gcc >= 4.1.0` or `clang >= 3.3.0`
- - `autoconf >= 2.60`
- - `automake >= 1.10`
- - `libtool >= 2.2.4`
-
-The build steps below are for C and C++03. If compiling for C++11,
-add `-std=c++11` to the environmental variable `CXXFLAGS` with
-`export CXXFLAGS="$CXXFLAGS -std=c++11"` prior to following the
-directions below.
-
-```bash
-$ git clone https://github.com/msgpack/msgpack-c
-$ cd msgpack-c
-$ ./bootstrap
-$ ./configure
-$ make
-```
-
-You can install the resulting library like this:
-
-```bash
-$ sudo make install
-```
-##### Using cmake
-
-###### Using the Terminal (CLI)
+##### Using the Terminal (CLI)
 
 You will need:
 
@@ -172,7 +143,7 @@ execute the following commands:
     $ cmake -DMSGPACK_CXX11=ON .
     $ sudo make install
 
-##### GUI on Windows
+#### GUI on Windows
 
 Clone msgpack-c git repository.
 

appveyor.yml

@@ -1,4 +1,4 @@
-version: 2.0.0.{build}
+version: 2.1.0.{build}
 
 environment:
   matrix:
@@ -24,19 +24,19 @@ environment:
       boost: -DMSGPACK_BOOST=OFF
       msvc: '"Visual Studio 14 2015"'
 build_script:
-- appveyor DownloadFile http://googletest.googlecode.com/files/gtest-1.7.0.zip -FileName gtest-1.7.0.zip
-- 7z x gtest-1.7.0.zip > NUL
-- cd gtest-1.7.0
+- appveyor DownloadFile https://github.com/google/googletest/archive/release-1.7.0.zip -FileName googletest-release-1.7.0.zip
+- 7z x googletest-release-1.7.0.zip > NUL
+- cd googletest-release-1.7.0
 - md build
 - cd build
 - cmake -G %msvc% -DBUILD_SHARED_LIBS=ON -DCMAKE_CXX_FLAGS=/D_VARIADIC_MAX=10 ..
 - cmake --build . --config Release
 - cd ..
 - cd ..
-- appveyor DownloadFile http://zlib.net/zlib-1.2.8.tar.gz -FileName zlib-1.2.8.tar.gz
-- 7z x zlib-1.2.8.tar.gz > NUL
-- 7z x zlib-1.2.8.tar > NUL
-- cd zlib-1.2.8
+- appveyor DownloadFile http://zlib.net/zlib-1.2.11.tar.gz -FileName zlib-1.2.11.tar.gz
+- 7z x zlib-1.2.11.tar.gz > NUL
+- 7z x zlib-1.2.11.tar > NUL
+- cd zlib-1.2.11
 - md build
 - cd build
 - cmake -G %msvc% ..
@@ -46,9 +46,9 @@ build_script:
 - cd ..
 - md build
 - cd build
-- cmake -G %msvc% %cpp11% %boost% -DMSGPACK_BOOST_DIR=C:\Libraries\\boost_1_60_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 -DCMAKE_CXX_FLAGS='"/D_VARIADIC_MAX=10 /EHsc"' ..
+- cmake -G %msvc% %cpp11% %boost% %x3_parse%  -DMSGPACK_BOOST_DIR=C:\Libraries\\boost_1_60_0 -DGTEST_LIBRARY=%APPVEYOR_BUILD_FOLDER%\googletest-release-1.7.0\build\Release\gtest.lib -DGTEST_MAIN_LIBRARY=%APPVEYOR_BUILD_FOLDER%\googletest-release-1.7.0\build\Release\gtest_main.lib -DGTEST_INCLUDE_DIR=%APPVEYOR_BUILD_FOLDER%\googletest-release-1.7.0\include -DZLIB_LIBRARY=%APPVEYOR_BUILD_FOLDER%\zlib-1.2.11\build\Release\zlib.lib -DZLIB_INCLUDE_DIR=%APPVEYOR_BUILD_FOLDER%\zlib-1.2.11 -DCMAKE_CXX_FLAGS='"/D_VARIADIC_MAX=10 /EHsc"' ..
 - cmake --build . --config Release
 
 test_script:
-- set PATH=%PATH%;%APPVEYOR_BUILD_FOLDER%\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

ci/build_cmake.sh

@@ -16,42 +16,14 @@ then
     exit $ret
 fi
 
-if [ $1 = "cpp11" ]
+if [ "${ARCH}" == "32" ]
 then
-    cpp11="-DMSGPACK_CXX11=ON"
+    export BIT32="ON"
 else
-    cpp11=""
+    export BIT32="OFF"
 fi
 
-if [ $2 = "32" ]
-then
-    bit32="-DMSGPACK_32BIT=ON"
-else
-    bit32=""
-fi
-
-if [ $3 = "boost" ]
-then
-    boost="-DMSGPACK_BOOST=ON"
-else
-    boost=""
-fi
-
-if [ "$4" != "" ]
-then
-    boost_dir="-DMSGPACK_BOOST_DIR=$4"
-else
-    boost_dir=""
-fi
-
-if [ "$5" = "OFF" ]
-then
-    shared="-DMSGPACK_ENABLE_SHARED=OFF"
-else
-    shared=""
-fi
-
-cmake $cpp11 $bit32 $boost $boost_dir $shared -DMSGPACK_CHAR_SIGN=${CHAR_SIGN} -DMSGPACK_DEFAULT_API_VERSION=${API_VERSION} ..
+cmake -DMSGPACK_CXX11=${CXX11} -DMSGPACK_32BIT=${BIT32} -DMSGPACK_BOOST=${BOOST} -DMSGPACK_ENABLE_SHARED=${SHARED} -DMSGPACK_CHAR_SIGN=${CHAR_SIGN} -DMSGPACK_DEFAULT_API_VERSION=${API_VERSION} -DMSGPACK_USE_X3_PARSE=${X3_PARSE} ..
 
 ret=$?
 if [ $ret -ne 0 ]
@@ -83,7 +55,7 @@ then
     exit $ret
 fi
 
-if [ "$2" != "32" ]
+if [ "${ARCH}" != "32" ] && [ `uname` = "Linux" ]
 then
     ctest -T memcheck | tee memcheck.log
 

example/CMakeLists.txt

@@ -2,3 +2,4 @@ ADD_SUBDIRECTORY (c)
 ADD_SUBDIRECTORY (cpp03)
 ADD_SUBDIRECTORY (cpp11)
 ADD_SUBDIRECTORY (boost)
+ADD_SUBDIRECTORY (x3)

example/boost/CMakeLists.txt

@@ -19,13 +19,6 @@ FOREACH (source_file ${exec_PROGRAMS})
         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}")

example/c/CMakeLists.txt

@@ -1,6 +1,9 @@
-INCLUDE_DIRECTORIES (
-    ../include
-)
+IF (MSGPACK_ENABLE_SHARED)
+    SET (MSGPACK_LIB msgpackc)
+ELSE ()
+    SET (MSGPACK_LIB msgpackc-static)
+ENDIF ()
+
 
 LIST (APPEND exec_PROGRAMS
     lib_buffer_unpack.c
@@ -17,7 +20,7 @@ FOREACH (source_file ${exec_PROGRAMS})
         ${source_file}
     )
     TARGET_LINK_LIBRARIES (${source_file_we}
-        msgpackc
+        ${MSGPACK_LIB}
     )
     IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
         SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Werror -g -O3")
@@ -27,13 +30,6 @@ FOREACH (source_file ${exec_PROGRAMS})
         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}")

example/c/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,  */

example/cpp03/CMakeLists.txt

@@ -22,13 +22,11 @@ IF (NOT MSVC)
     )
 ENDIF ()
 
-IF (MSGPACK_BOOST)
-    IF (NOT MSVC)
-        LIST (APPEND with_boost_lib_PROGRAMS
-            speed_test.cpp
-            speed_test_nested_array.cpp
-        )
-    ENDIF ()
+IF (Boost_TIMER_LIBRARY AND Boost_CHRONO_LIBRARY AND Boost_SYSTEM_LIBRARY)
+    LIST (APPEND with_boost_lib_PROGRAMS
+        speed_test.cpp
+        speed_test_nested_array.cpp
+    )
 ENDIF ()
 
 FOREACH (source_file ${exec_PROGRAMS})
@@ -56,10 +54,10 @@ FOREACH (source_file ${with_pthread_PROGRAMS})
         ${source_file}
     )
     TARGET_LINK_LIBRARIES (${source_file_we}
-        pthread
+        ${CMAKE_THREAD_LIBS_INIT}
     )
     IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-        SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Werror -g -O3 -pthread")
+        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]")
@@ -100,13 +98,6 @@ FOREACH (source_file ${with_boost_lib_PROGRAMS})
         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}")

example/cpp11/CMakeLists.txt

@@ -8,6 +8,12 @@ IF (MSGPACK_CXX11)
         non_def_con_class.cpp
     )
 
+    IF ("${MSGPACK_DEFAULT_API_VERSION}" GREATER "1")
+        LIST (APPEND exec_PROGRAMS
+            socket_stream_example.cpp
+        )
+    ENDIF ()
+
     FOREACH (source_file ${exec_PROGRAMS})
         GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
         ADD_EXECUTABLE (
@@ -22,13 +28,6 @@ IF (MSGPACK_CXX11)
             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}")

example/cpp11/socket_stream_example.cpp

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

example/x3/CMakeLists.txt

@@ -0,0 +1,64 @@
+IF (MSGPACK_USE_X3_PARSE)
+    INCLUDE_DIRECTORIES (
+        ../include
+    )
+
+    LIST (APPEND exec_PROGRAMS
+        unpack.cpp
+        parse.cpp
+    )
+    IF (Boost_CONTEXT_LIBRARY AND Boost_SYSTEM_LIBRARY AND CMAKE_THREAD_LIBS_INIT)
+        LIST (APPEND with_boost_PROGRAMS
+            stream_unpack.cpp
+        )
+    ENDIF ()
+    FOREACH (source_file ${exec_PROGRAMS})
+        GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
+        ADD_EXECUTABLE (
+            ${source_file_we}
+            ${source_file}
+        )
+        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 ")
+        ENDIF ()
+
+        IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+            SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
+        ENDIF ()
+
+        IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+            IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
+                STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+            ELSE ()
+                SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
+            ENDIF ()
+        ENDIF ()
+    ENDFOREACH ()
+    FOREACH (source_file ${with_boost_PROGRAMS})
+        GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
+        ADD_EXECUTABLE (
+            ${source_file_we}
+            ${source_file}
+        )
+        TARGET_LINK_LIBRARIES (${source_file_we}
+            ${Boost_CONTEXT_LIBRARY}
+            ${Boost_SYSTEM_LIBRARY}
+            ${CMAKE_THREAD_LIBS_INIT}
+        )
+        IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+            SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Werror -g ")
+        ENDIF ()
+
+        IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+            SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
+        ENDIF ()
+
+        IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+            IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
+                STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+            ELSE ()
+                SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
+            ENDIF ()
+        ENDIF ()
+    ENDFOREACH ()
+ENDIF ()

example/x3/parse.cpp

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

example/x3/stream_unpack.cpp

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

example/x3/unpack.cpp

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

include/msgpack/adaptor/boost/string_view.hpp

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

include/msgpack/adaptor/define_decl.hpp

@@ -42,6 +42,7 @@
     }
 
 #define MSGPACK_BASE_ARRAY(base) (*const_cast<base *>(static_cast<base const*>(this)))
+#define MSGPACK_NVP(name, value) (name) (value)
 
 #define MSGPACK_DEFINE_MAP_EACH_PROC(r, data, elem) \
     MSGPACK_PP_IF( \

include/msgpack/fbuffer.h

@@ -25,7 +25,7 @@ extern "C" {
 
 static inline int msgpack_fbuffer_write(void* data, const char* buf, size_t len)
 {
-    return (1 == fwrite(buf, len, 1, (FILE *)data)) ? 0 : -1;
+    return (len == fwrite(buf, len, 1, (FILE *)data)) ? 0 : -1;
 }
 
 /** @} */

include/msgpack/gcc_atomic.hpp

@@ -11,7 +11,6 @@
 #ifndef MSGPACK_GCC_ATOMIC_HPP
 #define MSGPACK_GCC_ATOMIC_HPP
 
-#ifdef ENABLE_GCC_CXX_ATOMIC
 #if defined(__GNUC__) && ((__GNUC__*10 + __GNUC_MINOR__) < 41)
 
 #include "msgpack/gcc_atomic.h"
@@ -28,6 +27,5 @@ int _msgpack_sync_incr_and_fetch(volatile _msgpack_atomic_counter_t* ptr)
 }
 
 #endif // old gcc workaround
-#endif // ENABLE_GCC_CXX_ATOMIC
 
 #endif /* gcc_atomic.hpp */

include/msgpack/object.h

@@ -29,6 +29,8 @@ typedef enum {
     MSGPACK_OBJECT_BOOLEAN              = 0x01,
     MSGPACK_OBJECT_POSITIVE_INTEGER     = 0x02,
     MSGPACK_OBJECT_NEGATIVE_INTEGER     = 0x03,
+    MSGPACK_OBJECT_FLOAT32              = 0x0a,
+    MSGPACK_OBJECT_FLOAT64              = 0x04,
     MSGPACK_OBJECT_FLOAT                = 0x04,
 #if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
     MSGPACK_OBJECT_DOUBLE               = MSGPACK_OBJECT_FLOAT, /* obsolete */
@@ -98,6 +100,9 @@ typedef struct msgpack_object_kv {
 MSGPACK_DLLEXPORT
 void msgpack_object_print(FILE* out, msgpack_object o);
 
+MSGPACK_DLLEXPORT
+int msgpack_object_print_buffer(char *buffer, size_t buffer_size, msgpack_object o);
+
 MSGPACK_DLLEXPORT
 bool msgpack_object_equal(const msgpack_object x, const msgpack_object y);
 

include/msgpack/parse_return.hpp

@@ -0,0 +1,16 @@
+//
+// MessagePack for C++ deserializing routine
+//
+// Copyright (C) 2017 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_PARSE_RETURN_HPP
+#define MSGPACK_PARSE_RETURN_HPP
+
+#include "msgpack/v1/parse_return.hpp"
+#include "msgpack/v2/parse_return.hpp"
+
+#endif // MSGPACK_PARSE_RETURN_HPP

include/msgpack/sysdep.h

@@ -14,6 +14,11 @@
 
 #include <stdlib.h>
 #include <stddef.h>
+
+#if defined(_MSC_VER) && _MSC_VER <= 1800
+#   define snprintf(buf, len, format,...) _snprintf_s(buf, len, len, format, __VA_ARGS__)
+#endif
+
 #if defined(_MSC_VER) && _MSC_VER < 1600
     typedef signed __int8 int8_t;
     typedef unsigned __int8 uint8_t;
@@ -46,9 +51,9 @@
 #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

include/msgpack/type.hpp

@@ -50,5 +50,6 @@
 #include "adaptor/boost/msgpack_variant.hpp"
 #include "adaptor/boost/optional.hpp"
 #include "adaptor/boost/string_ref.hpp"
+#include "adaptor/boost/string_view.hpp"
 
 #endif // defined(MSGPACK_USE_BOOST)

include/msgpack/unpack.h

@@ -146,6 +146,18 @@ static inline void   msgpack_unpacker_buffer_consumed(msgpack_unpacker* mpac, si
 MSGPACK_DLLEXPORT
 msgpack_unpack_return msgpack_unpacker_next(msgpack_unpacker* mpac, msgpack_unpacked* pac);
 
+/**
+ * Deserializes one object and set the number of parsed bytes involved.
+ * Returns true if it successes. Otherwise false is returned.
+ * @param mpac    pointer to an initialized msgpack_unpacker object.
+ * @param result  pointer to an initialized msgpack_unpacked object.
+ * @param p_bytes pointer to variable that will be set with the number of parsed bytes.
+ */
+MSGPACK_DLLEXPORT
+msgpack_unpack_return msgpack_unpacker_next_with_size(msgpack_unpacker* mpac,
+                                                      msgpack_unpacked* result,
+                                                      size_t *p_bytes);
+
 /**
  * Initializes a msgpack_unpacked object.
  * The initialized object must be destroyed by msgpack_unpacked_destroy(msgpack_unpacker*).
@@ -267,4 +279,3 @@ static inline msgpack_zone* msgpack_unpacked_release_zone(msgpack_unpacked* resu
 #endif
 
 #endif /* msgpack/unpack.h */
-

include/msgpack/unpack.hpp

@@ -14,5 +14,6 @@
 
 #include "msgpack/v1/unpack.hpp"
 #include "msgpack/v2/unpack.hpp"
+#include "msgpack/v2/x3_unpack.hpp"
 
 #endif // MSGPACK_UNPACK_HPP

include/msgpack/unpack_exception.hpp

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

include/msgpack/unpack_template.h

@@ -109,14 +109,17 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c
         int ret;
 
 #define push_simple_value(func) \
-        if(msgpack_unpack_callback(func)(user, &obj) < 0) { goto _failed; } \
+        ret = msgpack_unpack_callback(func)(user, &obj); \
+        if(ret < 0) { goto _failed; } \
         goto _push
 #define push_fixed_value(func, arg) \
-        if(msgpack_unpack_callback(func)(user, arg, &obj) < 0) { goto _failed; } \
+        ret = msgpack_unpack_callback(func)(user, arg, &obj); \
+        if(ret < 0) { goto _failed; } \
         goto _push
 #define push_variable_value(func, base, pos, len) \
-        if(msgpack_unpack_callback(func)(user, \
-            (const char*)base, (const char*)pos, len, &obj) < 0) { goto _failed; } \
+        ret = msgpack_unpack_callback(func)(user, \
+            (const char*)base, (const char*)pos, len, &obj); \
+        if(ret < 0) { goto _failed; } \
         goto _push
 
 #define again_fixed_trail(_cs, trail_len) \
@@ -130,33 +133,16 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c
         goto _fixed_trail_again
 
 #define start_container(func, count_, ct_) \
-        if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ \
-        if(msgpack_unpack_callback(func)(user, count_, &stack[top].obj) < 0) { goto _failed; } \
+        if(top >= MSGPACK_EMBED_STACK_SIZE) { \
+            ret = MSGPACK_UNPACK_NOMEM_ERROR; \
+            goto _failed; \
+        } /* FIXME */ \
+        ret = msgpack_unpack_callback(func)(user, count_, &stack[top].obj); \
+        if(ret < 0) { goto _failed; } \
         if((count_) == 0) { obj = stack[top].obj; goto _push; } \
         stack[top].ct = ct_; \
         stack[top].count = count_; \
         ++top; \
-        /*printf("container %d count %d stack %d\n",stack[top].obj,count_,top);*/ \
-        /*printf("stack push %d\n", top);*/ \
-        /* FIXME \
-        if(top >= stack_size) { \
-            if(stack_size == MSGPACK_EMBED_STACK_SIZE) { \
-                size_t csize = sizeof(msgpack_unpack_struct(_stack)) * MSGPACK_EMBED_STACK_SIZE; \
-                size_t nsize = csize * 2; \
-                msgpack_unpack_struct(_stack)* tmp = (msgpack_unpack_struct(_stack)*)malloc(nsize); \
-                if(tmp == NULL) { goto _failed; } \
-                memcpy(tmp, ctx->stack, csize); \
-                ctx->stack = stack = tmp; \
-                ctx->stack_size = stack_size = MSGPACK_EMBED_STACK_SIZE * 2; \
-            } else { \
-                size_t nsize = sizeof(msgpack_unpack_struct(_stack)) * ctx->stack_size * 2; \
-                msgpack_unpack_struct(_stack)* tmp = (msgpack_unpack_struct(_stack)*)realloc(ctx->stack, nsize); \
-                if(tmp == NULL) { goto _failed; } \
-                ctx->stack = stack = tmp; \
-                ctx->stack_size = stack_size = stack_size * 2; \
-            } \
-        } \
-        */ \
         goto _header_again
 
 #define NEXT_CS(p) \
@@ -231,6 +217,7 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c
                     case 0xdf:  // map 32
                         again_fixed_trail(NEXT_CS(p), 2u << (((unsigned int)*p) & 0x01));
                     default:
+                        ret = MSGPACK_UNPACK_PARSE_ERROR;
                         goto _failed;
                     }
                 SWITCH_RANGE(0xa0, 0xbf)  // FixStr
@@ -241,6 +228,7 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c
                     start_container(_map, ((unsigned int)*p) & 0x0f, MSGPACK_CT_MAP_KEY);
 
                 SWITCH_RANGE_DEFAULT
+                    ret = MSGPACK_UNPACK_PARSE_ERROR;
                     goto _failed;
                 SWITCH_RANGE_END
                 // end MSGPACK_CS_HEADER
@@ -384,6 +372,7 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c
                 }
 
                 default:
+                    ret = MSGPACK_UNPACK_PARSE_ERROR;
                     goto _failed;
                 }
             }
@@ -393,7 +382,8 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c
         c = &stack[top-1];
         switch(c->ct) {
         case MSGPACK_CT_ARRAY_ITEM:
-            if(msgpack_unpack_callback(_array_item)(user, &c->obj, obj) < 0) { goto _failed; }
+            ret = msgpack_unpack_callback(_array_item)(user, &c->obj, obj); \
+            if(ret < 0) { goto _failed; }
             if(--c->count == 0) {
                 obj = c->obj;
                 --top;
@@ -406,7 +396,8 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c
             c->ct = MSGPACK_CT_MAP_VALUE;
             goto _header_again;
         case MSGPACK_CT_MAP_VALUE:
-            if(msgpack_unpack_callback(_map_item)(user, &c->obj, c->map_key, obj) < 0) { goto _failed; }
+            ret = msgpack_unpack_callback(_map_item)(user, &c->obj, c->map_key, obj); \
+            if(ret < 0) { goto _failed; }
             if(--c->count == 0) {
                 obj = c->obj;
                 --top;
@@ -417,6 +408,7 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c
             goto _header_again;
 
         default:
+            ret = MSGPACK_UNPACK_PARSE_ERROR;
             goto _failed;
         }
 
@@ -436,7 +428,6 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c
 
     _failed:
         /*printf("** FAILED **\n"); */
-        ret = -1;
         goto _end;
 
     _out:

include/msgpack/v1/adaptor/boost/fusion.hpp

@@ -45,7 +45,7 @@ struct as<
             T,
             boost::mpl::bool_<true>,
             boost::mpl::if_ <
-                boost::mpl::and_<
+                boost::mpl::or_<
                     boost::mpl::_1,
                     msgpack::has_as<boost::mpl::_2>
                 >,

include/msgpack/v1/adaptor/boost/msgpack_variant.hpp

@@ -47,7 +47,7 @@ struct basic_variant :
         bool,              // BOOL
         int64_t,           // NEGATIVE_INTEGER
         uint64_t,          // POSITIVE_INTEGER
-        double,            // FLOAT
+        double,            // FLOAT32, FLOAT64
         std::string,       // STR
 #if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
         boost::string_ref, // STR
@@ -66,7 +66,7 @@ struct basic_variant :
         bool,              // BOOL
         int64_t,           // NEGATIVE_INTEGER
         uint64_t,          // POSITIVE_INTEGER
-        double,            // FLOAT
+        double,            // FLOAT32, FLOAT64
         std::string,       // STR
 #if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
         boost::string_ref, // STR
@@ -286,7 +286,8 @@ struct as<type::basic_variant<STR, BIN, EXT> > {
             return o.as<uint64_t>();
         case type::NEGATIVE_INTEGER:
             return o.as<int64_t>();
-        case type::FLOAT:
+        case type::FLOAT32:
+        case type::FLOAT64:
             return o.as<double>();
         case type::STR:
             return o.as<STR>();
@@ -326,7 +327,8 @@ struct convert<type::basic_variant<STR, BIN, EXT> > {
         case type::NEGATIVE_INTEGER:
             v = o.as<int64_t>();
             break;
-        case type::FLOAT:
+        case type::FLOAT32:
+        case type::FLOAT64:
             v = o.as<double>();
             break;
         case type::STR:

include/msgpack/v1/adaptor/boost/string_view.hpp

@@ -0,0 +1,87 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2017 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_V1_TYPE_BOOST_STRING_VIEW_HPP
+#define MSGPACK_V1_TYPE_BOOST_STRING_VIEW_HPP
+
+#include <boost/version.hpp>
+#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 61
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/adaptor/check_container_size.hpp"
+
+#include <boost/utility/string_view.hpp>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace adaptor {
+
+template <>
+struct convert<boost::string_view> {
+    msgpack::object const& operator()(msgpack::object const& o, boost::string_view& v) const {
+        switch (o.type) {
+        case msgpack::type::BIN:
+            v = boost::string_view(o.via.bin.ptr, o.via.bin.size);
+            break;
+        case msgpack::type::STR:
+            v = boost::string_view(o.via.str.ptr, o.via.str.size);
+            break;
+        default:
+            throw msgpack::type_error();
+            break;
+        }
+        return o;
+    }
+};
+
+template <>
+struct pack<boost::string_view> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const boost::string_view& 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_view> {
+    void operator()(msgpack::object& o, const boost::string_view& 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_view> {
+    void operator()(msgpack::object::with_zone& o, const boost::string_view& 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_V1_TYPE_BOOST_STRING_VIEW_HPP

include/msgpack/v1/adaptor/carray.hpp

@@ -101,7 +101,7 @@ struct pack<char[N]> {
         char const* p = v;
         uint32_t size = checked_get_container_size(N);
         char const* p2 = static_cast<char const*>(std::memchr(p, '\0', size));
-        uint32_t adjusted_size = p2 ? p2 - p : size;
+        uint32_t adjusted_size = p2 ? static_cast<uint32_t>(p2 - p) : size;
         o.pack_str(adjusted_size);
         o.pack_str_body(p, adjusted_size);
         return o;
@@ -115,7 +115,7 @@ struct pack<const char[N]> {
         uint32_t size = checked_get_container_size(N);
         char const* p = v;
         char const* p2 = static_cast<char const*>(std::memchr(p, '\0', size));
-        uint32_t adjusted_size = p2 ? p2 - p : size;
+        uint32_t adjusted_size = p2 ? static_cast<uint32_t>(p2 - p) : size;
         o.pack_str(adjusted_size);
         o.pack_str_body(p, adjusted_size);
         return o;
@@ -167,7 +167,7 @@ struct object_with_zone<char[N]> {
         char const* p = v;
         uint32_t size = checked_get_container_size(N);
         char const* p2 = static_cast<char const*>(std::memchr(p, '\0', size));
-        uint32_t adjusted_size = p2 ? p2 - p : size;
+        uint32_t adjusted_size = p2 ? static_cast<uint32_t>(p2 - p) : size;
         o.type = msgpack::type::STR;
         char* ptr = static_cast<char*>(o.zone.allocate_align(adjusted_size));
         o.via.str.ptr = ptr;
@@ -182,7 +182,7 @@ struct object_with_zone<const char[N]> {
         char const* p = v;
         uint32_t size = checked_get_container_size(N);
         char const* p2 = static_cast<char const*>(std::memchr(p, '\0', size));
-        uint32_t adjusted_size = p2 ? p2 - p : size;
+        uint32_t adjusted_size = p2 ? static_cast<uint32_t>(p2 - p) : size;
         o.type = msgpack::type::STR;
         char* ptr = static_cast<char*>(o.zone.allocate_align(adjusted_size));
         o.via.str.ptr = ptr;
@@ -221,7 +221,7 @@ struct object<char[N]> {
         char const* p = v;
         uint32_t size = checked_get_container_size(N);
         char const* p2 = static_cast<char const*>(std::memchr(p, '\0', size));
-        uint32_t adjusted_size = p2 ? p2 - p : size;
+        uint32_t adjusted_size = p2 ? static_cast<uint32_t>(p2 - p) : size;
         o.type = msgpack::type::STR;
         o.via.str.ptr = p;
         o.via.str.size = adjusted_size;
@@ -234,7 +234,7 @@ struct object<const char[N]> {
         char const* p = v;
         uint32_t size = checked_get_container_size(N);
         char const* p2 = static_cast<char const*>(std::memchr(p, '\0', size));
-        uint32_t adjusted_size = p2 ? p2 - p : size;
+        uint32_t adjusted_size = p2 ? static_cast<uint32_t>(p2 - p) : size;
         o.type = msgpack::type::STR;
         o.via.str.ptr = p;
         o.via.str.size = adjusted_size;

include/msgpack/v1/adaptor/cpp11/tuple.hpp

@@ -109,7 +109,7 @@ struct StdTupleConverter<Tuple, 0> {
 namespace adaptor {
 
 template <typename... Args>
-struct as<std::tuple<Args...>, typename std::enable_if<msgpack::all_of<msgpack::has_as, Args...>::value>::type>  {
+struct as<std::tuple<Args...>, typename std::enable_if<msgpack::any_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(); }

include/msgpack/v1/adaptor/cpp11/unordered_map.hpp

@@ -27,7 +27,7 @@ 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> {
+    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);
@@ -100,7 +100,7 @@ struct object_with_zone<std::unordered_map<K, V, Hash, Compare, Alloc>> {
 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> {
+    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);

include/msgpack/v1/adaptor/detail/cpp11_msgpack_tuple.hpp

@@ -146,7 +146,7 @@ struct MsgpackTupleConverter<Tuple, 0> {
 namespace adaptor {
 
 template <typename... Args>
-struct as<msgpack::type::tuple<Args...>, typename std::enable_if<msgpack::all_of<msgpack::has_as, Args...>::value>::type>  {
+struct as<msgpack::type::tuple<Args...>, typename std::enable_if<msgpack::any_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(); }

include/msgpack/v1/adaptor/float.hpp

@@ -27,7 +27,7 @@ namespace adaptor {
 template <>
 struct convert<float> {
     msgpack::object const& operator()(msgpack::object const& o, float& v) const {
-        if(o.type == msgpack::type::FLOAT) {
+        if(o.type == msgpack::type::FLOAT32 || o.type == msgpack::type::FLOAT64) {
             v = static_cast<float>(o.via.f64);
         }
         else if (o.type == msgpack::type::POSITIVE_INTEGER) {
@@ -56,7 +56,7 @@ struct pack<float> {
 template <>
 struct convert<double> {
     msgpack::object const& operator()(msgpack::object const& o, double& v) const {
-        if(o.type == msgpack::type::FLOAT) {
+        if(o.type == msgpack::type::FLOAT32 || o.type == msgpack::type::FLOAT64) {
             v = o.via.f64;
         }
         else if (o.type == msgpack::type::POSITIVE_INTEGER) {
@@ -85,7 +85,7 @@ struct pack<double> {
 template <>
 struct object<float> {
     void operator()(msgpack::object& o, float v) const {
-        o.type = msgpack::type::FLOAT;
+        o.type = msgpack::type::FLOAT32;
         o.via.f64 = static_cast<double>(v);
     }
 };
@@ -93,7 +93,7 @@ struct object<float> {
 template <>
 struct object<double> {
     void operator()(msgpack::object& o, double v) const {
-        o.type = msgpack::type::FLOAT;
+        o.type = msgpack::type::FLOAT64;
         o.via.f64 = v;
     }
 };

include/msgpack/v1/adaptor/map.hpp

@@ -48,7 +48,7 @@ namespace adaptor {
 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> {
+    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;
@@ -129,7 +129,7 @@ struct object_with_zone<type::assoc_vector<K, V, Compare, Alloc> > {
 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> {
+    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);
@@ -222,7 +222,7 @@ struct object_with_zone<std::map<K, V, Compare, Alloc> > {
 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> {
+    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);

include/msgpack/v1/adaptor/pair.hpp

@@ -28,7 +28,7 @@ namespace adaptor {
 
 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> {
+          typename std::enable_if<msgpack::any_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(); }

include/msgpack/v1/cpp_config.hpp

@@ -126,4 +126,10 @@ template<class T> struct is_pointer : detail::is_pointer_helper<typename remove_
 
 #endif // MSGPACK_USE_CPP03
 
+#if __cplusplus >= 201402L
+#define MSGPACK_DEPRECATED(msg) [[deprecated(msg)]]
+#else  // __cplusplus >= 201402L
+#define MSGPACK_DEPRECATED(msg)
+#endif // __cplusplus >= 201402L
+
 #endif // MSGPACK_V1_CPP_CONFIG_HPP

include/msgpack/v1/meta.hpp

@@ -21,11 +21,17 @@ namespace msgpack {
 MSGPACK_API_VERSION_NAMESPACE(v1) {
 /// @endcond
 
+
+
 namespace detail {
 
 template<bool...values> struct all_of_imp
     : std::is_same<bool_pack<values..., true>, bool_pack<true, values...>>{};
 
+template<bool...values> struct any_of_imp {
+    static const bool value = !std::is_same<bool_pack<values..., false>, bool_pack<false, values...>>::value;
+};
+
 } // namespace detail
 
 template<std::size_t... Is> struct seq {};

include/msgpack/v1/meta_decl.hpp

@@ -28,11 +28,16 @@ template<bool...> struct bool_pack;
 
 template<bool...values> struct all_of_imp;
 
+template<bool...values> struct any_of_imp;
+
 } // namespace detail
 
 template<template <class> class T, class... U>
 using all_of = detail::all_of_imp<T<U>::value...>;
 
+template<template <class> class T, class... U>
+using any_of = detail::any_of_imp<(T<U>::value)...>;
+
 template<std::size_t... Is> struct seq;
 
 template<std::size_t N, std::size_t... Is>

include/msgpack/v1/object.hpp

@@ -60,7 +60,6 @@ public:
     ) :
         m_obj(obj), m_zone(msgpack::move(z)) { }
 
-    // obsolete
     void set(msgpack::object const& obj)
         { m_obj = obj; }
 
@@ -257,7 +256,11 @@ struct pack<msgpack::object> {
             o.pack_int64(v.via.i64);
             return o;
 
-        case msgpack::type::FLOAT:
+        case msgpack::type::FLOAT32:
+            o.pack_float(static_cast<float>(v.via.f64));
+            return o;
+
+        case msgpack::type::FLOAT64:
             o.pack_double(v.via.f64);
             return o;
 
@@ -311,7 +314,8 @@ struct object_with_zone<msgpack::object> {
         case msgpack::type::BOOLEAN:
         case msgpack::type::POSITIVE_INTEGER:
         case msgpack::type::NEGATIVE_INTEGER:
-        case msgpack::type::FLOAT:
+        case msgpack::type::FLOAT32:
+        case msgpack::type::FLOAT64:
             std::memcpy(&o.via, &v.via, sizeof(v.via));
             return;
 
@@ -395,7 +399,6 @@ class define : public Type {
 public:
     typedef Type msgpack_type;
     typedef define<Type> define_type;
-
     define() {}
     define(const msgpack_type& v) : msgpack_type(v) {}
 
@@ -438,7 +441,8 @@ inline bool operator==(const msgpack::object& x, const msgpack::object& y)
     case msgpack::type::NEGATIVE_INTEGER:
         return x.via.i64 == y.via.i64;
 
-    case msgpack::type::FLOAT:
+    case msgpack::type::FLOAT32:
+    case msgpack::type::FLOAT64:
         return x.via.f64 == y.via.f64;
 
     case msgpack::type::STR:
@@ -698,7 +702,11 @@ inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const ms
         o.pack_int64(v.via.i64);
         return o;
 
-    case msgpack::type::FLOAT:
+    case msgpack::type::FLOAT32:
+        o.pack_float(v.via.f64);
+        return o;
+
+    case msgpack::type::FLOAT64:
         o.pack_double(v.via.f64);
         return o;
 
@@ -766,7 +774,8 @@ inline std::ostream& operator<< (std::ostream& s, const msgpack::object& o)
         s << o.via.i64;
         break;
 
-    case msgpack::type::FLOAT:
+    case msgpack::type::FLOAT32:
+    case msgpack::type::FLOAT64:
         s << o.via.f64;
         break;
 
@@ -802,7 +811,9 @@ inline std::ostream& operator<< (std::ostream& s, const msgpack::object& o)
             default: {
                 unsigned int code = static_cast<unsigned int>(c);
                 if (code < 0x20 || code == 0x7f) {
+                    std::ios::fmtflags flags(s.flags());
                     s << "\\u" << std::hex << std::setw(4) << std::setfill('0') << (code & 0xff);
+                    s.flags(flags);
                 }
                 else {
                     s << c;

include/msgpack/v1/object_decl.hpp

@@ -85,14 +85,17 @@ void operator<< (msgpack::object& o, const msgpack_object& v);
 
 // obsolete
 template <typename T>
+MSGPACK_DEPRECATED("please use member function version of object::convert(T&)")
 void convert(T& v, msgpack::object const& o);
 
 // obsolete
 template <typename Stream, typename T>
+MSGPACK_DEPRECATED("please use member function version of packer::pack(const T&)")
 void pack(msgpack::packer<Stream>& o, const T& v);
 
 // obsolete
 template <typename Stream, typename T>
+MSGPACK_DEPRECATED("please use member function version of packer::pack(const T&)")
 void pack_copy(msgpack::packer<Stream>& o, T v);
 
 template <typename Stream>

include/msgpack/v1/object_fwd.hpp

@@ -78,6 +78,7 @@ struct object {
         uint64_t u64;
         int64_t  i64;
 #if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
+        MSGPACK_DEPRECATED("please use f64 instead")
         double   dec; // obsolete
 #endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT
         double   f64;
@@ -157,6 +158,7 @@ struct object {
      * @return The pointer of `v`.
      */
     template <typename T>
+    MSGPACK_DEPRECATED("please use reference version instead")
     typename msgpack::enable_if<
         msgpack::is_pointer<T>::value,
         T
@@ -214,6 +216,7 @@ struct object {
      * @param z The pointer to the zone that is used by the object.
      */
     template <typename T>
+    MSGPACK_DEPRECATED("please use zone reference version instead of the pointer version")
     object(const T& v, msgpack::zone* z);
 
     template <typename T>

include/msgpack/v1/object_fwd_decl.hpp

@@ -30,9 +30,11 @@ namespace type {
         BOOLEAN             = MSGPACK_OBJECT_BOOLEAN,
         POSITIVE_INTEGER    = MSGPACK_OBJECT_POSITIVE_INTEGER,
         NEGATIVE_INTEGER    = MSGPACK_OBJECT_NEGATIVE_INTEGER,
+        FLOAT32             = MSGPACK_OBJECT_FLOAT32,
+        FLOAT64             = MSGPACK_OBJECT_FLOAT64,
         FLOAT               = MSGPACK_OBJECT_FLOAT,
 #if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
-        DOUBLE              = MSGPACK_OBJECT_DOUBLE, // obsolete
+        DOUBLE              = MSGPACK_DEPRECATED("please use FLOAT64 instead") MSGPACK_OBJECT_DOUBLE, // obsolete
 #endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT
         STR                 = MSGPACK_OBJECT_STR,
         BIN                 = MSGPACK_OBJECT_BIN,

include/msgpack/v1/parse_return.hpp

@@ -0,0 +1,36 @@
+//
+// MessagePack for C++ deserializing routine
+//
+// Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_V1_PARSE_RETURN_HPP
+#define MSGPACK_V1_PARSE_RETURN_HPP
+
+#include "msgpack/versioning.hpp"
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+
+// for internal use
+typedef enum {
+    PARSE_SUCCESS              =  2,
+    PARSE_EXTRA_BYTES          =  1,
+    PARSE_CONTINUE             =  0,
+    PARSE_PARSE_ERROR          = -1
+} parse_return;
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+}  // namespace msgpack
+
+#endif // MSGPACK_V1_PARSE_RETURN_HPP

include/msgpack/v1/unpack.hpp

@@ -14,12 +14,12 @@
 #include "msgpack/unpack_decl.hpp"
 #include "msgpack/object.hpp"
 #include "msgpack/zone.hpp"
+#include "msgpack/unpack_exception.hpp"
 #include "msgpack/unpack_define.h"
 #include "msgpack/cpp_config.hpp"
 #include "msgpack/sysdep.h"
 
 #include <memory>
-#include <stdexcept>
 
 #if !defined(MSGPACK_USE_CPP03)
 #include <atomic>
@@ -39,96 +39,6 @@ namespace msgpack {
 MSGPACK_API_VERSION_NAMESPACE(v1) {
 /// @endcond
 
-struct unpack_error : public std::runtime_error {
-    explicit unpack_error(const std::string& msg)
-        :std::runtime_error(msg) {}
-#if !defined(MSGPACK_USE_CPP03)
-    explicit unpack_error(const char* msg):
-        std::runtime_error(msg) {}
-#endif // !defined(MSGPACK_USE_CPP03)
-};
-
-struct parse_error : public unpack_error {
-    explicit parse_error(const std::string& msg)
-        :unpack_error(msg) {}
-#if !defined(MSGPACK_USE_CPP03)
-    explicit parse_error(const char* msg)
-        :unpack_error(msg) {}
-#endif // !defined(MSGPACK_USE_CPP03)
-};
-
-struct insufficient_bytes : public unpack_error {
-    explicit insufficient_bytes(const std::string& msg)
-        :unpack_error(msg) {}
-#if !defined(MSGPACK_USE_CPP03)
-    explicit insufficient_bytes(const char* msg)
-        :unpack_error(msg) {}
-#endif // !defined(MSGPACK_USE_CPP03)
-};
-
-struct size_overflow : public unpack_error {
-    explicit size_overflow(const std::string& msg)
-        :unpack_error(msg) {}
-#if !defined(MSGPACK_USE_CPP03)
-    explicit size_overflow(const char* msg)
-        :unpack_error(msg) {}
-#endif
-};
-
-struct array_size_overflow : public size_overflow {
-    array_size_overflow(const std::string& msg)
-        :size_overflow(msg) {}
-#if !defined(MSGPACK_USE_CPP03)
-    array_size_overflow(const char* msg)
-        :size_overflow(msg) {}
-#endif
-};
-
-struct map_size_overflow : public size_overflow {
-    map_size_overflow(const std::string& msg)
-        :size_overflow(msg) {}
-#if !defined(MSGPACK_USE_CPP03)
-    map_size_overflow(const char* msg)
-        :size_overflow(msg) {}
-#endif
-};
-
-struct str_size_overflow : public size_overflow {
-    str_size_overflow(const std::string& msg)
-        :size_overflow(msg) {}
-#if !defined(MSGPACK_USE_CPP03)
-    str_size_overflow(const char* msg)
-        :size_overflow(msg) {}
-#endif
-};
-
-struct bin_size_overflow : public size_overflow {
-    bin_size_overflow(const std::string& msg)
-        :size_overflow(msg) {}
-#if !defined(MSGPACK_USE_CPP03)
-    bin_size_overflow(const char* msg)
-        :size_overflow(msg) {}
-#endif
-};
-
-struct ext_size_overflow : public size_overflow {
-    ext_size_overflow(const std::string& msg)
-        :size_overflow(msg) {}
-#if !defined(MSGPACK_USE_CPP03)
-    ext_size_overflow(const char* msg)
-        :size_overflow(msg) {}
-#endif
-};
-
-struct depth_size_overflow : public size_overflow {
-    depth_size_overflow(const std::string& msg)
-        :size_overflow(msg) {}
-#if !defined(MSGPACK_USE_CPP03)
-    depth_size_overflow(const char* msg)
-        :size_overflow(msg) {}
-#endif
-};
-
 namespace detail {
 
 class unpack_user {
@@ -184,10 +94,10 @@ inline void unpack_int64(int64_t d, msgpack::object& o)
         else { o.type = msgpack::type::NEGATIVE_INTEGER; o.via.i64 = d; } }
 
 inline void unpack_float(float d, msgpack::object& o)
-{ o.type = msgpack::type::FLOAT; o.via.f64 = d; }
+{ o.type = msgpack::type::FLOAT32; o.via.f64 = d; }
 
 inline void unpack_double(double d, msgpack::object& o)
-{ o.type = msgpack::type::FLOAT; o.via.f64 = d; }
+{ o.type = msgpack::type::FLOAT64; o.via.f64 = d; }
 
 inline void unpack_nil(msgpack::object& o)
 { o.type = msgpack::type::NIL; }
@@ -203,7 +113,11 @@ struct unpack_array {
         if (n > u.limit().array()) throw msgpack::array_size_overflow("array size overflow");
         o.type = msgpack::type::ARRAY;
         o.via.array.size = 0;
-        o.via.array.ptr = static_cast<msgpack::object*>(u.zone().allocate_align(n*sizeof(msgpack::object)));
+        size_t size = n*sizeof(msgpack::object);
+        if (size / sizeof(msgpack::object) != n) {
+            throw msgpack::array_size_overflow("array size overflow");
+        }
+        o.via.array.ptr = static_cast<msgpack::object*>(u.zone().allocate_align(size));
     }
 };
 
@@ -221,7 +135,11 @@ struct unpack_map {
         if (n > u.limit().map()) throw msgpack::map_size_overflow("map size overflow");
         o.type = msgpack::type::MAP;
         o.via.map.size = 0;
-        o.via.map.ptr = static_cast<msgpack::object_kv*>(u.zone().allocate_align(n*sizeof(msgpack::object_kv)));
+        size_t size = n*sizeof(msgpack::object_kv);
+        if (size / sizeof(msgpack::object_kv) != n) {
+            throw msgpack::map_size_overflow("map size overflow");
+        }
+        o.via.map.ptr = static_cast<msgpack::object_kv*>(u.zone().allocate_align(size));
     }
 };
 
@@ -1003,6 +921,7 @@ public:
      * This function is obsolete. Use the reference inteface version of next() function instead of
      * the pointer interface version.
      */
+    MSGPACK_DEPRECATED("please use reference version instead")
     bool next(msgpack::object_handle* result);
 
     /// Unpack one msgpack::object.
@@ -1416,7 +1335,7 @@ inline void unpacker::remove_nonparsed_buffer()
 
 namespace detail {
 
-inline unpack_return
+inline parse_return
 unpack_imp(const char* data, std::size_t len, std::size_t& off,
            msgpack::zone& result_zone, msgpack::object& result, bool& referenced,
            unpack_reference_func f = MSGPACK_NULLPTR, void* user_data = MSGPACK_NULLPTR,
@@ -1426,7 +1345,7 @@ unpack_imp(const char* data, std::size_t len, std::size_t& off,
 
     if(len <= noff) {
         // FIXME
-        return UNPACK_CONTINUE;
+        return PARSE_CONTINUE;
     }
 
     detail::context ctx(f, user_data, limit);
@@ -1438,23 +1357,23 @@ unpack_imp(const char* data, std::size_t len, std::size_t& off,
 
     int e = ctx.execute(data, len, noff);
     if(e < 0) {
-        return UNPACK_PARSE_ERROR;
+        return PARSE_PARSE_ERROR;
     }
 
     referenced = ctx.user().referenced();
     off = noff;
 
     if(e == 0) {
-        return UNPACK_CONTINUE;
+        return PARSE_CONTINUE;
     }
 
     result = ctx.data();
 
     if(noff < len) {
-        return UNPACK_EXTRA_BYTES;
+        return PARSE_EXTRA_BYTES;
     }
 
-    return UNPACK_SUCCESS;
+    return PARSE_SUCCESS;
 }
 
 } // detail
@@ -1471,19 +1390,19 @@ inline msgpack::object_handle unpack(
     msgpack::unique_ptr<msgpack::zone> z(new msgpack::zone);
     referenced = false;
     std::size_t noff = off;
-    unpack_return ret = detail::unpack_imp(
+    parse_return ret = detail::unpack_imp(
         data, len, noff, *z, obj, referenced, f, user_data, limit);
 
     switch(ret) {
-    case UNPACK_SUCCESS:
+    case PARSE_SUCCESS:
         off = noff;
         return msgpack::object_handle(obj, msgpack::move(z));
-    case UNPACK_EXTRA_BYTES:
+    case PARSE_EXTRA_BYTES:
         off = noff;
         return msgpack::object_handle(obj, msgpack::move(z));
-    case UNPACK_CONTINUE:
+    case PARSE_CONTINUE:
         throw msgpack::insufficient_bytes("insufficient bytes");
-    case UNPACK_PARSE_ERROR:
+    case PARSE_PARSE_ERROR:
     default:
         throw msgpack::parse_error("parse error");
     }
@@ -1528,23 +1447,23 @@ inline void unpack(
     msgpack::unique_ptr<msgpack::zone> z(new msgpack::zone);
     referenced = false;
     std::size_t noff = off;
-    unpack_return ret = detail::unpack_imp(
+    parse_return ret = detail::unpack_imp(
         data, len, noff, *z, obj, referenced, f, user_data, limit);
 
     switch(ret) {
-    case UNPACK_SUCCESS:
+    case PARSE_SUCCESS:
         off = noff;
         result.set(obj);
         result.zone() = msgpack::move(z);
         return;
-    case UNPACK_EXTRA_BYTES:
+    case PARSE_EXTRA_BYTES:
         off = noff;
         result.set(obj);
         result.zone() = msgpack::move(z);
         return;
-    case UNPACK_CONTINUE:
+    case PARSE_CONTINUE:
         throw msgpack::insufficient_bytes("insufficient bytes");
-    case UNPACK_PARSE_ERROR:
+    case PARSE_PARSE_ERROR:
     default:
         throw msgpack::parse_error("parse error");
     }
@@ -1591,19 +1510,19 @@ inline msgpack::object unpack(
     msgpack::object obj;
     std::size_t noff = off;
     referenced = false;
-    unpack_return ret = detail::unpack_imp(
+    parse_return ret = detail::unpack_imp(
         data, len, noff, z, obj, referenced, f, user_data, limit);
 
     switch(ret) {
-    case UNPACK_SUCCESS:
+    case PARSE_SUCCESS:
         off = noff;
         return obj;
-    case UNPACK_EXTRA_BYTES:
+    case PARSE_EXTRA_BYTES:
         off = noff;
         return obj;
-    case UNPACK_CONTINUE:
+    case PARSE_CONTINUE:
         throw msgpack::insufficient_bytes("insufficient bytes");
-    case UNPACK_PARSE_ERROR:
+    case PARSE_PARSE_ERROR:
     default:
         throw msgpack::parse_error("parse error");
     }
@@ -1643,6 +1562,7 @@ inline msgpack::object unpack(
 
 // obsolete
 // pointer version
+MSGPACK_DEPRECATED("please use reference version instead")
 inline void unpack(
     msgpack::object_handle* result,
     const char* data, std::size_t len, std::size_t* off, bool* referenced,

include/msgpack/v1/unpack_decl.hpp

@@ -16,6 +16,7 @@
 #include "msgpack/zone.hpp"
 #include "msgpack/cpp_config.hpp"
 #include "msgpack/sysdep.h"
+#include "msgpack/parse_return.hpp"
 
 #include <memory>
 #include <stdexcept>
@@ -433,17 +434,9 @@ void unpack(
     unpack_reference_func f = MSGPACK_NULLPTR, void* user_data = MSGPACK_NULLPTR, unpack_limit const& limit = unpack_limit());
 
 
-// for internal use
-typedef enum {
-    UNPACK_SUCCESS              =  2,
-    UNPACK_EXTRA_BYTES          =  1,
-    UNPACK_CONTINUE             =  0,
-    UNPACK_PARSE_ERROR          = -1
-} unpack_return;
-
 namespace detail {
 
-unpack_return
+parse_return
 unpack_imp(const char* data, std::size_t len, std::size_t& off,
            msgpack::zone& result_zone, msgpack::object& result, bool& referenced,
            unpack_reference_func f, void* user_data,

include/msgpack/v1/unpack_exception.hpp

@@ -0,0 +1,122 @@
+//
+// MessagePack for C++ deserializing routine
+//
+// Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_V1_UNPACK_EXCEPTION_HPP
+#define MSGPACK_V1_UNPACK_EXCEPTION_HPP
+
+#include "msgpack/versioning.hpp"
+
+#include <string>
+#include <stdexcept>
+
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+struct unpack_error : public std::runtime_error {
+    explicit unpack_error(const std::string& msg)
+        :std::runtime_error(msg) {}
+#if !defined(MSGPACK_USE_CPP03)
+    explicit unpack_error(const char* msg):
+        std::runtime_error(msg) {}
+#endif // !defined(MSGPACK_USE_CPP03)
+};
+
+struct parse_error : public unpack_error {
+    explicit parse_error(const std::string& msg)
+        :unpack_error(msg) {}
+#if !defined(MSGPACK_USE_CPP03)
+    explicit parse_error(const char* msg)
+        :unpack_error(msg) {}
+#endif // !defined(MSGPACK_USE_CPP03)
+};
+
+struct insufficient_bytes : public unpack_error {
+    explicit insufficient_bytes(const std::string& msg)
+        :unpack_error(msg) {}
+#if !defined(MSGPACK_USE_CPP03)
+    explicit insufficient_bytes(const char* msg)
+        :unpack_error(msg) {}
+#endif // !defined(MSGPACK_USE_CPP03)
+};
+
+struct size_overflow : public unpack_error {
+    explicit size_overflow(const std::string& msg)
+        :unpack_error(msg) {}
+#if !defined(MSGPACK_USE_CPP03)
+    explicit size_overflow(const char* msg)
+        :unpack_error(msg) {}
+#endif
+};
+
+struct array_size_overflow : public size_overflow {
+    array_size_overflow(const std::string& msg)
+        :size_overflow(msg) {}
+#if !defined(MSGPACK_USE_CPP03)
+    array_size_overflow(const char* msg)
+        :size_overflow(msg) {}
+#endif
+};
+
+struct map_size_overflow : public size_overflow {
+    map_size_overflow(const std::string& msg)
+        :size_overflow(msg) {}
+#if !defined(MSGPACK_USE_CPP03)
+    map_size_overflow(const char* msg)
+        :size_overflow(msg) {}
+#endif
+};
+
+struct str_size_overflow : public size_overflow {
+    str_size_overflow(const std::string& msg)
+        :size_overflow(msg) {}
+#if !defined(MSGPACK_USE_CPP03)
+    str_size_overflow(const char* msg)
+        :size_overflow(msg) {}
+#endif
+};
+
+struct bin_size_overflow : public size_overflow {
+    bin_size_overflow(const std::string& msg)
+        :size_overflow(msg) {}
+#if !defined(MSGPACK_USE_CPP03)
+    bin_size_overflow(const char* msg)
+        :size_overflow(msg) {}
+#endif
+};
+
+struct ext_size_overflow : public size_overflow {
+    ext_size_overflow(const std::string& msg)
+        :size_overflow(msg) {}
+#if !defined(MSGPACK_USE_CPP03)
+    ext_size_overflow(const char* msg)
+        :size_overflow(msg) {}
+#endif
+};
+
+struct depth_size_overflow : public size_overflow {
+    depth_size_overflow(const std::string& msg)
+        :size_overflow(msg) {}
+#if !defined(MSGPACK_USE_CPP03)
+    depth_size_overflow(const char* msg)
+        :size_overflow(msg) {}
+#endif
+};
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+}  // namespace msgpack
+
+
+#endif // MSGPACK_V1_UNPACK_EXCEPTION_HPP

include/msgpack/v2/create_object_visitor.hpp

@@ -0,0 +1,243 @@
+//
+// MessagePack for C++ deserializing routine
+//
+// Copyright (C) 2017 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_V2_CREATE_OBJECT_VISITOR_HPP
+#define MSGPACK_V2_CREATE_OBJECT_VISITOR_HPP
+
+#include "msgpack/unpack_decl.hpp"
+#include "msgpack/unpack_exception.hpp"
+#include "msgpack/v2/null_visitor.hpp"
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v2) {
+/// @endcond
+
+namespace detail {
+
+class create_object_visitor : public msgpack::v2::null_visitor {
+public:
+    create_object_visitor(unpack_reference_func f, void* user_data, unpack_limit const& limit)
+        :m_func(f), m_user_data(user_data), m_limit(limit) {
+        m_stack.reserve(MSGPACK_EMBED_STACK_SIZE);
+        m_stack.push_back(&m_obj);
+    }
+
+#if !defined(MSGPACK_USE_CPP03)
+    create_object_visitor(create_object_visitor&& other)
+        :m_func(other.m_func),
+         m_user_data(other.m_user_data),
+         m_limit(std::move(other.m_limit)),
+         m_stack(std::move(other.m_stack)),
+         m_zone(other.m_zone),
+         m_referenced(other.m_referenced) {
+        other.m_zone = MSGPACK_NULLPTR;
+        m_stack[0] = &m_obj;
+    }
+    create_object_visitor& operator=(create_object_visitor&& other) {
+        this->~create_object_visitor();
+        new (this) create_object_visitor(std::move(other));
+        return *this;
+    }
+#endif // !defined(MSGPACK_USE_CPP03)
+
+    void init() {
+        m_stack.resize(1);
+        m_obj = msgpack::object();
+        m_stack[0] = &m_obj;
+    }
+    msgpack::object const& data() const
+    {
+        return m_obj;
+    }
+    msgpack::zone const& zone() const { return *m_zone; }
+    msgpack::zone& zone() { return *m_zone; }
+    void set_zone(msgpack::zone& zone) { m_zone = &zone; }
+    bool referenced() const { return m_referenced; }
+    void set_referenced(bool referenced) { m_referenced = referenced; }
+    // visit functions
+    bool visit_nil() {
+        msgpack::object* obj = m_stack.back();
+        obj->type = msgpack::type::NIL;
+        return true;
+    }
+    bool visit_boolean(bool v) {
+        msgpack::object* obj = m_stack.back();
+        obj->type = msgpack::type::BOOLEAN;
+        obj->via.boolean = v;
+        return true;
+    }
+    bool visit_positive_integer(uint64_t v) {
+        msgpack::object* obj = m_stack.back();
+        obj->type = msgpack::type::POSITIVE_INTEGER;
+        obj->via.u64 = v;
+        return true;
+    }
+    bool visit_negative_integer(int64_t v) {
+        msgpack::object* obj = m_stack.back();
+        if(v >= 0) {
+            obj->type = msgpack::type::POSITIVE_INTEGER;
+            obj->via.u64 = v;
+        }
+        else {
+            obj->type = msgpack::type::NEGATIVE_INTEGER;
+            obj->via.i64 = v;
+        }
+        return true;
+    }
+    bool visit_float(double v) {
+        msgpack::object* obj = m_stack.back();
+        obj->type = msgpack::type::FLOAT;
+        obj->via.f64 = v;
+        return true;
+    }
+    bool visit_str(const char* v, uint32_t size) {
+        if (size > m_limit.str()) throw msgpack::str_size_overflow("str size overflow");
+        msgpack::object* obj = m_stack.back();
+        obj->type = msgpack::type::STR;
+        if (m_func && m_func(obj->type, size, m_user_data)) {
+            obj->via.str.ptr = v;
+            set_referenced(true);
+        }
+        else {
+            char* tmp = static_cast<char*>(zone().allocate_align(size));
+            std::memcpy(tmp, v, size);
+            obj->via.str.ptr = tmp;
+        }
+        obj->via.str.size = size;
+        return true;
+    }
+    bool visit_bin(const char* v, uint32_t size) {
+        if (size > m_limit.bin()) throw msgpack::bin_size_overflow("bin size overflow");
+        msgpack::object* obj = m_stack.back();
+        obj->type = msgpack::type::BIN;
+        if (m_func && m_func(obj->type, size, m_user_data)) {
+            obj->via.bin.ptr = v;
+            set_referenced(true);
+        }
+        else {
+            char* tmp = static_cast<char*>(zone().allocate_align(size));
+            std::memcpy(tmp, v, size);
+            obj->via.bin.ptr = tmp;
+        }
+        obj->via.bin.size = size;
+        return true;
+    }
+    bool visit_ext(const char* v, uint32_t size) {
+        if (size > m_limit.ext()) throw msgpack::ext_size_overflow("ext size overflow");
+        msgpack::object* obj = m_stack.back();
+        obj->type = msgpack::type::EXT;
+        if (m_func && m_func(obj->type, size, m_user_data)) {
+            obj->via.ext.ptr = v;
+            set_referenced(true);
+        }
+        else {
+            char* tmp = static_cast<char*>(zone().allocate_align(size));
+            std::memcpy(tmp, v, size);
+            obj->via.ext.ptr = tmp;
+        }
+        obj->via.ext.size = static_cast<uint32_t>(size - 1);
+        return true;
+    }
+    bool start_array(uint32_t num_elements) {
+        if (num_elements > m_limit.array()) throw msgpack::array_size_overflow("array size overflow");
+        if (m_stack.size() > m_limit.depth()) throw msgpack::depth_size_overflow("depth size overflow");
+        msgpack::object* obj = m_stack.back();
+        obj->type = msgpack::type::ARRAY;
+        obj->via.array.size = num_elements;
+        if (num_elements == 0) {
+            obj->via.array.ptr = MSGPACK_NULLPTR;
+        }
+        else {
+            size_t size = num_elements*sizeof(msgpack::object);
+            if (size / sizeof(msgpack::object) != num_elements) {
+                throw msgpack::array_size_overflow("array size overflow");
+            }
+            obj->via.array.ptr =
+                static_cast<msgpack::object*>(m_zone->allocate_align(size));
+        }
+        m_stack.push_back(obj->via.array.ptr);
+        return true;
+    }
+    bool start_array_item() {
+        return true;
+    }
+    bool end_array_item() {
+        ++m_stack.back();
+        return true;
+    }
+    bool end_array() {
+        m_stack.pop_back();
+        return true;
+    }
+    bool start_map(uint32_t num_kv_pairs) {
+        if (num_kv_pairs > m_limit.map()) throw msgpack::map_size_overflow("map size overflow");
+        if (m_stack.size() > m_limit.depth()) throw msgpack::depth_size_overflow("depth size overflow");
+        msgpack::object* obj = m_stack.back();
+        obj->type = msgpack::type::MAP;
+        obj->via.map.size = num_kv_pairs;
+        if (num_kv_pairs == 0) {
+            obj->via.map.ptr = MSGPACK_NULLPTR;
+        }
+        else {
+            size_t size = num_kv_pairs*sizeof(msgpack::object_kv);
+            if (size / sizeof(msgpack::object_kv) != num_kv_pairs) {
+                throw msgpack::map_size_overflow("map size overflow");
+            }
+            obj->via.map.ptr =
+                static_cast<msgpack::object_kv*>(m_zone->allocate_align(size));
+        }
+        m_stack.push_back(reinterpret_cast<msgpack::object*>(obj->via.map.ptr));
+        return true;
+    }
+    bool start_map_key() {
+        return true;
+    }
+    bool end_map_key() {
+        ++m_stack.back();
+        return true;
+    }
+    bool start_map_value() {
+        return true;
+    }
+    bool end_map_value() {
+        ++m_stack.back();
+        return true;
+    }
+    bool end_map() {
+        m_stack.pop_back();
+        return true;
+    }
+    void parse_error(size_t /*parsed_offset*/, size_t /*error_offset*/) {
+        throw msgpack::parse_error("parse error");
+    }
+    void insufficient_bytes(size_t /*parsed_offset*/, size_t /*error_offset*/) {
+        throw msgpack::insufficient_bytes("insufficient bytes");
+    }
+private:
+public:
+    unpack_reference_func m_func;
+    void* m_user_data;
+    unpack_limit m_limit;
+    msgpack::object m_obj;
+    std::vector<msgpack::object*> m_stack;
+    msgpack::zone* m_zone;
+    bool m_referenced;
+};
+
+} // detail
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v2)
+/// @endcond
+
+}  // namespace msgpack
+
+#endif // MSGPACK_V2_CREATE_OBJECT_VISITOR_HPP

include/msgpack/v2/meta_decl.hpp

@@ -27,10 +27,14 @@ using v1::detail::bool_pack;
 
 using v1::detail::all_of_imp;
 
+using v1::detail::any_of_imp;
+
 } // namespace detail
 
 using v1::all_of;
 
+using v1::any_of;
+
 using v1::seq;
 
 using v1::gen_seq;

include/msgpack/v2/null_visitor.hpp

@@ -0,0 +1,94 @@
+//
+// MessagePack for C++ deserializing routine
+//
+// Copyright (C) 2017 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_V2_NULL_VISITOR_HPP
+#define MSGPACK_V2_NULL_VISITOR_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/cpp_config.hpp"
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v2) {
+/// @endcond
+
+struct null_visitor {
+    bool visit_nil() {
+        return true;
+    }
+    bool visit_boolean(bool /*v*/) {
+        return true;
+    }
+    bool visit_positive_integer(uint64_t /*v*/) {
+        return true;
+    }
+    bool visit_negative_integer(int64_t /*v*/) {
+        return true;
+    }
+    bool visit_float(double /*v*/) {
+        return true;
+    }
+    bool visit_str(const char* /*v*/, uint32_t /*size*/) {
+        return true;
+    }
+    bool visit_bin(const char* /*v*/, uint32_t /*size*/) {
+        return true;
+    }
+    bool visit_ext(const char* /*v*/, uint32_t /*size*/) {
+        return true;
+    }
+    bool start_array(uint32_t /*num_elements*/) {
+        return true;
+    }
+    bool start_array_item() {
+        return true;
+    }
+    bool end_array_item() {
+        return true;
+    }
+    bool end_array() {
+        return true;
+    }
+    bool start_map(uint32_t /*num_kv_pairs*/) {
+        return true;
+    }
+    bool start_map_key() {
+        return true;
+    }
+    bool end_map_key() {
+        return true;
+    }
+    bool start_map_value() {
+        return true;
+    }
+    bool end_map_value() {
+        return true;
+    }
+    bool end_map() {
+        return true;
+    }
+    void parse_error(size_t /*parsed_offset*/, size_t /*error_offset*/) {
+    }
+    void insufficient_bytes(size_t /*parsed_offset*/, size_t /*error_offset*/) {
+    }
+    bool referenced() const {
+        return false;
+    }
+    void set_referenced(bool /*referenced*/) {
+    }
+};
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v2)
+/// @endcond
+
+}  // namespace msgpack
+
+#endif // MSGPACK_V2_NULL_VISITOR_HPP

include/msgpack/v2/object_fwd_decl.hpp

@@ -25,6 +25,8 @@ using v1::type::NIL;
 using v1::type::BOOLEAN;
 using v1::type::POSITIVE_INTEGER;
 using v1::type::NEGATIVE_INTEGER;
+using v1::type::FLOAT32;
+using v1::type::FLOAT64;
 using v1::type::FLOAT;
 #if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
 using v1::type::DOUBLE;

include/msgpack/v2/parse_return.hpp

@@ -0,0 +1,37 @@
+//
+// MessagePack for C++ deserializing routine
+//
+// Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_V2_PARSE_RETURN_HPP
+#define MSGPACK_V2_PARSE_RETURN_HPP
+
+#include "msgpack/v1/parse_return.hpp"
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v2) {
+/// @endcond
+
+
+// for internal use
+typedef enum {
+    PARSE_SUCCESS              = v1::PARSE_SUCCESS,
+    PARSE_EXTRA_BYTES          = v1::PARSE_EXTRA_BYTES,
+    PARSE_CONTINUE             = v1::PARSE_CONTINUE,
+    PARSE_PARSE_ERROR          = v1::PARSE_PARSE_ERROR,
+    PARSE_STOP_VISITOR         = -2
+} parse_return;
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v2)
+/// @endcond
+
+}  // namespace msgpack
+
+#endif // MSGPACK_V2_PARSE_RETURN_HPP

include/msgpack/v2/unpack_decl.hpp

@@ -87,14 +87,6 @@ class unpacker;
 template <typename unpack_visitor, typename referenced_buffer_hook>
 class basic_unpacker;
 
-typedef enum unpack_return {
-    UNPACK_SUCCESS      = v1::UNPACK_SUCCESS,
-    UNPACK_EXTRA_BYTES  = v1::UNPACK_EXTRA_BYTES,
-    UNPACK_CONTINUE     = v1::UNPACK_CONTINUE,
-    UNPACK_PARSE_ERROR  = v1::UNPACK_PARSE_ERROR,
-    UNPACK_STOP_VISITOR = -2
-} unpack_return;
-
 /// Unpack msgpack::object from a buffer.
 /**
  * @param data The pointer to the buffer.
@@ -327,14 +319,14 @@ bool parse(const char* data, size_t len, Visitor& v);
 
 namespace detail {
 
-unpack_return
+parse_return
 unpack_imp(const char* data, std::size_t len, std::size_t& off,
            msgpack::zone& result_zone, msgpack::object& result, bool& referenced,
            unpack_reference_func f, void* user_data,
            unpack_limit const& limit);
 
 template <typename UnpackVisitor>
-unpack_return
+parse_return
 parse_imp(const char* data, size_t len, size_t& off, UnpackVisitor& v);
 
 } // detail

include/msgpack/v2/x3_parse.hpp

@@ -0,0 +1,874 @@
+//
+// MessagePack for C++ deserializing routine
+//
+// Copyright (C) 2017 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_V2_X3_PARSE_HPP
+#define MSGPACK_V2_X3_PARSE_HPP
+
+#if defined(MSGPACK_USE_X3_PARSE)
+
+#include <boost/version.hpp>
+
+#if BOOST_VERSION >= 106100
+
+#include "msgpack/versioning.hpp"
+
+#if __GNUC__ >= 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif // __GNUC__ >= 4
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/home/x3.hpp>
+#include <boost/spirit/home/x3/binary.hpp>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v2) {
+/// @endcond
+
+namespace detail {
+
+namespace x3 = boost::spirit::x3;
+
+using x3::byte_;
+
+// byte range utility
+const auto byte_range = [](const std::uint8_t from, const std::uint8_t to) {
+    const auto check = [from, to](auto& ctx)
+    {
+        const std::uint8_t value = x3::_attr(ctx);
+        x3::_val(ctx) = value;
+        x3::_pass(ctx) = from <= value && value <= to;
+    };
+    return x3::byte_ [check];
+};
+
+// MessagePack rule
+const auto mp_positive_fixint = byte_range(0x00, 0x7f);
+const auto mp_fixmap          = byte_range(0x80, 0x8f);
+const auto mp_fixarray        = byte_range(0x90, 0x9f);
+const auto mp_fixstr          = byte_range(0xa0, 0xbf);
+const auto mp_nil             = x3::byte_(0xc0);
+const auto mp_false           = x3::byte_(0xc2);
+const auto mp_true            = x3::byte_(0xc3);
+const auto mp_bin8            = x3::byte_(0xc4);
+const auto mp_bin16           = x3::byte_(0xc5);
+const auto mp_bin32           = x3::byte_(0xc6);
+const auto mp_ext8            = x3::byte_(0xc7);
+const auto mp_ext16           = x3::byte_(0xc8);
+const auto mp_ext32           = x3::byte_(0xc9);
+const auto mp_float32         = x3::byte_(0xca);
+const auto mp_float64         = x3::byte_(0xcb);
+const auto mp_uint8           = x3::byte_(0xcc);
+const auto mp_uint16          = x3::byte_(0xcd);
+const auto mp_uint32          = x3::byte_(0xce);
+const auto mp_uint64          = x3::byte_(0xcf);
+const auto mp_int8            = x3::byte_(0xd0);
+const auto mp_int16           = x3::byte_(0xd1);
+const auto mp_int32           = x3::byte_(0xd2);
+const auto mp_int64           = x3::byte_(0xd3);
+const auto mp_fixext1         = x3::byte_(0xd4);
+const auto mp_fixext2         = x3::byte_(0xd5);
+const auto mp_fixext4         = x3::byte_(0xd6);
+const auto mp_fixext8         = x3::byte_(0xd7);
+const auto mp_fixext16        = x3::byte_(0xd8);
+const auto mp_str8            = x3::byte_(0xd9);
+const auto mp_str16           = x3::byte_(0xda);
+const auto mp_str32           = x3::byte_(0xdb);
+const auto mp_array16         = x3::byte_(0xdc);
+const auto mp_array32         = x3::byte_(0xdd);
+const auto mp_map16           = x3::byte_(0xde);
+const auto mp_map32           = x3::byte_(0xdf);
+const auto mp_negative_fixint = byte_range(0xe0, 0xff);
+
+const auto mp_d_uint8 = x3::byte_;
+const auto mp_d_uint16 = x3::big_word;
+const auto mp_d_uint32 = x3::big_dword;
+const auto mp_d_uint64 = x3::big_qword;
+
+const auto mp_d_int8 = x3::byte_;
+const auto mp_d_int16 = x3::big_word;
+const auto mp_d_int32 = x3::big_dword;
+const auto mp_d_int64 = x3::big_qword;
+
+x3::rule<class mp_object> const mp_object("mp_object");
+x3::rule<class array_items> const array_item("array_item");
+x3::rule<class map_items> const map_item("map_item");
+x3::rule<class kv> const kv("kv");
+
+struct tag_app_specific {};
+struct index_size {
+    enum struct type_t {
+        array,
+        map,
+        other
+    };
+    index_size(std::size_t size, type_t type = type_t::other):size(size), type(type) {}
+    std::size_t index = 0;
+    std::size_t size;
+    type_t type;
+};
+
+template <typename Visitor>
+struct app_specific {
+    template <typename Vis>
+    app_specific(Vis&& vis):vis(vis) {}
+    std::vector<index_size> index_sizes;
+    Visitor vis;
+};
+
+template <typename Visitor>
+app_specific<Visitor> make_app_specific(Visitor&& vis) {
+    return app_specific<Visitor>(std::forward<Visitor>(vis));
+}
+
+const auto more   = [](auto &ctx) {
+    auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+    _pass(ctx) = app_specific.index_sizes.back().index++ < app_specific.index_sizes.back().size;
+};
+
+const auto done   = [](auto &ctx) {
+    auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+    if (app_specific.index_sizes.back().index == app_specific.index_sizes.back().size + 1) {
+        _pass(ctx) = true;
+        switch (app_specific.index_sizes.back().type) {
+        case index_size::type_t::array:
+            app_specific.vis.end_array();
+            break;
+        case index_size::type_t::map:
+            app_specific.vis.end_map();
+            break;
+        case index_size::type_t::other:
+            break;
+        }
+        app_specific.index_sizes.pop_back();
+    }
+    else {
+        _pass(ctx) = false;
+    }
+};
+
+const auto mp_object_def =
+    // -----------------------------------------------
+    mp_nil [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                app_specific.vis.visit_nil();
+            }
+        )
+    ]
+    |
+    // -----------------------------------------------
+    mp_true [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                app_specific.vis.visit_boolean(true);
+            }
+        )
+    ]
+    |
+    // -----------------------------------------------
+    mp_false [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                app_specific.vis.visit_boolean(false);
+            }
+        )
+    ]
+    |
+    // -----------------------------------------------
+    mp_positive_fixint [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                app_specific.vis.visit_positive_integer(_attr(ctx));
+            }
+        )
+    ]
+    |
+    // -----------------------------------------------
+    mp_negative_fixint [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                std::int8_t val = _attr(ctx);
+                app_specific.vis.visit_negative_integer(val);
+            }
+        )
+    ]
+    |
+    // -----------------------------------------------
+    mp_uint8 >> mp_d_uint8 [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                app_specific.vis.visit_negative_integer(_attr(ctx));
+            }
+        )
+    ]
+    |
+    // -----------------------------------------------
+    mp_uint16 >> mp_d_uint16 [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                app_specific.vis.visit_positive_integer(_attr(ctx));
+            }
+        )
+    ]
+    |
+    // -----------------------------------------------
+    mp_uint32 >> mp_d_uint32 [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                app_specific.vis.visit_positive_integer(_attr(ctx));
+            }
+        )
+    ]
+    |
+    // -----------------------------------------------
+    mp_uint64 >> mp_d_uint64 [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                app_specific.vis.visit_positive_integer(_attr(ctx));
+            }
+        )
+    ]
+    |
+    // -----------------------------------------------
+    mp_int8 >> mp_d_int8 [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                std::int8_t val = _attr(ctx);
+                app_specific.vis.visit_negative_integer(val);
+            }
+        )
+    ]
+    |
+    // -----------------------------------------------
+    mp_int16 >> mp_d_int16 [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                std::int16_t val = _attr(ctx);
+                app_specific.vis.visit_negative_integer(val);
+            }
+        )
+    ]
+    |
+    // -----------------------------------------------
+    mp_int32 >> mp_d_int32 [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                std::int32_t val = _attr(ctx);
+                app_specific.vis.visit_negative_integer(val);
+            }
+        )
+    ]
+    |
+    // -----------------------------------------------
+    mp_int64 >> mp_d_int64 [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                std::int64_t val = _attr(ctx);
+                app_specific.vis.visit_negative_integer(val);
+            }
+        )
+    ]
+    |
+    // -----------------------------------------------
+    mp_float32 >> mp_d_uint32 [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                union { uint32_t i; float f; } mem;
+                mem.i = _attr(ctx);
+                app_specific.vis.visit_float(mem.f);
+            }
+        )
+    ]
+    |
+    // -----------------------------------------------
+    mp_float64 >> mp_d_uint64 [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                union { uint64_t i; double f; } mem;
+                mem.i = _attr(ctx);
+#if defined(TARGET_OS_IPHONE)
+                // ok
+#elif defined(__arm__) && !(__ARM_EABI__) // arm-oabi
+                // https://github.com/msgpack/msgpack-perl/pull/1
+                mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL);
+#endif
+                app_specific.vis.visit_float(mem.f);
+            }
+        )
+    ]
+    |
+    // -----------------------------------------------
+    mp_fixstr [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                std::size_t size = _attr(ctx) & 0b00011111;
+                app_specific.index_sizes.emplace_back(size);
+            }
+        )
+    ]
+    >>
+    x3::raw [
+        *(x3::eps [more] >> x3::char_)
+        >> x3::eps [done]
+    ][
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                auto const& str = _attr(ctx);
+                std::size_t size = std::distance(str.begin(), str.end());
+                app_specific.vis.visit_str(size ? &str.front() : nullptr, size);
+            }
+        )
+    ]
+    |
+    // -----------------------------------------------
+    mp_str8 >> mp_d_uint8 [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                app_specific.index_sizes.emplace_back(_attr(ctx));
+            }
+        )
+    ]
+    >>
+    x3::raw [
+        *(x3::eps [more] >> x3::char_)
+        >> x3::eps [done]
+    ][
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                auto const& str = _attr(ctx);
+                std::size_t size = std::distance(str.begin(), str.end());
+                app_specific.vis.visit_str(size ? &str.front() : nullptr, size);
+            }
+        )
+    ]
+    |
+    // -----------------------------------------------
+    mp_str16 >> mp_d_uint16 [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                app_specific.index_sizes.emplace_back(_attr(ctx));
+            }
+        )
+    ]
+    >>
+    x3::raw [
+        *(x3::eps [more] >> x3::char_)
+        >> x3::eps [done]
+    ][
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                auto const& str = _attr(ctx);
+                std::size_t size = std::distance(str.begin(), str.end());
+                app_specific.vis.visit_str(size ? &str.front() : nullptr, size);
+            }
+        )
+    ]
+    |
+    // -----------------------------------------------
+    mp_str32 >> mp_d_uint32 [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                app_specific.index_sizes.emplace_back(_attr(ctx));
+            }
+        )
+    ]
+    >>
+    x3::raw [
+        *(x3::eps [more] >> x3::char_)
+        >> x3::eps [done]
+    ][
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                auto const& str = _attr(ctx);
+                std::size_t size = std::distance(str.begin(), str.end());
+                app_specific.vis.visit_str(size ? &str.front() : nullptr, size);
+            }
+        )
+    ]
+    |
+    // -----------------------------------------------
+    mp_bin8 >> mp_d_uint8 [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                app_specific.index_sizes.emplace_back(_attr(ctx));
+            }
+        )
+    ]
+    >>
+    x3::raw [
+        *(x3::eps [more] >> x3::char_)
+        >> x3::eps [done]
+    ][
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                auto const& bin = _attr(ctx);
+                std::size_t size = std::distance(bin.begin(), bin.end());
+                app_specific.vis.visit_bin(size ? &bin.front() : nullptr, size);
+            }
+        )
+    ]
+    |
+    // -----------------------------------------------
+    mp_bin16 >> mp_d_uint16 [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                app_specific.index_sizes.emplace_back(_attr(ctx));
+            }
+        )
+    ]
+    >>
+    x3::raw [
+        *(x3::eps [more] >> x3::char_)
+        >> x3::eps [done]
+    ][
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                auto const& bin = _attr(ctx);
+                std::size_t size = std::distance(bin.begin(), bin.end());
+                app_specific.vis.visit_bin(size ? &bin.front() : nullptr, size);
+            }
+        )
+    ]
+    |
+    // -----------------------------------------------
+    mp_bin32 >> mp_d_uint32 [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                app_specific.index_sizes.emplace_back(_attr(ctx));
+            }
+        )
+    ]
+    >>
+    x3::raw [
+        *(x3::eps [more] >> x3::char_)
+        >> x3::eps [done]
+    ][
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                auto const& bin = _attr(ctx);
+                std::size_t size = std::distance(bin.begin(), bin.end());
+                app_specific.vis.visit_bin(size ? &bin.front() : nullptr, size);
+            }
+        )
+    ]
+    |
+    // -----------------------------------------------
+    mp_fixarray [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                std::size_t size = _attr(ctx) & 0b00001111;
+                app_specific.index_sizes.emplace_back(size, index_size::type_t::array);
+                app_specific.vis.start_array(size);
+            }
+        )
+    ]
+    >> *(x3::eps [more] >> array_item)
+    >> x3::eps [done]
+    |
+    // -----------------------------------------------
+    mp_array16 >> mp_d_uint16 [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                std::size_t size = _attr(ctx);
+                app_specific.index_sizes.emplace_back(size, index_size::type_t::array);
+                app_specific.vis.start_array(size);
+            }
+        )
+    ]
+    >> *(x3::eps [more] >> array_item)
+    >> x3::eps [done]
+    |
+    // -----------------------------------------------
+    mp_array32 >> mp_d_uint32 [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                std::size_t size = _attr(ctx);
+                app_specific.index_sizes.emplace_back(size, index_size::type_t::array);
+                app_specific.vis.start_array(size);
+            }
+        )
+    ]
+    >> *(x3::eps [more] >> array_item)
+    >> x3::eps [done]
+    |
+    // -----------------------------------------------
+    mp_fixmap [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                std::size_t size = _attr(ctx) & 0b00001111;
+                app_specific.index_sizes.emplace_back(size, index_size::type_t::map);
+                app_specific.vis.start_map(size);
+            }
+        )
+    ]
+    >> *(x3::eps [more] >> map_item)
+    >> x3::eps [done]
+    |
+    // -----------------------------------------------
+    mp_map16 >> mp_d_uint16 [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                std::size_t size = _attr(ctx);
+                app_specific.index_sizes.emplace_back(size, index_size::type_t::map);
+                app_specific.vis.start_map(size);
+            }
+        )
+    ]
+    >> *(x3::eps [more] >> map_item)
+    >> x3::eps [done]
+    |
+    // -----------------------------------------------
+    mp_map32 >> mp_d_uint32 [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                std::size_t size = _attr(ctx);
+                app_specific.index_sizes.emplace_back(size, index_size::type_t::map);
+                app_specific.vis.start_map(size);
+            }
+        )
+    ]
+    >> *(x3::eps [more] >> map_item)
+    >> x3::eps [done]
+    |
+    // -----------------------------------------------
+    mp_fixext1 [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                app_specific.index_sizes.emplace_back(1+1);
+            }
+        )
+    ]
+    >>
+    x3::raw [
+        *(x3::eps [more] >> x3::char_)
+        >> x3::eps [done]
+    ][
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                auto const& ext = _attr(ctx);
+                std::size_t size = std::distance(ext.begin(), ext.end());
+                app_specific.vis.visit_ext(size ? &ext.front() : nullptr, size);
+            }
+        )
+    ]
+    |
+    // -----------------------------------------------
+    mp_fixext2 [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                app_specific.index_sizes.emplace_back(2+1);
+            }
+        )
+    ]
+    >>
+    x3::raw [
+        *(x3::eps [more] >> x3::char_)
+        >> x3::eps [done]
+    ][
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                auto const& ext = _attr(ctx);
+                std::size_t size = std::distance(ext.begin(), ext.end());
+                app_specific.vis.visit_ext(size ? &ext.front() : nullptr, size);
+            }
+        )
+    ]
+    |
+    // -----------------------------------------------
+    mp_fixext4 [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                app_specific.index_sizes.emplace_back(4+1);
+            }
+        )
+    ]
+    >>
+    x3::raw [
+        *(x3::eps [more] >> x3::char_)
+        >> x3::eps [done]
+    ][
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                auto const& ext = _attr(ctx);
+                std::size_t size = std::distance(ext.begin(), ext.end());
+                app_specific.vis.visit_ext(size ? &ext.front() : nullptr, size);
+            }
+        )
+    ]
+    |
+    // -----------------------------------------------
+    mp_fixext8 [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                app_specific.index_sizes.emplace_back(8+1);
+            }
+        )
+    ]
+    >>
+    x3::raw [
+        *(x3::eps [more] >> x3::char_)
+        >> x3::eps [done]
+    ][
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                auto const& ext = _attr(ctx);
+                std::size_t size = std::distance(ext.begin(), ext.end());
+                app_specific.vis.visit_ext(size ? &ext.front() : nullptr, size);
+            }
+        )
+    ]
+    |
+    // -----------------------------------------------
+    mp_fixext16 [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                app_specific.index_sizes.emplace_back(16+1);
+            }
+        )
+    ]
+    >>
+    x3::raw [
+        *(x3::eps [more] >> x3::char_)
+        >> x3::eps [done]
+    ][
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                auto const& ext = _attr(ctx);
+                std::size_t size = std::distance(ext.begin(), ext.end());
+                app_specific.vis.visit_ext(size ? &ext.front() : nullptr, size);
+            }
+        )
+    ]
+    |
+    // -----------------------------------------------
+    mp_ext8 >> mp_d_uint8 [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                app_specific.index_sizes.emplace_back(_attr(ctx)+1);
+            }
+        )
+    ]
+    >>
+    x3::raw [
+        *(x3::eps [more] >> x3::char_)
+        >> x3::eps [done]
+    ][
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                auto const& ext = _attr(ctx);
+                std::size_t size = std::distance(ext.begin(), ext.end());
+                app_specific.vis.visit_ext(size ? &ext.front() : nullptr, size);
+            }
+        )
+    ]
+    |
+    // -----------------------------------------------
+    mp_ext16 >> mp_d_uint16 [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                app_specific.index_sizes.emplace_back(_attr(ctx)+1);
+            }
+        )
+    ]
+    >>
+    x3::raw [
+        *(x3::eps [more] >> x3::char_)
+        >> x3::eps [done]
+    ][
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                auto const& ext = _attr(ctx);
+                std::size_t size = std::distance(ext.begin(), ext.end());
+                app_specific.vis.visit_ext(size ? &ext.front() : nullptr, size);
+            }
+        )
+    ]
+    |
+    // -----------------------------------------------
+    mp_ext32 >> mp_d_uint32 [
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                app_specific.index_sizes.emplace_back(_attr(ctx)+1);
+            }
+        )
+    ]
+    >>
+    x3::raw [
+        *(x3::eps [more] >> x3::char_)
+        >> x3::eps [done]
+    ][
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                auto const& ext = _attr(ctx);
+                std::size_t size = std::distance(ext.begin(), ext.end());
+                app_specific.vis.visit_ext(size ? &ext.front() : nullptr, size);
+            }
+        )
+    ];
+
+const auto array_item_def =
+    x3::eps[
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                app_specific.vis.start_array_item();
+                _pass(ctx) = true;
+            }
+        )
+    ]
+    >>
+    mp_object
+    >>
+    x3::eps[
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                app_specific.vis.end_array_item();
+                _pass(ctx) = true;
+            }
+        )
+    ];
+
+const auto map_item_def = kv;
+const auto kv_def =
+    x3::eps[
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                app_specific.vis.start_map_key();
+                _pass(ctx) = true;
+            }
+        )
+    ]
+    >>
+    mp_object
+    >>
+    x3::eps[
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                app_specific.vis.end_map_key();
+                _pass(ctx) = true;
+            }
+        )
+    ]
+    >>
+    x3::eps[
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                app_specific.vis.start_map_value();
+                _pass(ctx) = true;
+            }
+        )
+    ]
+    >>
+    mp_object
+    >>
+    x3::eps[
+        (
+            [](auto& ctx){
+                auto& app_specific = x3::get<tag_app_specific>(ctx).get();
+                app_specific.vis.end_map_value();
+                _pass(ctx) = true;
+            }
+        )
+    ];
+
+BOOST_SPIRIT_DEFINE(
+    mp_object, array_item, map_item, kv
+);
+
+const auto rule = mp_object;
+
+} // namespace detail
+
+template <typename Iterator, typename Visitor>
+inline bool parse(Iterator&& begin, Iterator&& end, Visitor&& vis) {
+    auto data = detail::make_app_specific(std::forward<Visitor>(vis));
+    return detail::x3::parse(
+        std::forward<Iterator>(begin),
+        std::forward<Iterator>(end),
+        detail::x3::with<detail::tag_app_specific>(std::ref(data))[detail::rule]
+    );
+}
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v2)
+/// @endcond
+
+}  // namespace msgpack
+
+#if __GNUC__ >= 4
+#pragma GCC diagnostic pop
+#endif // __GNUC__ >= 4
+
+#else  // BOOST_VERSION >= 106100
+
+#error Boost 1.61.0 or later is required to use x3 parse
+
+#endif // BOOST_VERSION >= 106100
+
+#endif // defined(MSGPACK_USE_X3_PARSE)
+
+#endif // MSGPACK_V2_X3_PARSE_HPP

include/msgpack/v2/x3_unpack.hpp

@@ -0,0 +1,119 @@
+//
+// MessagePack for C++ deserializing routine
+//
+// Copyright (C) 2017 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_V2_X3_UNPACK_HPP
+#define MSGPACK_V2_X3_UNPACK_HPP
+
+#if defined(MSGPACK_USE_X3_PARSE)
+
+#include <boost/version.hpp>
+
+#if BOOST_VERSION >= 106100
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/v2/create_object_visitor.hpp"
+#include "msgpack/v2/x3_parse.hpp"
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v2) {
+/// @endcond
+
+namespace detail {
+
+template <typename Iterator>
+inline void
+unpack_imp(Iterator&& begin, Iterator&& end,
+           msgpack::zone& result_zone, msgpack::object& result, bool& referenced,
+           unpack_reference_func f = MSGPACK_NULLPTR, void* user_data = MSGPACK_NULLPTR,
+           unpack_limit const& limit = unpack_limit())
+{
+    create_object_visitor v(f, user_data, limit);
+    v.set_zone(result_zone);
+    referenced = false;
+    v.set_referenced(referenced);
+    if (!parse(std::forward<Iterator>(begin), std::forward<Iterator>(end), v)) {
+        throw msgpack::parse_error("parse error");
+    }
+    referenced = v.referenced();
+    result = v.data();
+}
+
+} // namespace detail
+
+
+template <typename Iterator>
+inline msgpack::object_handle unpack(
+    Iterator&& begin, Iterator&& end,
+    bool& referenced,
+    unpack_reference_func f = MSGPACK_NULLPTR, void* user_data = MSGPACK_NULLPTR,
+    unpack_limit const& limit = unpack_limit())
+{
+    msgpack::object obj;
+    msgpack::unique_ptr<msgpack::zone> z(new msgpack::zone);
+    referenced = false;
+    detail::unpack_imp(
+        std::forward<Iterator>(begin), std::forward<Iterator>(end), *z, obj, referenced, f, user_data, limit);
+    return msgpack::object_handle(obj, msgpack::move(z));
+}
+
+template <typename Iterator>
+inline msgpack::object_handle unpack(
+    Iterator&& begin, Iterator&& end,
+    unpack_reference_func f = MSGPACK_NULLPTR, void* user_data = MSGPACK_NULLPTR,
+    unpack_limit const& limit = unpack_limit())
+{
+    bool referenced;
+    return unpack(std::forward<Iterator>(begin), std::forward<Iterator>(end), referenced, f, user_data, limit);
+}
+
+template <typename Iterator>
+inline msgpack::object unpack(
+    msgpack::zone& z,
+    Iterator&& begin, Iterator&& end,
+    bool& referenced,
+    unpack_reference_func f = MSGPACK_NULLPTR, void* user_data = MSGPACK_NULLPTR,
+    unpack_limit const& limit = unpack_limit())
+{
+    msgpack::object obj;
+    referenced = false;
+    detail::unpack_imp(
+        std::forward<Iterator>(begin), std::forward<Iterator>(end), z, obj, referenced, f, user_data, limit);
+    return obj;
+}
+
+template <typename Iterator>
+inline msgpack::object unpack(
+    msgpack::zone& z,
+    Iterator&& begin, Iterator&& end,
+    unpack_reference_func f = MSGPACK_NULLPTR, void* user_data = MSGPACK_NULLPTR,
+    unpack_limit const& limit = unpack_limit())
+{
+    bool referenced;
+    return unpack(
+        z, std::forward<Iterator>(begin), std::forward<Iterator>(end), referenced, f, user_data, limit);
+}
+
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v2)
+/// @endcond
+
+}  // namespace msgpack
+
+#else  // BOOST_VERSION >= 106100
+
+#error Boost 1.61.0 or later is required to use x3 parse
+
+#endif // BOOST_VERSION >= 106100
+
+#endif // defined(MSGPACK_USE_X3_PARSE)
+
+#endif // MSGPACK_V2_X3_UNPACK_HPP

include/msgpack/version_master.h

@@ -1,3 +1,3 @@
 #define MSGPACK_VERSION_MAJOR    2
-#define MSGPACK_VERSION_MINOR    0
-#define MSGPACK_VERSION_REVISION 0
+#define MSGPACK_VERSION_MINOR    1
+#define MSGPACK_VERSION_REVISION 1

include/msgpack/versioning.hpp

@@ -36,12 +36,12 @@
 #if defined(_MSC_VER)
 
 #define MSGPACK_DETAIL_PP_MSVC_VA_ARGS_WORKAROUND(define, args) define args
-#define MSGPACK_DETAIL_PP_CHECK(...) MSGPACK_DETAIL_PP_MSVC_VA_ARGS_WORKAROUND(MSGPACK_DETAIL_PP_CHECK_N, (__VA_ARGS__, 0))
+#define MSGPACK_DETAIL_PP_CHECK(...) MSGPACK_DETAIL_PP_MSVC_VA_ARGS_WORKAROUND(MSGPACK_DETAIL_PP_CHECK_N, (__VA_ARGS__, 0, 0))
 #define MSGPACK_DETAIL_PP_CHECK_N(x, n, ...) n
 
 #else  // defined(__MSC_VER)
 
-#define MSGPACK_DETAIL_PP_CHECK(...) MSGPACK_DETAIL_PP_CHECK_N(__VA_ARGS__, 0)
+#define MSGPACK_DETAIL_PP_CHECK(...) MSGPACK_DETAIL_PP_CHECK_N(__VA_ARGS__, 0, 0)
 #define MSGPACK_DETAIL_PP_CHECK_N(x, n, ...) n
 
 #endif // defined(__MSC_VER)

make_file_list.sh

@@ -13,7 +13,7 @@ cat c_headers.tmp | sed -e 's/^/    /g' >> Files.cmake
 echo ')' >> Files.cmake
 
 echo 'IF (MSGPACK_ENABLE_CXX)' >> Files.cmake
-echo '    LIST (APPEND msgpack_HEADERS' >> Files.cmake
+echo '    LIST (APPEND msgpackc_HEADERS' >> Files.cmake
 cat cpp_headers.tmp | sed -e 's/^/        /g' >> Files.cmake
 echo '    )' >> Files.cmake
 echo 'ENDIF ()' >> Files.cmake

src/objectc.c

@@ -9,6 +9,7 @@
  */
 #include "msgpack/object.h"
 #include "msgpack/pack.h"
+#include <ctype.h>
 #include <stdio.h>
 #include <string.h>
 
@@ -17,9 +18,9 @@
 #include <inttypes.h>
 #else
 #define PRIu64 "I64u"
-#define PRIi64 "I64i"
-#define PRIi8 "i"
-#endif
+#define PRIi64 "I64i"
+#define PRIi8 "i"
+#endif
 #else
 #include <inttypes.h>
 #endif
@@ -44,7 +45,10 @@ int msgpack_pack_object(msgpack_packer* pk, msgpack_object d)
     case MSGPACK_OBJECT_NEGATIVE_INTEGER:
         return msgpack_pack_int64(pk, d.via.i64);
 
-    case MSGPACK_OBJECT_FLOAT:
+    case MSGPACK_OBJECT_FLOAT32:
+        return msgpack_pack_float(pk, (float)d.via.f64);
+
+    case MSGPACK_OBJECT_FLOAT64:
         return msgpack_pack_double(pk, d.via.f64);
 
     case MSGPACK_OBJECT_STR:
@@ -112,6 +116,49 @@ int msgpack_pack_object(msgpack_packer* pk, msgpack_object d)
 }
 
 
+static void msgpack_object_bin_print(FILE* out, const char *ptr, size_t size)
+{
+    size_t i;
+    for (i = 0; i < size; ++i) {
+        if (ptr[i] == '"') {
+            fputs("\\\"", out);
+        } else if (isprint((unsigned char)ptr[i])) {
+            fputc(ptr[i], out);
+        } else {
+            fprintf(out, "\\x%02x", (unsigned char)ptr[i]);
+        }
+    }
+}
+
+static int msgpack_object_bin_print_buffer(char *buffer, size_t buffer_size, const char *ptr, size_t size)
+{
+    size_t i;
+    char *aux_buffer = buffer;
+    size_t aux_buffer_size = buffer_size;
+    int ret;
+
+    for (i = 0; i < size; ++i) {
+        if (ptr[i] == '"') {
+            ret = snprintf(aux_buffer, aux_buffer_size, "\\\"");
+            aux_buffer = aux_buffer + ret;
+            aux_buffer_size = aux_buffer_size - ret;
+        } else if (isprint((unsigned char)ptr[i])) {
+            if (aux_buffer_size > 0) {
+                memcpy(aux_buffer, ptr + i, 1);
+                aux_buffer = aux_buffer + 1;
+                aux_buffer_size = aux_buffer_size - 1;
+            }
+        } else {
+            ret = snprintf(aux_buffer, aux_buffer_size, "\\x%02x", (unsigned char)ptr[i]);
+            aux_buffer = aux_buffer + ret;
+            aux_buffer_size = aux_buffer_size - ret;
+        }
+    }
+
+    return buffer_size - aux_buffer_size;
+}
+
+
 void msgpack_object_print(FILE* out, msgpack_object o)
 {
     switch(o.type) {
@@ -147,7 +194,8 @@ void msgpack_object_print(FILE* out, msgpack_object o)
 #endif
         break;
 
-    case MSGPACK_OBJECT_FLOAT:
+    case MSGPACK_OBJECT_FLOAT32:
+    case MSGPACK_OBJECT_FLOAT64:
         fprintf(out, "%f", o.via.f64);
         break;
 
@@ -159,7 +207,7 @@ void msgpack_object_print(FILE* out, msgpack_object o)
 
     case MSGPACK_OBJECT_BIN:
         fprintf(out, "\"");
-        fwrite(o.via.bin.ptr, o.via.bin.size, 1, out);
+        msgpack_object_bin_print(out, o.via.bin.ptr, o.via.bin.size);
         fprintf(out, "\"");
         break;
 
@@ -170,7 +218,7 @@ void msgpack_object_print(FILE* out, msgpack_object o)
         fprintf(out, "(ext: %d)", (int)o.via.ext.type);
 #endif
         fprintf(out, "\"");
-        fwrite(o.via.ext.ptr, o.via.ext.size, 1, out);
+        msgpack_object_bin_print(out, o.via.ext.ptr, o.via.ext.size);
         fprintf(out, "\"");
         break;
 
@@ -222,6 +270,205 @@ void msgpack_object_print(FILE* out, msgpack_object o)
     }
 }
 
+int msgpack_object_print_buffer(char *buffer, size_t buffer_size, msgpack_object o)
+{
+    char *aux_buffer = buffer;
+    size_t aux_buffer_size = buffer_size;
+    int ret;
+    switch(o.type) {
+    case MSGPACK_OBJECT_NIL:
+        ret = snprintf(aux_buffer, aux_buffer_size, "nil");
+        aux_buffer = aux_buffer + ret;
+        aux_buffer_size = aux_buffer_size - ret;
+        break;
+
+    case MSGPACK_OBJECT_BOOLEAN:
+        ret = snprintf(aux_buffer, aux_buffer_size, (o.via.boolean ? "true" : "false"));
+        aux_buffer = aux_buffer + ret;
+        aux_buffer_size = aux_buffer_size - ret;
+        break;
+
+    case MSGPACK_OBJECT_POSITIVE_INTEGER:
+#if defined(PRIu64)
+        ret = snprintf(aux_buffer, aux_buffer_size, "%" PRIu64, o.via.u64);
+        aux_buffer = aux_buffer + ret;
+        aux_buffer_size = aux_buffer_size - ret;
+#else
+        if (o.via.u64 > ULONG_MAX) {
+            ret = snprintf(aux_buffer, aux_buffer_size, "over 4294967295");
+            aux_buffer = aux_buffer + ret;
+            aux_buffer_size = aux_buffer_size - ret;
+        } else {
+            ret = snprintf(aux_buffer, aux_buffer_size, "%lu", (unsigned long)o.via.u64);
+            aux_buffer = aux_buffer + ret;
+            aux_buffer_size = aux_buffer_size - ret;
+        }
+#endif
+        break;
+
+    case MSGPACK_OBJECT_NEGATIVE_INTEGER:
+#if defined(PRIi64)
+        ret = snprintf(aux_buffer, aux_buffer_size, "%" PRIi64, o.via.i64);
+        aux_buffer = aux_buffer + ret;
+        aux_buffer_size = aux_buffer_size - ret;
+#else
+        if (o.via.i64 > LONG_MAX) {
+            ret = snprintf(aux_buffer, aux_buffer_size, "over +2147483647");
+            aux_buffer = aux_buffer + ret;
+            aux_buffer_size = aux_buffer_size - ret;
+        } else if (o.via.i64 < LONG_MIN) {
+            ret = snprintf(aux_buffer, aux_buffer_size, "under -2147483648");
+            aux_buffer = aux_buffer + ret;
+            aux_buffer_size = aux_buffer_size - ret;
+        } else {
+            ret = snprintf(aux_buffer, aux_buffer_size, "%ld", (signed long)o.via.i64);
+            aux_buffer = aux_buffer + ret;
+            aux_buffer_size = aux_buffer_size - ret;
+        }
+#endif
+        break;
+
+    case MSGPACK_OBJECT_FLOAT32:
+    case MSGPACK_OBJECT_FLOAT64:
+        ret = snprintf(aux_buffer, aux_buffer_size, "%f", o.via.f64);
+        aux_buffer = aux_buffer + ret;
+        aux_buffer_size = aux_buffer_size - ret;
+        break;
+
+    case MSGPACK_OBJECT_STR:
+        ret = snprintf(aux_buffer, aux_buffer_size, "\"");
+        aux_buffer = aux_buffer + ret;
+        aux_buffer_size = aux_buffer_size - ret;
+        ret = snprintf(aux_buffer, aux_buffer_size, "%.*s", o.via.str.size, o.via.str.ptr);
+        aux_buffer = aux_buffer + ret;
+        aux_buffer_size = aux_buffer_size - ret;
+        ret = snprintf(aux_buffer, aux_buffer_size, "\"");
+        aux_buffer = aux_buffer + ret;
+        aux_buffer_size = aux_buffer_size - ret;
+        break;
+
+    case MSGPACK_OBJECT_BIN:
+        ret = snprintf(aux_buffer, aux_buffer_size, "\"");
+        aux_buffer = aux_buffer + ret;
+        aux_buffer_size = aux_buffer_size - ret;
+
+        ret = msgpack_object_bin_print_buffer(aux_buffer, aux_buffer_size, o.via.bin.ptr, o.via.bin.size);
+        aux_buffer = aux_buffer + ret;
+        aux_buffer_size = aux_buffer_size - ret;
+
+        ret = snprintf(aux_buffer, aux_buffer_size, "\"");
+        aux_buffer = aux_buffer + ret;
+        aux_buffer_size = aux_buffer_size - ret;
+        break;
+
+    case MSGPACK_OBJECT_EXT:
+#if defined(PRIi8)
+        ret = snprintf(aux_buffer, aux_buffer_size, "(ext: %" PRIi8 ")", o.via.ext.type);
+        aux_buffer = aux_buffer + ret;
+        aux_buffer_size = aux_buffer_size - ret;
+#else
+        ret = snprintf(aux_buffer, aux_buffer_size, "(ext: %d)", (int)o.via.ext.type);
+        aux_buffer = aux_buffer + ret;
+        aux_buffer_size = aux_buffer_size - ret;
+#endif
+        ret = snprintf(aux_buffer, aux_buffer_size, "\"");
+        aux_buffer = aux_buffer + ret;
+        aux_buffer_size = aux_buffer_size - ret;
+
+        ret = msgpack_object_bin_print_buffer(aux_buffer, aux_buffer_size, o.via.ext.ptr, o.via.ext.size);
+        aux_buffer = aux_buffer + ret;
+        aux_buffer_size = aux_buffer_size - ret;
+
+        ret = snprintf(aux_buffer, aux_buffer_size, "\"");
+        aux_buffer = aux_buffer + ret;
+        aux_buffer_size = aux_buffer_size - ret;
+        break;
+
+    case MSGPACK_OBJECT_ARRAY:
+        ret = snprintf(aux_buffer, aux_buffer_size, "[");
+        aux_buffer = aux_buffer + ret;
+        aux_buffer_size = aux_buffer_size - ret;
+        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;
+            ret = msgpack_object_print_buffer(aux_buffer, aux_buffer_size, *p);
+            aux_buffer = aux_buffer + ret;
+            aux_buffer_size = aux_buffer_size - ret;
+            ++p;
+            for(; p < pend; ++p) {
+                ret = snprintf(aux_buffer, aux_buffer_size, ", ");
+                aux_buffer = aux_buffer + ret;
+                aux_buffer_size = aux_buffer_size - ret;
+                ret = msgpack_object_print_buffer(aux_buffer, aux_buffer_size, *p);
+                aux_buffer = aux_buffer + ret;
+                aux_buffer_size = aux_buffer_size - ret;
+            }
+        }
+        ret = snprintf(aux_buffer, aux_buffer_size, "]");
+        aux_buffer = aux_buffer + ret;
+        aux_buffer_size = aux_buffer_size - ret;
+        break;
+
+    case MSGPACK_OBJECT_MAP:
+        ret = snprintf(aux_buffer, aux_buffer_size, "{");
+        aux_buffer = aux_buffer + ret;
+        aux_buffer_size = aux_buffer_size - ret;
+        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;
+            ret = msgpack_object_print_buffer(aux_buffer, aux_buffer_size, p->key);
+            aux_buffer = aux_buffer + ret;
+            aux_buffer_size = aux_buffer_size - ret;
+            ret = snprintf(aux_buffer, aux_buffer_size, "=>");
+            aux_buffer = aux_buffer + ret;
+            aux_buffer_size = aux_buffer_size - ret;
+            ret = msgpack_object_print_buffer(aux_buffer, aux_buffer_size, p->val);
+            aux_buffer = aux_buffer + ret;
+            aux_buffer_size = aux_buffer_size - ret;
+            ++p;
+            for(; p < pend; ++p) {
+                ret = snprintf(aux_buffer, aux_buffer_size, ", ");
+                aux_buffer = aux_buffer + ret;
+                aux_buffer_size = aux_buffer_size - ret;
+                ret = msgpack_object_print_buffer(aux_buffer, aux_buffer_size, p->key);
+                aux_buffer = aux_buffer + ret;
+                aux_buffer_size = aux_buffer_size - ret;
+                ret = snprintf(aux_buffer, aux_buffer_size, "=>");
+                aux_buffer = aux_buffer + ret;
+                aux_buffer_size = aux_buffer_size - ret;
+                ret = msgpack_object_print_buffer(aux_buffer, aux_buffer_size, p->val);
+                aux_buffer = aux_buffer + ret;
+                aux_buffer_size = aux_buffer_size - ret;
+            }
+        }
+        ret = snprintf(aux_buffer, aux_buffer_size, "}");
+        aux_buffer = aux_buffer + ret;
+        aux_buffer_size = aux_buffer_size - ret;
+        break;
+
+    default:
+    // FIXME
+#if defined(PRIu64)
+        ret = snprintf(aux_buffer, aux_buffer_size, "#<UNKNOWN %i %" PRIu64 ">", o.type, o.via.u64);
+        aux_buffer = aux_buffer + ret;
+        aux_buffer_size = aux_buffer_size - ret;
+#else
+        if (o.via.u64 > ULONG_MAX) {
+            ret = snprintf(aux_buffer, aux_buffer_size, "#<UNKNOWN %i over 4294967295>", o.type);
+            aux_buffer = aux_buffer + ret;
+            aux_buffer_size = aux_buffer_size - ret;
+        } else {
+            ret = snprintf(aux_buffer, aux_buffer_size, "#<UNKNOWN %i %lu>", o.type, (unsigned long)o.via.u64);
+            aux_buffer = aux_buffer + ret;
+            aux_buffer_size = aux_buffer_size - ret;
+        }
+#endif
+    }
+
+    return buffer_size - aux_buffer_size;
+}
+
+
 bool msgpack_object_equal(const msgpack_object x, const msgpack_object y)
 {
     if(x.type != y.type) { return false; }
@@ -239,7 +486,8 @@ bool msgpack_object_equal(const msgpack_object x, const msgpack_object y)
     case MSGPACK_OBJECT_NEGATIVE_INTEGER:
         return x.via.i64 == y.via.i64;
 
-    case MSGPACK_OBJECT_FLOAT:
+    case MSGPACK_OBJECT_FLOAT32:
+    case MSGPACK_OBJECT_FLOAT64:
         return x.via.f64 == y.via.f64;
 
     case MSGPACK_OBJECT_STR:

src/unpack.c

@@ -151,7 +151,7 @@ static inline int template_callback_int64(unpack_user* u, int64_t d, msgpack_obj
 static inline int template_callback_float(unpack_user* u, float d, msgpack_object* o)
 {
     MSGPACK_UNUSED(u);
-    o->type = MSGPACK_OBJECT_FLOAT;
+    o->type = MSGPACK_OBJECT_FLOAT32;
     o->via.f64 = d;
     return 0;
 }
@@ -159,7 +159,7 @@ static inline int template_callback_float(unpack_user* u, float d, msgpack_objec
 static inline int template_callback_double(unpack_user* u, double d, msgpack_object* o)
 {
     MSGPACK_UNUSED(u);
-    o->type = MSGPACK_OBJECT_FLOAT;
+    o->type = MSGPACK_OBJECT_FLOAT64;
     o->via.f64 = d;
     return 0;
 }
@@ -189,10 +189,16 @@ static inline int template_callback_false(unpack_user* u, msgpack_object* o)
 
 static inline int template_callback_array(unpack_user* u, unsigned int n, msgpack_object* o)
 {
+    unsigned int size;
     o->type = MSGPACK_OBJECT_ARRAY;
     o->via.array.size = 0;
-    o->via.array.ptr = (msgpack_object*)msgpack_zone_malloc(u->z, n*sizeof(msgpack_object));
-    if(o->via.array.ptr == NULL) { return -1; }
+    size = n*sizeof(msgpack_object);
+    if (size / sizeof(msgpack_object) != n) {
+        // integer overflow
+        return MSGPACK_UNPACK_NOMEM_ERROR;
+    }
+    o->via.array.ptr = (msgpack_object*)msgpack_zone_malloc(u->z, size);
+    if(o->via.array.ptr == NULL) { return MSGPACK_UNPACK_NOMEM_ERROR; }
     return 0;
 }
 
@@ -210,10 +216,16 @@ static inline int template_callback_array_item(unpack_user* u, msgpack_object* c
 
 static inline int template_callback_map(unpack_user* u, unsigned int n, msgpack_object* o)
 {
+    unsigned int size;
     o->type = MSGPACK_OBJECT_MAP;
     o->via.map.size = 0;
-    o->via.map.ptr = (msgpack_object_kv*)msgpack_zone_malloc(u->z, n*sizeof(msgpack_object_kv));
-    if(o->via.map.ptr == NULL) { return -1; }
+    size = n*sizeof(msgpack_object_kv);
+    if (size / sizeof(msgpack_object_kv) != n) {
+        // integer overflow
+        return MSGPACK_UNPACK_NOMEM_ERROR;
+    }
+    o->via.map.ptr = (msgpack_object_kv*)msgpack_zone_malloc(u->z, size);
+    if(o->via.map.ptr == NULL) { return MSGPACK_UNPACK_NOMEM_ERROR; }
     return 0;
 }
 
@@ -255,6 +267,9 @@ static inline int template_callback_bin(unpack_user* u, const char* b, const cha
 
 static inline int template_callback_ext(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o)
 {
+    if (l == 0) {
+        return MSGPACK_UNPACK_PARSE_ERROR;
+    }
     MSGPACK_UNUSED(u);
     MSGPACK_UNUSED(b);
     o->type = MSGPACK_OBJECT_EXT;
@@ -510,7 +525,8 @@ void msgpack_unpacker_reset(msgpack_unpacker* mpac)
     mpac->parsed = 0;
 }
 
-msgpack_unpack_return msgpack_unpacker_next(msgpack_unpacker* mpac, msgpack_unpacked* result)
+static inline msgpack_unpack_return unpacker_next(msgpack_unpacker* mpac,
+                                                  msgpack_unpacked* result)
 {
     int ret;
 
@@ -521,7 +537,7 @@ msgpack_unpack_return msgpack_unpacker_next(msgpack_unpacker* mpac, msgpack_unpa
     if(ret < 0) {
         result->zone = NULL;
         memset(&result->data, 0, sizeof(msgpack_object));
-        return MSGPACK_UNPACK_PARSE_ERROR;
+        return ret;
     }
 
     if(ret == 0) {
@@ -529,11 +545,40 @@ msgpack_unpack_return msgpack_unpacker_next(msgpack_unpacker* mpac, msgpack_unpa
     }
     result->zone = msgpack_unpacker_release_zone(mpac);
     result->data = msgpack_unpacker_data(mpac);
-    msgpack_unpacker_reset(mpac);
 
     return MSGPACK_UNPACK_SUCCESS;
 }
 
+msgpack_unpack_return msgpack_unpacker_next(msgpack_unpacker* mpac,
+                                            msgpack_unpacked* result)
+{
+    int ret;
+
+    ret = unpacker_next(mpac, result);
+    if (ret == MSGPACK_UNPACK_SUCCESS) {
+        msgpack_unpacker_reset(mpac);
+    }
+
+    return ret;
+}
+
+msgpack_unpack_return
+msgpack_unpacker_next_with_size(msgpack_unpacker* mpac,
+                                msgpack_unpacked* result, size_t *p_bytes)
+{
+    int ret;
+
+    ret = unpacker_next(mpac, result);
+    if (ret == MSGPACK_UNPACK_SUCCESS || ret == MSGPACK_UNPACK_CONTINUE) {
+        *p_bytes = mpac->parsed;
+    }
+
+    if (ret == MSGPACK_UNPACK_SUCCESS) {
+        msgpack_unpacker_reset(mpac);
+    }
+
+    return ret;
+}
 
 msgpack_unpack_return
 msgpack_unpack(const char* data, size_t len, size_t* off,
@@ -556,7 +601,7 @@ msgpack_unpack(const char* data, size_t len, size_t* off,
 
         e = template_execute(&ctx, data, len, &noff);
         if(e < 0) {
-            return MSGPACK_UNPACK_PARSE_ERROR;
+            return e;
         }
 
         if(off != NULL) { *off = noff; }
@@ -607,7 +652,7 @@ msgpack_unpack_next(msgpack_unpacked* result,
         if(e < 0) {
             msgpack_zone_free(result->zone);
             result->zone = NULL;
-            return MSGPACK_UNPACK_PARSE_ERROR;
+            return e;
         }
 
 

test/CMakeLists.txt

@@ -45,6 +45,13 @@ IF (MSGPACK_BOOST)
         boost_variant.cpp
         boost_optional.cpp
         boost_string_ref.cpp
+        boost_string_view.cpp
+    )
+ENDIF ()
+
+IF (MSGPACK_USE_X3_PARSE)
+    LIST (APPEND check_PROGRAMS
+        msgpack_x3_parse.cpp
     )
 ENDIF ()
 
@@ -85,13 +92,6 @@ FOREACH (source_file ${check_PROGRAMS})
         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] /WX")
             STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")

test/boost_fusion.cpp

@@ -159,6 +159,57 @@ TEST(MSGPACK_BOOST, pack_convert_no_def_con)
 
 #endif // !defined(_MSC_VER)
 
+struct mystruct_no_def_con_def_con {
+    mystruct_no_def_con_def_con() = delete;
+    // Constructor that have parameters corresponding to BOOST_FUSION_ADAPT_STRUCT is mandatory.
+    // See *1, *2, and *3
+    mystruct_no_def_con_def_con(
+        no_def_con1 i,
+        no_def_con2 j,
+        int k):
+        f1(std::move(i)),
+        f2(std::move(j)),
+        f3(std::move(k)) {}
+
+    no_def_con1 f1;
+    no_def_con2 f2;
+    int f3;
+};
+
+inline bool operator==(mystruct_no_def_con_def_con const& lhs, mystruct_no_def_con_def_con const& rhs) {
+    return lhs.f1 == rhs.f1 && lhs.f2 == rhs.f2 && lhs.f3 == rhs.f3;
+}
+
+inline bool operator!=(mystruct_no_def_con_def_con const& lhs, mystruct_no_def_con_def_con const& rhs) {
+    return !(lhs == rhs);
+}
+
+BOOST_FUSION_ADAPT_STRUCT(
+    mystruct_no_def_con_def_con,
+    f1, // *1
+    f2, // *2
+    f3  // *3
+)
+
+
+// MSVC2015's std::tuple requires default constructor during 'as' process.
+// It doesn't support Expression SFINAE yet, then 'as' is fallbacked to 'convert'.
+// After MSVC would support Expression SFINAE, remove this guard.
+#if !defined(_MSC_VER)
+
+TEST(MSGPACK_BOOST, pack_convert_no_def_con_def_con)
+{
+    std::stringstream ss;
+    mystruct_no_def_con_def_con val1(no_def_con1(1), no_def_con2(2), 3);
+    msgpack::pack(ss, val1);
+    msgpack::object_handle oh =
+        msgpack::unpack(ss.str().data(), ss.str().size());
+    mystruct_no_def_con_def_con val2 = oh.get().as<mystruct_no_def_con_def_con>();
+    EXPECT_TRUE(val1 == val2);
+}
+
+#endif // !defined(_MSC_VER)
+
 #endif // !defined(MSGPACK_USE_CPP03
 
 #endif // defined(MSGPACK_USE_BOOST)

test/boost_string_view.cpp

@@ -0,0 +1,47 @@
+#include <msgpack.hpp>
+#include <sstream>
+#include <iterator>
+#include <gtest/gtest.h>
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#if defined(MSGPACK_USE_BOOST)
+#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 61
+
+TEST(MSGPACK_BOOST, pack_convert_string_view)
+{
+    std::stringstream ss;
+    std::string s = "ABC";
+    boost::string_view val1(s);
+
+    msgpack::pack(ss, val1);
+
+    msgpack::object_handle oh;
+    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    boost::string_view val2 = oh.get().as<boost::string_view>();
+    EXPECT_TRUE(val1 == val2);
+}
+
+TEST(MSGPACK_BOOST, object_strinf_view)
+{
+    std::string s = "ABC";
+    boost::string_view val1(s);
+    msgpack::object obj(val1);
+    boost::string_view val2 = obj.as<boost::string_view>();
+    EXPECT_TRUE(val1 == val2);
+}
+
+TEST(MSGPACK_BOOST, object_with_zone_string_view)
+{
+    msgpack::zone z;
+    std::string s = "ABC";
+    boost::string_view val1(s);
+    msgpack::object obj(val1, z);
+    boost::string_view val2 = obj.as<boost::string_view>();
+    EXPECT_TRUE(val1 == val2);
+}
+
+#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 61
+#endif // defined(MSGPACK_USE_BOOST)

test/carray.cpp

@@ -113,7 +113,7 @@ TEST(carray, pack_unpack_char_as_str)
     msgpack::pack(ss, v1);
     msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
     EXPECT_EQ(oh.get().type, msgpack::type::STR);
-    EXPECT_EQ(oh.get().via.str.size, 1);
+    EXPECT_EQ(oh.get().via.str.size, static_cast<size_t>(1));
 
     char v2[2] = { 2, 3 };
     oh.get().convert(v2);
@@ -143,7 +143,7 @@ TEST(carray, obj_with_zone_char_as_str)
 
     msgpack::object o(v1, z);
     EXPECT_EQ(o.type, msgpack::type::STR);
-    EXPECT_EQ(o.via.str.size, 1);
+    EXPECT_EQ(o.via.str.size, static_cast<size_t>(1));
 
     char v2[2];
     o.convert(v2);
@@ -175,7 +175,7 @@ TEST(carray, pack_unpack_unsigned_char_as_bin)
     msgpack::pack(ss, v1);
     msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
     EXPECT_EQ(oh.get().type, msgpack::type::BIN);
-    EXPECT_EQ(oh.get().via.bin.size, 2);
+    EXPECT_EQ(oh.get().via.bin.size, static_cast<size_t>(2));
 
     unsigned char v2[2];
     oh.get().convert(v2);
@@ -205,7 +205,7 @@ TEST(carray, obj_with_zone_unsigned_char_as_bin)
 
     msgpack::object o(v1, z);
     EXPECT_EQ(o.type, msgpack::type::BIN);
-    EXPECT_EQ(o.via.bin.size, 2);
+    EXPECT_EQ(o.via.bin.size, static_cast<size_t>(2));
 
     unsigned char v2[2];
     o.convert(v2);

test/convert.cpp

@@ -92,7 +92,15 @@ TEST(convert, return_value_ptr)
     msgpack::object obj(1, z);
 
     int i;
+    // obsolete
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
     EXPECT_EQ(obj.convert(&i), &i);
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
+#pragma GCC diagnostic pop
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
     EXPECT_EQ(1, i);
 }
 

test/iterator_cpp11.cpp

@@ -32,7 +32,7 @@ TEST(iterator, vector)
     auto const& msgarr = oh.get().via.array;
     auto dist = std::distance(begin(msgarr), end(msgarr));
     auto vecSize = vec.size();
-    EXPECT_EQ(dist, vecSize);
+    EXPECT_EQ(static_cast<size_t>(dist), vecSize);
 
     vec_type::const_iterator correct = std::begin(vec);
     for (auto const& obj : msgarr) {
@@ -58,7 +58,7 @@ TEST(iterator, map)
     auto const& msgmap = oh.get().via.map;
     auto dist = std::distance(begin(msgmap), end(msgmap));
     auto mapSize = map.size();
-    EXPECT_EQ(dist, mapSize);
+    EXPECT_EQ(static_cast<size_t>(dist), mapSize);
 
     for (auto const& kv : msgmap) {
         auto key = kv.key.as<unsigned int>();

test/limit.cpp

@@ -518,8 +518,15 @@ TEST(limit, unpack_array_over_off_ref_pointer)
         bool ref;
         std::size_t off = 0;
         msgpack::object_handle unp;
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
         msgpack::unpack(&unp, ss.str().c_str(), ss.str().size(), &off, &ref, MSGPACK_NULLPTR, MSGPACK_NULLPTR,
                         msgpack::unpack_limit(2, 0, 0, 0, 0));
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
+#pragma GCC diagnostic pop
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
         EXPECT_TRUE(false);
     }
     catch(msgpack::array_size_overflow const&) {

test/msgpack_c.cpp

@@ -225,10 +225,7 @@ TEST(MSGPACKC, simple_buffer_float)
         msgpack_unpack_return ret =
             msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
         EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
-        EXPECT_EQ(MSGPACK_OBJECT_FLOAT, obj.type);
-#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
-        EXPECT_EQ(MSGPACK_OBJECT_DOUBLE, obj.type);
-#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT
+        EXPECT_EQ(MSGPACK_OBJECT_FLOAT32, obj.type);
         if (isnan(val)) {
             EXPECT_TRUE(isnan(obj.via.f64));
 #if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
@@ -290,6 +287,7 @@ TEST(MSGPACKC, simple_buffer_double)
         msgpack_unpack_return ret =
             msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
         EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
+        EXPECT_EQ(MSGPACK_OBJECT_FLOAT64, obj.type);
         EXPECT_EQ(MSGPACK_OBJECT_FLOAT, obj.type);
 #if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
         EXPECT_EQ(MSGPACK_OBJECT_DOUBLE, obj.type);
@@ -370,7 +368,7 @@ TEST(MSGPACKC, simple_buffer_false)
         msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
     EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
     EXPECT_EQ(MSGPACK_OBJECT_BOOLEAN, obj.type);
-    EXPECT_EQ(false, obj.via.boolean);
+    EXPECT_FALSE(obj.via.boolean);
     msgpack_zone_destroy(&z);
     msgpack_sbuffer_destroy(&sbuf);
 }
@@ -665,7 +663,7 @@ TEST(MSGPACKC, simple_buffer_array)
             break;
         case 2:
             EXPECT_EQ(MSGPACK_OBJECT_BOOLEAN, o.type);
-            EXPECT_EQ(false, o.via.boolean);
+            EXPECT_FALSE(o.via.boolean);
             break;
         case 3:
             EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, o.type);
@@ -713,7 +711,7 @@ TEST(MSGPACKC, simple_buffer_map)
             EXPECT_EQ(MSGPACK_OBJECT_BOOLEAN, key.type);
             EXPECT_EQ(true, key.via.boolean);
             EXPECT_EQ(MSGPACK_OBJECT_BOOLEAN, val.type);
-            EXPECT_EQ(false, val.via.boolean);
+            EXPECT_FALSE(val.via.boolean);
             break;
         case 1:
             EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, key.type);

test/msgpack_cpp11.cpp

@@ -612,6 +612,18 @@ TEST(MSGPACK_NO_DEF_CON_ASSOC_VECTOR, simple_buffer)
     EXPECT_EQ(val1, val2);
 }
 
+TEST(MSGPACK_NO_DEF_CON_DEF_CON_ASSOC_VECTOR, simple_buffer)
+{
+    msgpack::type::assoc_vector<no_def_con, int> val1 { {1, 2}, {3, 4}, {5, 6}};
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, val1);
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    msgpack::type::assoc_vector<no_def_con, int> val2
+        = oh.get().as<msgpack::type::assoc_vector<no_def_con, int>>();
+    EXPECT_EQ(val1, val2);
+}
+
 TEST(MSGPACK_NO_DEF_CON_MAP, simple_buffer)
 {
     std::map<no_def_con, no_def_con_composite> val1 { {1, 2}, {3, 4}, {5, 6}};
@@ -624,6 +636,18 @@ TEST(MSGPACK_NO_DEF_CON_MAP, simple_buffer)
     EXPECT_EQ(val1, val2);
 }
 
+TEST(MSGPACK_NO_DEF_CON_DEF_CON_MAP, simple_buffer)
+{
+    std::map<no_def_con, int> val1 { {1, 2}, {3, 4}, {5, 6}};
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, val1);
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    std::map<no_def_con, int> val2
+        = oh.get().as<std::map<no_def_con, int>>();
+    EXPECT_EQ(val1, val2);
+}
+
 TEST(MSGPACK_NO_DEF_CON_MULTIMAP, simple_buffer)
 {
     std::multimap<no_def_con, no_def_con_composite> val1 { {1, 2}, {3, 4}, {5, 6}};
@@ -636,6 +660,18 @@ TEST(MSGPACK_NO_DEF_CON_MULTIMAP, simple_buffer)
     EXPECT_EQ(val1, val2);
 }
 
+TEST(MSGPACK_NO_DEF_CON_DEF_CON_MULTIMAP, simple_buffer)
+{
+    std::multimap<no_def_con, int> val1 { {1, 2}, {3, 4}, {5, 6}};
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, val1);
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    std::multimap<no_def_con, int> val2
+        = oh.get().as<std::multimap<no_def_con, int>>();
+    EXPECT_EQ(val1, val2);
+}
+
 TEST(MSGPACK_NO_DEF_CON_DEQUE, simple_buffer)
 {
     std::deque<no_def_con> val1 { 1, 2, 3 };
@@ -659,6 +695,18 @@ TEST(MSGPACK_NO_DEF_CON_PAIR, simple_buffer)
     EXPECT_EQ(val1, val2);
 }
 
+TEST(MSGPACK_NO_DEF_CON_DEF_CON_PAIR, simple_buffer)
+{
+    std::pair<no_def_con, int> val1 {1, 2};
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, val1);
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    std::pair<no_def_con, int> val2
+        = oh.get().as<std::pair<no_def_con, int>>();
+    EXPECT_EQ(val1, val2);
+}
+
 
 
 // MSVC2015's std::tuple requires default constructor during 'as' process.
@@ -678,6 +726,18 @@ TEST(MSGPACK_NO_DEF_CON_TUPLE, simple_buffer)
     EXPECT_EQ(val1, val2);
 }
 
+TEST(MSGPACK_NO_DEF_CON_DEF_CON_TUPLE, simple_buffer)
+{
+    std::tuple<no_def_con, no_def_con, int> val1 {1, 2, 3};
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, val1);
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    std::tuple<no_def_con, no_def_con, int> val2
+        = oh.get().as<std::tuple<no_def_con, no_def_con, int>>();
+    EXPECT_EQ(val1, val2);
+}
+
 TEST(MSGPACK_NO_DEF_CON_MSGPACK_TUPLE, simple_buffer)
 {
     msgpack::type::tuple<no_def_con, no_def_con, no_def_con_composite> val1 {1, 2, 3};
@@ -690,6 +750,18 @@ TEST(MSGPACK_NO_DEF_CON_MSGPACK_TUPLE, simple_buffer)
     EXPECT_EQ(val1, val2);
 }
 
+TEST(MSGPACK_NO_DEF_CON_DEF_CON_MSGPACK_TUPLE, simple_buffer)
+{
+    msgpack::type::tuple<no_def_con, no_def_con, int> val1 {1, 2, 3};
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, val1);
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    msgpack::type::tuple<no_def_con, no_def_con, int> val2
+        = oh.get().as<msgpack::type::tuple<no_def_con, no_def_con, int>>();
+    EXPECT_EQ(val1, val2);
+}
+
 #endif // !define(_MSC_VER)
 
 TEST(MSGPACK_NO_DEF_FORWARD_LIST, simple_buffer)
@@ -737,6 +809,18 @@ TEST(MSGPACK_NO_DEF_CON_UNORDERED_MAP, simple_buffer)
     EXPECT_EQ(val1, val2);
 }
 
+TEST(MSGPACK_NO_DEF_CON_DEF_CON_UNORDERED_MAP, simple_buffer)
+{
+    std::unordered_map<no_def_con, int> val1 { {1, 2}, {3, 4}, {5, 6}};
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, val1);
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    std::unordered_map<no_def_con, int> val2
+        = oh.get().as<std::unordered_map<no_def_con, int>>();
+    EXPECT_EQ(val1, val2);
+}
+
 TEST(MSGPACK_NO_DEF_CON_UNORDERED_MULTIMAP, simple_buffer)
 {
     std::unordered_multimap<no_def_con, no_def_con_composite> val1 { {1, 2}, {3, 4}, {5, 6}};
@@ -749,6 +833,18 @@ TEST(MSGPACK_NO_DEF_CON_UNORDERED_MULTIMAP, simple_buffer)
     EXPECT_EQ(val1, val2);
 }
 
+TEST(MSGPACK_NO_DEF_CON_DEF_CON_UNORDERED_MULTIMAP, simple_buffer)
+{
+    std::unordered_multimap<no_def_con, int> val1 { {1, 2}, {3, 4}, {5, 6}};
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, val1);
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    std::unordered_multimap<no_def_con, int> val2
+        = oh.get().as<std::unordered_multimap<no_def_con, int>>();
+    EXPECT_EQ(val1, val2);
+}
+
 TEST(MSGPACK_NO_DEF_CON_ARRAY, simple_buffer)
 {
     std::array<no_def_con, 3> val1 { { 1, 2, 3 } };

test/msgpack_tuple.cpp

@@ -12,7 +12,7 @@ TEST(msgpack_tuple, member_get)
     t1.get<1>() = false;
     t1.get<2>() = "DEFG";
     EXPECT_EQ(40, t1.get<0>());
-    EXPECT_EQ(false, t1.get<1>());
+    EXPECT_FALSE(t1.get<1>());
     EXPECT_EQ("DEFG", t1.get<2>());
 }
 
@@ -26,7 +26,7 @@ TEST(msgpack_tuple, non_member_get)
     msgpack::type::get<1>(t1) = false;
     msgpack::type::get<2>(t1) = "DEFG";
     EXPECT_EQ(40, msgpack::type::get<0>(t1));
-    EXPECT_EQ(false, msgpack::type::get<1>(t1));
+    EXPECT_FALSE(msgpack::type::get<1>(t1));
     EXPECT_EQ("DEFG", msgpack::type::get<2>(t1));
 }
 
@@ -41,7 +41,7 @@ TEST(msgpack_tuple, std_non_member_get)
     std::get<1>(t1) = false;
     std::get<2>(t1) = "DEFG";
     EXPECT_EQ(40, std::get<0>(t1));
-    EXPECT_EQ(false, std::get<1>(t1));
+    EXPECT_FALSE(std::get<1>(t1));
     EXPECT_EQ("DEFG", std::get<2>(t1));
 }
 
@@ -55,7 +55,7 @@ TEST(msgpack_tuple, make_tuple)
     t1.get<1>() = false;
     t1.get<2>() = "DEFG";
     EXPECT_EQ(40, t1.get<0>());
-    EXPECT_EQ(false, t1.get<1>());
+    EXPECT_FALSE(t1.get<1>());
     EXPECT_EQ("DEFG", t1.get<2>());
 }
 
@@ -97,7 +97,7 @@ TEST(msgpack_tuple, swap)
     EXPECT_EQ(true, t2.get<1>());
     EXPECT_EQ("ABC", t2.get<2>());
     EXPECT_EQ(40, t1.get<0>());
-    EXPECT_EQ(false, t1.get<1>());
+    EXPECT_FALSE(t1.get<1>());
     EXPECT_EQ("DEFG", t1.get<2>());
 }
 #endif

test/msgpack_x3_parse.cpp

@@ -0,0 +1,829 @@
+#include "msgpack.hpp"
+
+#include <sstream>
+#include <limits>
+
+#if defined(MSGPACK_USE_X3_PARSE)
+
+#include <gtest/gtest.h>
+
+using namespace std;
+
+const double kEPS = 1e-10;
+
+TEST(MSGPACK_X3_PARSE, nil_t)
+{
+    msgpack::type::nil_t v;
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_TRUE(oh.get().is_nil());
+}
+
+TEST(MSGPACK_X3_PARSE, bool_false)
+{
+    bool v = false;
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<bool>());
+}
+
+TEST(MSGPACK_X3_PARSE, bool_true)
+{
+    bool v = true;
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<bool>());
+}
+
+TEST(MSGPACK_X3_PARSE, positive_fixint_1)
+{
+    uint8_t v = 0;
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<uint8_t>());
+}
+
+TEST(MSGPACK_X3_PARSE, positive_fixint_2)
+{
+    uint8_t v = 127;
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<uint8_t>());
+}
+
+TEST(MSGPACK_X3_PARSE, negative_fixint_1)
+{
+    int8_t v = -1;
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<int8_t>());
+}
+
+TEST(MSGPACK_X3_PARSE, negative_fixint_2)
+{
+    int8_t v = -32;
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<int8_t>());
+}
+
+TEST(MSGPACK_X3_PARSE, uint8_1)
+{
+    uint8_t v = 128U;
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<uint8_t>());
+}
+
+TEST(MSGPACK_X3_PARSE, uint8_2)
+{
+    uint8_t v = 0xffU;
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<uint8_t>());
+}
+
+TEST(MSGPACK_X3_PARSE, uint16_1)
+{
+    uint16_t v = 0x100U;
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<uint16_t>());
+}
+
+TEST(MSGPACK_X3_PARSE, uint16_2)
+{
+    uint16_t v = 0xffffU;
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<uint16_t>());
+}
+
+TEST(MSGPACK_X3_PARSE, uint32_1)
+{
+    uint32_t v = 0x10000UL;
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<uint32_t>());
+}
+
+TEST(MSGPACK_X3_PARSE, uint32_2)
+{
+    uint32_t v = 0xffffffffUL;
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<uint32_t>());
+}
+
+TEST(MSGPACK_X3_PARSE, uint64_1)
+{
+    uint64_t v = 0x100000000ULL;
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<uint64_t>());
+}
+
+TEST(MSGPACK_X3_PARSE, uint64_2)
+{
+    uint64_t v = 0xffffffffffffffffULL;
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<uint64_t>());
+}
+
+TEST(MSGPACK_X3_PARSE, int8_1)
+{
+    int8_t v = 0b11011111;
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<int8_t>());
+}
+
+TEST(MSGPACK_X3_PARSE, int8_2)
+{
+    int8_t v = 0b10000000;
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<int8_t>());
+}
+
+TEST(MSGPACK_X3_PARSE, int16_1)
+{
+    int16_t v = 0xff00;
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<int16_t>());
+}
+
+TEST(MSGPACK_X3_PARSE, int16_2)
+{
+    int16_t v = 0x8000;
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<int16_t>());
+}
+
+TEST(MSGPACK_X3_PARSE, int32_1)
+{
+    int32_t v = 0xff000000L;
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<int32_t>());
+}
+
+TEST(MSGPACK_X3_PARSE, int32_2)
+{
+    int32_t v = 0x80000000L;
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<int32_t>());
+}
+
+TEST(MSGPACK_X3_PARSE, int64_1)
+{
+    int64_t v = 0xff00000000000000LL;
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<int64_t>());
+}
+
+TEST(MSGPACK_X3_PARSE, int64_2)
+{
+    int64_t v = 0x8000000000000000LL;
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<int64_t>());
+}
+
+TEST(MSGPACK_X3_PARSE, array_1)
+{
+    std::vector<int> v;
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<std::vector<int> >());
+}
+
+TEST(MSGPACK_X3_PARSE, array_2)
+{
+    std::vector<int> v;
+    std::stringstream ss;
+    for (int i = 0; i != 0xffU; ++i) v.push_back(i);
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<std::vector<int> >());
+}
+
+TEST(MSGPACK_X3_PARSE, array_3)
+{
+    std::vector<int> v;
+    std::stringstream ss;
+    for (int i = 0; i != 0xffU+1U; ++i) v.push_back(i);
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<std::vector<int> >());
+}
+
+TEST(MSGPACK_X3_PARSE, array_4)
+{
+    std::vector<int> v;
+    std::stringstream ss;
+    for (int i = 0; i != 0xffffU; ++i) v.push_back(i);
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<std::vector<int> >());
+}
+
+TEST(MSGPACK_X3_PARSE, array_5)
+{
+    std::vector<uint32_t> v;
+    std::stringstream ss;
+    for (uint32_t i = 0; i != 0xffffU+1U; ++i) v.push_back(i);
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<std::vector<uint32_t> >());
+}
+
+TEST(MSGPACK_X3_PARSE, map_1)
+{
+    std::map<int, int> v;
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, (oh.get().as<std::map<int, int> >()));
+}
+
+TEST(MSGPACK_X3_PARSE, map_2)
+{
+    std::map<int, int> v;
+    std::stringstream ss;
+    for (int i = 0; i != 0xffU; ++i) v.emplace(i, i);
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, (oh.get().as<std::map<int, int> >()));
+}
+
+TEST(MSGPACK_X3_PARSE, map_3)
+{
+    std::map<int, int> v;
+    std::stringstream ss;
+    for (int i = 0; i != 0xffU+1U; ++i) v.emplace(i, i);
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, (oh.get().as<std::map<int, int> >()));
+}
+
+TEST(MSGPACK_X3_PARSE, map_4)
+{
+    std::map<int, int> v;
+    std::stringstream ss;
+    for (int i = 0; i != 0xffffU; ++i) v.emplace(i, i);
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, (oh.get().as<std::map<int, int> >()));
+}
+
+TEST(MSGPACK_X3_PARSE, map_5)
+{
+    std::map<uint32_t, uint32_t> v;
+    std::stringstream ss;
+    for (uint32_t i = 0; i != 0xffffU+1U; ++i) v.emplace(i, i);
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, (oh.get().as<std::map<uint32_t, uint32_t> >()));
+}
+
+TEST(MSGPACK_X3_PARSE, float_1)
+{
+    std::vector<float> v;
+    v.push_back(0.0);
+    v.push_back(-0.0);
+    v.push_back(1.0);
+    v.push_back(-1.0);
+    v.push_back(numeric_limits<float>::min());
+    v.push_back(numeric_limits<float>::max());
+    v.push_back(nanf("tag"));
+    if (numeric_limits<float>::has_infinity) {
+        v.push_back(numeric_limits<float>::infinity());
+        v.push_back(-numeric_limits<float>::infinity());
+    }
+    if (numeric_limits<float>::has_quiet_NaN) {
+        v.push_back(numeric_limits<float>::quiet_NaN());
+    }
+    if (numeric_limits<float>::has_signaling_NaN) {
+        v.push_back(numeric_limits<float>::signaling_NaN());
+    }
+
+    for (unsigned int i = 0; i < v.size() ; i++) {
+        std::stringstream ss;
+        float val1 = v[i];
+        msgpack::pack(ss, val1);
+        msgpack::object_handle oh =
+            msgpack::unpack(ss.str().begin(), ss.str().end());
+        float val2 = oh.get().as<float>();
+
+        if (std::isnan(val1))
+            EXPECT_TRUE(std::isnan(val2));
+        else if (std::isinf(val1))
+            EXPECT_TRUE(std::isinf(val2));
+        else
+            EXPECT_TRUE(fabs(val2 - val1) <= kEPS);
+    }
+}
+
+TEST(MSGPACK_X3_PARSE, double_1)
+{
+    std::vector<double> v;
+    v.push_back(0.0);
+    v.push_back(-0.0);
+    v.push_back(1.0);
+    v.push_back(-1.0);
+    v.push_back(numeric_limits<double>::min());
+    v.push_back(numeric_limits<double>::max());
+    v.push_back(nanf("tag"));
+    if (numeric_limits<double>::has_infinity) {
+        v.push_back(numeric_limits<double>::infinity());
+        v.push_back(-numeric_limits<double>::infinity());
+    }
+    if (numeric_limits<double>::has_quiet_NaN) {
+        v.push_back(numeric_limits<double>::quiet_NaN());
+    }
+    if (numeric_limits<double>::has_signaling_NaN) {
+        v.push_back(numeric_limits<double>::signaling_NaN());
+    }
+
+    for (unsigned int i = 0; i < v.size() ; i++) {
+        std::stringstream ss;
+        double val1 = v[i];
+        msgpack::pack(ss, val1);
+        msgpack::object_handle oh =
+            msgpack::unpack(ss.str().begin(), ss.str().end());
+        double val2 = oh.get().as<double>();
+
+        if (std::isnan(val1))
+            EXPECT_TRUE(std::isnan(val2));
+        else if (std::isinf(val1))
+            EXPECT_TRUE(std::isinf(val2));
+        else
+            EXPECT_TRUE(fabs(val2 - val1) <= kEPS);
+    }
+}
+
+TEST(MSGPACK_X3_PARSE, string_1)
+{
+    std::string v;
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<std::string>());
+}
+
+TEST(MSGPACK_X3_PARSE, string_2)
+{
+    std::string v;
+
+    for (uint64_t i = 0; i != 0x1fU; ++i) v.push_back('0'+(i%10));
+
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<std::string>());
+}
+
+TEST(MSGPACK_X3_PARSE, string_3)
+{
+    std::string v;
+
+    for (uint64_t i = 0; i != 0xffU; ++i) v.push_back('0'+(i%10));
+
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<std::string>());
+}
+
+TEST(MSGPACK_X3_PARSE, string_4)
+{
+    std::string v;
+
+    for (uint64_t i = 0; i != 0xffU+1U; ++i) v.push_back('0'+(i%10));
+
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<std::string>());
+}
+
+TEST(MSGPACK_X3_PARSE, string_5)
+{
+    std::string v;
+
+    for (uint64_t i = 0; i != 0xffffU; ++i) v.push_back('0'+(i%10));
+
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<std::string>());
+}
+
+TEST(MSGPACK_X3_PARSE, string_6)
+{
+    std::string v;
+
+    for (uint64_t i = 0; i != 0xffffUL + 1UL; ++i) v.push_back('0'+(i%10));
+
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<std::string>());
+}
+
+TEST(MSGPACK_X3_PARSE, bin_1)
+{
+    std::vector<char> v;
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<std::vector<char>>());
+}
+
+TEST(MSGPACK_X3_PARSE, bin_2)
+{
+    std::vector<char> v;
+
+    for (uint64_t i = 0; i != 0x1fU; ++i) v.push_back(i%0xff);
+
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<std::vector<char>>());
+}
+
+TEST(MSGPACK_X3_PARSE, bin_3)
+{
+    std::vector<char> v;
+
+    for (uint64_t i = 0; i != 0xffU; ++i) v.push_back(i%0xff);
+
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<std::vector<char>>());
+}
+
+TEST(MSGPACK_X3_PARSE, bin_4)
+{
+    std::vector<char> v;
+
+    for (uint64_t i = 0; i != 0xffU+1U; ++i) v.push_back(i%0xff);
+
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<std::vector<char>>());
+}
+
+TEST(MSGPACK_X3_PARSE, bin_5)
+{
+    std::vector<char> v;
+
+    for (uint64_t i = 0; i != 0xffffU; ++i) v.push_back(i%0xff);
+
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<std::vector<char>>());
+}
+
+TEST(MSGPACK_X3_PARSE, bin_6)
+{
+    std::vector<char> v;
+
+    for (uint64_t i = 0; i != 0xffffUL + 1UL; ++i) v.push_back(i%0xff);
+
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, oh.get().as<std::vector<char>>());
+}
+
+TEST(MSGPACK_X3_PARSE, fixext1)
+{
+    std::stringstream ss;
+    msgpack::packer<std::stringstream> packer(ss);
+    char const buf [] = { 2 };
+
+    packer.pack_ext(sizeof(buf), 1);
+    packer.pack_ext_body(buf, sizeof(buf));
+    msgpack::object_handle oh =
+        msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(1ul, oh.get().via.ext.size);
+    EXPECT_EQ(1, oh.get().via.ext.type());
+    EXPECT_EQ(2, oh.get().via.ext.data()[0]);
+}
+
+TEST(MSGPACK_X3_PARSE, fixext2)
+{
+    std::stringstream ss;
+    msgpack::packer<std::stringstream> packer(ss);
+    char const buf [] = { 2, 3 };
+
+    packer.pack_ext(sizeof(buf), 0);
+    packer.pack_ext_body(buf, sizeof(buf));
+    msgpack::object_handle oh =
+        msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(2ul, oh.get().via.ext.size);
+    EXPECT_EQ(0, oh.get().via.ext.type());
+    EXPECT_TRUE(
+        std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
+}
+
+TEST(MSGPACK_X3_PARSE, fixext4)
+{
+    std::stringstream ss;
+    msgpack::packer<std::stringstream> packer(ss);
+    char const buf [] = { 2, 3, 4, 5 };
+
+    packer.pack_ext(sizeof(buf), 1);
+    packer.pack_ext_body(buf, sizeof(buf));
+    msgpack::object_handle oh =
+        msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(4ul, oh.get().via.ext.size);
+    EXPECT_EQ(1, oh.get().via.ext.type());
+    EXPECT_TRUE(
+        std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
+}
+
+TEST(MSGPACK_X3_PARSE, fixext8)
+{
+    std::stringstream ss;
+    msgpack::packer<std::stringstream> packer(ss);
+    char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9 };
+
+    packer.pack_ext(sizeof(buf), 1);
+    packer.pack_ext_body(buf, sizeof(buf));
+    msgpack::object_handle oh =
+        msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(8ul, oh.get().via.ext.size);
+    EXPECT_EQ(1, oh.get().via.ext.type());
+    EXPECT_TRUE(
+        std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
+}
+
+TEST(MSGPACK_X3_PARSE, fixext16)
+{
+    std::stringstream ss;
+    msgpack::packer<std::stringstream> packer(ss);
+    char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 };
+
+    packer.pack_ext(sizeof(buf), 1);
+    packer.pack_ext_body(buf, sizeof(buf));
+    msgpack::object_handle oh =
+        msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(16ul, oh.get().via.ext.size);
+    EXPECT_EQ(1, oh.get().via.ext.type());
+    EXPECT_TRUE(
+        std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
+}
+
+TEST(MSGPACK_X3_PARSE, ext_0)
+{
+    std::size_t const size = 0;
+    std::stringstream ss;
+    msgpack::packer<std::stringstream> packer(ss);
+
+    packer.pack_ext(size, 77);
+    msgpack::object_handle oh =
+        msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(size, oh.get().via.ext.size);
+    EXPECT_EQ(77, oh.get().via.ext.type());
+}
+
+TEST(MSGPACK_X3_PARSE, ext_255)
+{
+    std::size_t const size = 255;
+    std::stringstream ss;
+    msgpack::packer<std::stringstream> packer(ss);
+    char buf[size];
+    for (std::size_t i = 0; i != size; ++i) buf[i] = static_cast<char>(i);
+    packer.pack_ext(sizeof(buf), 77);
+    packer.pack_ext_body(buf, sizeof(buf));
+
+    msgpack::object_handle oh =
+        msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(size, oh.get().via.ext.size);
+    EXPECT_EQ(77, oh.get().via.ext.type());
+    EXPECT_TRUE(
+        std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
+}
+
+TEST(MSGPACK_X3_PARSE, ext_256)
+{
+    std::size_t const size = 256;
+    std::stringstream ss;
+    msgpack::packer<std::stringstream> packer(ss);
+    char buf[size];
+    for (std::size_t i = 0; i != size; ++i) buf[i] = static_cast<char>(i);
+    packer.pack_ext(sizeof(buf), 77);
+    packer.pack_ext_body(buf, sizeof(buf));
+
+    msgpack::object_handle oh =
+        msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(size, oh.get().via.ext.size);
+    EXPECT_EQ(77, oh.get().via.ext.type());
+    EXPECT_TRUE(
+        std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
+}
+
+TEST(MSGPACK_X3_PARSE, ext_65535)
+{
+    std::size_t const size = 65535;
+    std::stringstream ss;
+    msgpack::packer<std::stringstream> packer(ss);
+    char buf[size];
+    for (std::size_t i = 0; i != size; ++i) buf[i] = static_cast<char>(i);
+    packer.pack_ext(sizeof(buf), 77);
+    packer.pack_ext_body(buf, sizeof(buf));
+
+    msgpack::object_handle oh =
+        msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(size, oh.get().via.ext.size);
+    EXPECT_EQ(77, oh.get().via.ext.type());
+    EXPECT_TRUE(
+        std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
+}
+
+TEST(MSGPACK_X3_PARSE, ext_65536)
+{
+    std::size_t const size = 65536;
+    std::stringstream ss;
+    msgpack::packer<std::stringstream> packer(ss);
+    char buf[size];
+    for (std::size_t i = 0; i != size; ++i) buf[i] = static_cast<char>(i);
+    packer.pack_ext(sizeof(buf), 77);
+    packer.pack_ext_body(buf, sizeof(buf));
+
+    msgpack::object_handle oh =
+        msgpack::unpack(ss.str().begin(), ss.str().end());
+    EXPECT_EQ(size, oh.get().via.ext.size);
+    EXPECT_EQ(77, oh.get().via.ext.type());
+    EXPECT_TRUE(
+        std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
+}
+
+TEST(MSGPACK_X3_PARSE, unpack_referenced_1)
+{
+    std::string v = "ABC";
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    bool r;
+    msgpack::object_handle oh =
+        msgpack::unpack(ss.str().begin(), ss.str().end(), r);
+    EXPECT_FALSE(r);
+    EXPECT_EQ(v, oh.get().as<std::string>());
+}
+
+TEST(MSGPACK_X3_PARSE, unpack_referenced_2)
+{
+    std::string v = "ABC";
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    // copy is required because ss.str() returns temporary object.
+    std::string str = ss.str();
+    bool r;
+    msgpack::object_handle oh =
+        msgpack::unpack(
+            str.begin(),
+            str.end(),
+            r,
+            [](msgpack::type::object_type, std::size_t, void*) {
+                return true;
+            }
+        );
+    EXPECT_TRUE(r);
+    EXPECT_EQ(v, oh.get().as<std::string>());
+}
+
+TEST(MSGPACK_X3_PARSE, unpack_zone_1)
+{
+    std::string v = "ABC";
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    msgpack::zone z;
+    msgpack::object obj =
+        msgpack::unpack(z, ss.str().begin(), ss.str().end());
+    EXPECT_EQ(v, obj.as<std::string>());
+}
+
+TEST(MSGPACK_X3_PARSE, unpack_zone_2)
+{
+    std::string v = "ABC";
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    msgpack::zone z;
+    bool r;
+    msgpack::object obj =
+        msgpack::unpack(z, ss.str().begin(), ss.str().end(), r);
+    EXPECT_EQ(v, obj.as<std::string>());
+
+    EXPECT_FALSE(r);
+    EXPECT_EQ(v, obj.as<std::string>());
+}
+
+TEST(MSGPACK_X3_PARSE, unpack_zone_3)
+{
+    std::string v = "ABC";
+    std::stringstream ss;
+    msgpack::pack(ss, v);
+
+    // copy is required because ss.str() returns temporary object.
+    std::string str = ss.str();
+    msgpack::zone z;
+    bool r;
+    msgpack::object obj =
+        msgpack::unpack(
+            z,
+            str.begin(),
+            str.end(),
+            r,
+            [](msgpack::type::object_type, std::size_t, void*) {
+                return true;
+            }
+        );
+    EXPECT_TRUE(r);
+    EXPECT_EQ(v, obj.as<std::string>());
+}
+
+#endif // defined(MSGPACK_USE_X3_PARSE)

test/object.cpp

@@ -277,12 +277,17 @@ TEST(object, construct_primitive)
     EXPECT_EQ(msgpack::type::NEGATIVE_INTEGER, obj_int.type);
     EXPECT_EQ(-1, obj_int.via.i64);
 
-    msgpack::object obj_float(1.2);
-    EXPECT_EQ(msgpack::type::FLOAT, obj_float.type);
-    EXPECT_EQ(1.2, obj_float.via.f64);
+    msgpack::object obj_float(1.2F);
+    EXPECT_EQ(msgpack::type::FLOAT32, obj_float.type);
+    EXPECT_EQ(1.2F, obj_float.via.f64);
+
+    msgpack::object obj_double(1.2);
+    EXPECT_EQ(msgpack::type::FLOAT64, obj_double.type);
+    EXPECT_EQ(msgpack::type::FLOAT, obj_double.type);
+    EXPECT_EQ(1.2, obj_double.via.f64);
 #if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
-    EXPECT_EQ(msgpack::type::DOUBLE, obj_float.type);
-    EXPECT_EQ(1.2, obj_float.via.dec);
+    EXPECT_EQ(msgpack::type::DOUBLE, obj_double.type);
+    EXPECT_EQ(1.2, obj_double.via.dec);
 #endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT
 
     msgpack::object obj_bool(true);
@@ -418,3 +423,25 @@ TEST(object, clone_map)
     EXPECT_EQ(h.get(), obj);
     EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
 }
+
+TEST(object, pack_float)
+{
+    msgpack::object obj(1.2F);
+    std::stringstream ss1;
+    msgpack::pack(ss1, obj);
+    std::stringstream ss2;
+    msgpack::pack(ss2, 1.2F);
+    EXPECT_EQ(static_cast<size_t>(5), ss1.str().size());
+    EXPECT_EQ(ss1.str(), ss2.str());
+}
+
+TEST(object, pack_double)
+{
+    msgpack::object obj(1.2);
+    std::stringstream ss1;
+    msgpack::pack(ss1, obj);
+    std::stringstream ss2;
+    msgpack::pack(ss2, 1.2);
+    EXPECT_EQ(static_cast<size_t>(9), ss1.str().size());
+    EXPECT_EQ(ss1.str(), ss2.str());
+}

test/object_with_zone.cpp

@@ -176,6 +176,7 @@ TEST(object_with_zone, float)
     float v = 1.23f;
     msgpack::zone z;
     msgpack::object obj(v, z);
+    EXPECT_EQ(obj.type, msgpack::type::FLOAT32);
     EXPECT_TRUE(fabs(obj.as<float>() - v) <= kEPS);
     v = 4.56f;
     EXPECT_TRUE(fabs(obj.as<float>() - static_cast<float>(1.23)) <= kEPS);
@@ -187,6 +188,7 @@ TEST(object_with_zone, double)
     double v = 1.23;
     msgpack::zone z;
     msgpack::object obj(v, z);
+    EXPECT_EQ(obj.type, msgpack::type::FLOAT64);
     EXPECT_TRUE(fabs(obj.as<double>() - v) <= kEPS);
     v = 4.56;
     EXPECT_TRUE(fabs(obj.as<double>() - 1.23) <= kEPS);
@@ -749,7 +751,14 @@ TEST(object_with_zone, user_defined_non_virtual)
 
     msgpack::zone z;
     msgpack::object obj(b, z);
+#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__)
     bottom br = obj.as<bottom>();
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#pragma GCC diagnostic pop
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
     EXPECT_EQ(b.b, br.b);
     EXPECT_EQ(b.m1, br.m1);
     EXPECT_EQ(b.m2, br.m2);
@@ -787,7 +796,14 @@ TEST(object_with_zone, user_defined_virtual)
 
     msgpack::zone z;
     msgpack::object obj(b, z);
+#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__)
     v_bottom br = obj.as<v_bottom>();
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#pragma GCC diagnostic pop
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
     EXPECT_EQ(b.b, br.b);
     EXPECT_EQ(b.m1, br.m1);
     EXPECT_EQ(b.m2, br.m2);

test/pack_unpack.cpp

@@ -79,7 +79,7 @@ TEST(unpack, int_ret_no_offset_ref)
 
     msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
     EXPECT_EQ(1, oh.get().as<int>());
-    EXPECT_EQ(false, referenced);
+    EXPECT_FALSE(referenced);
 }
 
 TEST(unpack, int_ret_offset_ref)
@@ -91,7 +91,7 @@ TEST(unpack, int_ret_offset_ref)
 
     msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), off, referenced);
     EXPECT_EQ(1, oh.get().as<int>());
-    EXPECT_EQ(false, referenced);
+    EXPECT_FALSE(referenced);
     EXPECT_EQ(off, sbuf.size());
 }
 
@@ -128,7 +128,7 @@ TEST(unpack, int_no_offset_ref)
 
     msgpack::unpack(oh, sbuf.data(), sbuf.size(), referenced);
     EXPECT_EQ(1, oh.get().as<int>());
-    EXPECT_EQ(false, referenced);
+    EXPECT_FALSE(referenced);
 }
 
 TEST(unpack, int_offset_ref)
@@ -141,7 +141,7 @@ TEST(unpack, int_offset_ref)
 
     msgpack::unpack(oh, sbuf.data(), sbuf.size(), off, referenced);
     EXPECT_EQ(1, oh.get().as<int>());
-    EXPECT_EQ(false, referenced);
+    EXPECT_FALSE(referenced);
     EXPECT_EQ(off, sbuf.size());
 }
 
@@ -156,7 +156,14 @@ TEST(unpack, int_pointer_off_no_ref)
     std::size_t off = 0;
 
     // obsolete
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
     msgpack::unpack(&oh, sbuf.data(), sbuf.size(), &off);
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
+#pragma GCC diagnostic pop
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
     EXPECT_EQ(1, oh.get().as<int>());
     EXPECT_EQ(off, sbuf.size());
 }
@@ -170,7 +177,14 @@ TEST(unpack, int_pointer_off_no_ref_explicit)
     std::size_t off = 0;
 
     // obsolete
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
     msgpack::unpack(&oh, sbuf.data(), sbuf.size(), &off, MSGPACK_NULLPTR);
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
+#pragma GCC diagnostic pop
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
     EXPECT_EQ(1, oh.get().as<int>());
     EXPECT_EQ(off, sbuf.size());
 }
@@ -183,9 +197,16 @@ TEST(unpack, int_pointer_no_off_ref)
     bool referenced;
 
     // obsolete
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
     msgpack::unpack(&oh, sbuf.data(), sbuf.size(), MSGPACK_NULLPTR, &referenced);
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
+#pragma GCC diagnostic pop
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
     EXPECT_EQ(1, oh.get().as<int>());
-    EXPECT_EQ(false, referenced);
+    EXPECT_FALSE(referenced);
 }
 
 TEST(unpack, int_pointer_off_ref)
@@ -197,10 +218,17 @@ TEST(unpack, int_pointer_off_ref)
     std::size_t off = 0;
 
     // obsolete
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
     msgpack::unpack(&oh, sbuf.data(), sbuf.size(), &off, &referenced);
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
+#pragma GCC diagnostic pop
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
     EXPECT_EQ(1, oh.get().as<int>());
     EXPECT_EQ(off, sbuf.size());
-    EXPECT_EQ(false, referenced);
+    EXPECT_FALSE(referenced);
 }
 
 
@@ -211,7 +239,14 @@ TEST(unpack, int_default_null_pointer)
     msgpack::object_handle oh;
 
     // obsolete
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
     msgpack::unpack(&oh, sbuf.data(), sbuf.size());
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
+#pragma GCC diagnostic pop
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
     EXPECT_EQ(1, oh.get().as<int>());
 }
 
@@ -249,7 +284,7 @@ TEST(unpack, int_zone_no_offset_ref)
     msgpack::zone z;
     msgpack::object obj = msgpack::unpack(z, sbuf.data(), sbuf.size(), referenced);
     EXPECT_EQ(1, obj.as<int>());
-    EXPECT_EQ(false, referenced);
+    EXPECT_FALSE(referenced);
 }
 
 TEST(unpack, int_zone_offset_ref)
@@ -262,7 +297,7 @@ TEST(unpack, int_zone_offset_ref)
     msgpack::zone z;
     msgpack::object obj = msgpack::unpack(z, sbuf.data(), sbuf.size(), off, referenced);
     EXPECT_EQ(1, obj.as<int>());
-    EXPECT_EQ(false, referenced);
+    EXPECT_FALSE(referenced);
     EXPECT_EQ(off, sbuf.size());
 }
 

test/reference.cpp

@@ -5,7 +5,7 @@ TEST(reference, unpack_int)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
-    bool referenced;
+    bool referenced = false;
 
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
@@ -16,7 +16,7 @@ TEST(reference, unpack_string)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, std::string("abcdefg"));
-    bool referenced;
+    bool referenced = false;
 
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
@@ -31,7 +31,7 @@ TEST(reference, unpack_bin)
     packer.pack_bin(sizeof(c));
     packer.pack_bin_body(c, sizeof(c));
 
-    bool referenced;
+    bool referenced = false;
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
     EXPECT_FALSE(referenced);
@@ -45,7 +45,7 @@ TEST(reference, unpack_ext)
 
     packer.pack_ext(sizeof(buf), 1);
     packer.pack_ext_body(buf, sizeof(buf));
-    bool referenced;
+    bool referenced = false;
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
     EXPECT_FALSE(referenced);
@@ -66,7 +66,7 @@ TEST(reference, unpack_int_ref)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
-    bool referenced;
+    bool referenced = false;
 
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size(), referenced, never_called);
@@ -77,7 +77,7 @@ TEST(reference, unpack_string_ref)
 {
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, std::string("abcdefg"));
-    bool referenced;
+    bool referenced = false;
 
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size(), referenced, always_reference);
@@ -92,7 +92,7 @@ TEST(reference, unpack_bin_ref)
     packer.pack_bin(sizeof(c));
     packer.pack_bin_body(c, sizeof(c));
 
-    bool referenced;
+    bool referenced = false;
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size(), referenced, always_reference);
     EXPECT_TRUE(referenced);
@@ -106,7 +106,7 @@ TEST(reference, unpack_ext_ref)
 
     packer.pack_ext(sizeof(buf), 1);
     packer.pack_ext_body(buf, sizeof(buf));
-    bool referenced;
+    bool referenced = false;
 
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size(), referenced, always_reference);
@@ -139,7 +139,7 @@ TEST(reference, unpack_int_sized_ref)
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
 
-    bool referenced;
+    bool referenced = false;
     s_p = MSGPACK_NULLPTR;
 
     msgpack::object_handle oh =
@@ -153,7 +153,7 @@ TEST(reference, unpack_string_sized_ref_4)
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, std::string("1234"));
 
-    bool referenced;
+    bool referenced = false;
     s_p = MSGPACK_NULLPTR;
     // the last argument sbuf is any pointer as a user data.
     // That is stored to s_p in sized_reference
@@ -169,7 +169,7 @@ TEST(reference, unpack_string_sized_ref_5)
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, std::string("12345"));
 
-    bool referenced;
+    bool referenced = false;
     s_p = MSGPACK_NULLPTR;
 
     msgpack::object_handle oh =
@@ -187,7 +187,7 @@ TEST(reference, unpack_bin_sized_ref_5)
     packer.pack_bin(sizeof(c));
     packer.pack_bin_body(c, sizeof(c));
 
-    bool referenced;
+    bool referenced = false;
     s_p = MSGPACK_NULLPTR;
 
     msgpack::object_handle oh =
@@ -204,7 +204,7 @@ TEST(reference, unpack_bin_sized_ref_6)
     packer.pack_bin(sizeof(c));
     packer.pack_bin_body(c, sizeof(c));
 
-    bool referenced;
+    bool referenced = false;
     s_p = MSGPACK_NULLPTR;
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
@@ -221,7 +221,7 @@ TEST(reference, unpack_ext_sized_ref_6)
     packer.pack_ext(sizeof(buf), 1); // 5 + 1(type) = 6
     packer.pack_ext_body(buf, sizeof(buf));
 
-    bool referenced;
+    bool referenced = false;
     s_p = MSGPACK_NULLPTR;
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
@@ -238,7 +238,7 @@ TEST(reference, unpack_ext_sized_ref_7)
     packer.pack_ext(sizeof(buf), 1); // 6 + 1(type) = 7
     packer.pack_ext_body(buf, sizeof(buf));
 
-    bool referenced;
+    bool referenced = false;
     s_p = MSGPACK_NULLPTR;
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
@@ -256,7 +256,7 @@ TEST(reference, unpacker_int)
 
     msgpack::unpacker unp;
     msgpack::object_handle oh;
-    bool referenced;
+    bool referenced = false;
     unp.reserve_buffer(sbuf.size());
     std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
     unp.buffer_consumed(sbuf.size());
@@ -272,7 +272,7 @@ TEST(reference, unpacker_string)
 
     msgpack::unpacker unp;
     msgpack::object_handle oh;
-    bool referenced;
+    bool referenced = false;
     unp.reserve_buffer(sbuf.size());
     std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
     unp.buffer_consumed(sbuf.size());
@@ -291,7 +291,7 @@ TEST(reference, unpacker_bin)
 
     msgpack::unpacker unp;
     msgpack::object_handle oh;
-    bool referenced;
+    bool referenced = false;
     unp.reserve_buffer(sbuf.size());
     std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
     unp.buffer_consumed(sbuf.size());
@@ -311,7 +311,7 @@ TEST(reference, unpacker_ext)
 
     msgpack::unpacker unp;
     msgpack::object_handle oh;
-    bool referenced;
+    bool referenced = false;
     unp.reserve_buffer(sbuf.size());
     std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
     unp.buffer_consumed(sbuf.size());
@@ -329,7 +329,7 @@ TEST(reference, unpacker_int_sized_ref)
 
     msgpack::unpacker unp(never_called, &sbuf);
     msgpack::object_handle oh;
-    bool referenced;
+    bool referenced = false;
     unp.reserve_buffer(sbuf.size());
     std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
     unp.buffer_consumed(sbuf.size());
@@ -347,7 +347,7 @@ TEST(reference, unpacker_string_sized_ref_4)
 
     msgpack::unpacker unp(sized_reference, &sbuf);
     msgpack::object_handle oh;
-    bool referenced;
+    bool referenced = false;
     unp.reserve_buffer(sbuf.size());
     std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
     unp.buffer_consumed(sbuf.size());
@@ -365,7 +365,7 @@ TEST(reference, unpacker_string_sized_ref_5)
 
     msgpack::unpacker unp(sized_reference, &sbuf);
     msgpack::object_handle oh;
-    bool referenced;
+    bool referenced = false;
     unp.reserve_buffer(sbuf.size());
     std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
     unp.buffer_consumed(sbuf.size());
@@ -387,7 +387,7 @@ TEST(reference, unpacker_bin_sized_ref_5)
 
     msgpack::unpacker unp(sized_reference, &sbuf);
     msgpack::object_handle oh;
-    bool referenced;
+    bool referenced = false;
     unp.reserve_buffer(sbuf.size());
     std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
     unp.buffer_consumed(sbuf.size());
@@ -408,7 +408,7 @@ TEST(reference, unpacker_bin_sized_ref_6)
 
     msgpack::unpacker unp(sized_reference, &sbuf);
     msgpack::object_handle oh;
-    bool referenced;
+    bool referenced = false;
     unp.reserve_buffer(sbuf.size());
     std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
     unp.buffer_consumed(sbuf.size());
@@ -430,7 +430,7 @@ TEST(reference, unpacker_ext_sized_ref_6)
 
     msgpack::unpacker unp(sized_reference, &sbuf);
     msgpack::object_handle oh;
-    bool referenced;
+    bool referenced = false;
     unp.reserve_buffer(sbuf.size());
     std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
     unp.buffer_consumed(sbuf.size());
@@ -452,7 +452,7 @@ TEST(reference, unpacker_ext_sized_ref_7)
 
     msgpack::unpacker unp(sized_reference, &sbuf);
     msgpack::object_handle oh;
-    bool referenced;
+    bool referenced = false;
     unp.reserve_buffer(sbuf.size());
     std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
     unp.buffer_consumed(sbuf.size());

test/reference_wrapper_cpp11.cpp

@@ -42,7 +42,7 @@ TEST(MSGPACK_REFERENCE_WRAPPER, pack_vector)
     msgpack::pack(ss, val1);
     msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
     std::vector<int> val2 = oh.get().as<std::vector<int>>();
-    EXPECT_EQ(val2.size(), 1);
+    EXPECT_EQ(val2.size(), static_cast<size_t>(1));
     EXPECT_EQ(val1[0], val2[0]);
 }
 

test/streaming.cpp

@@ -78,7 +78,14 @@ TEST(streaming, basic_pointer)
 
         pac.buffer_consumed(len);
 
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
         while(pac.next(&oh)) {
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
+#pragma GCC diagnostic pop
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
             msgpack::object obj = oh.get();
             switch(count++) {
             case 0:

test/streaming_c.cpp

@@ -120,3 +120,64 @@ TEST(streaming, basic)
     msgpack_unpacked_destroy(&result);
     msgpack_sbuffer_free(buffer);
 }
+
+TEST(streaming, basic_with_size)
+{
+    int ret;
+    size_t bytes;
+    size_t parsed = 0;
+    msgpack_sbuffer* buffer = msgpack_sbuffer_new();
+    msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write);
+    msgpack_unpacked result;
+    msgpack_unpacker *unp;
+
+    // 1, 2, 3, "str", ["str_data"], "bin", ["bin_data"], {0.3: 0.4}
+    msgpack_pack_int(pk, 1);
+    msgpack_pack_int(pk, 2);
+    msgpack_pack_int(pk, 3);
+    msgpack_pack_str(pk, 3);
+    msgpack_pack_str_body(pk, "str", 3);
+    msgpack_pack_array(pk, 1);
+    msgpack_pack_str(pk, 8);
+    msgpack_pack_str_body(pk, "str_data", 8);
+    msgpack_pack_bin(pk, 3);
+    msgpack_pack_bin_body(pk, "bin", 3);
+    msgpack_pack_array(pk, 1);
+    msgpack_pack_bin(pk, 8);
+    msgpack_pack_bin_body(pk, "bin_data", 8);
+    msgpack_pack_map(pk, 1);
+    msgpack_pack_float(pk, 0.4f);
+    msgpack_pack_double(pk, 0.8);
+    msgpack_packer_free(pk);
+
+    unp = msgpack_unpacker_new(32 * 1024);
+    msgpack_unpacked_init(&result);
+
+    const char* input = buffer->data;
+
+    while (parsed < buffer->size) {
+        memcpy(msgpack_unpacker_buffer(unp), input, 1);
+        msgpack_unpacker_buffer_consumed(unp, 1);
+        input += 1;
+
+        bytes = 0;
+        ret = msgpack_unpacker_next_with_size(unp, &result, &bytes);
+        if (ret == MSGPACK_UNPACK_CONTINUE) {
+            EXPECT_GT(bytes, static_cast<size_t>(0));
+            continue;
+        }
+
+        while (ret == MSGPACK_UNPACK_SUCCESS) {
+            EXPECT_GT(bytes, static_cast<size_t>(0));
+            parsed += bytes;
+            ret = msgpack_unpacker_next_with_size(unp, &result, &bytes);
+        }
+
+    }
+
+    EXPECT_EQ(parsed, buffer->size);
+
+    msgpack_unpacked_destroy(&result);
+    msgpack_unpacker_free(unp);
+    msgpack_sbuffer_free(buffer);
+}

test/user_class.cpp

@@ -148,26 +148,30 @@ public:
 
     void msgpack_unpack(msgpack::object o)
     {
-        msgpack::type::tuple<bool, msgpack::object> tuple;
-        o.convert(tuple);
-
 #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__)
+        msgpack::type::tuple<bool, msgpack::object> tuple;
+        o.convert(tuple);
+
         is_double = tuple.get<0>();
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
-#pragma GCC diagnostic pop
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
         if (is_double)
             tuple.get<1>().convert(value.f);
         else
             tuple.get<1>().convert(value.i);
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#pragma GCC diagnostic pop
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
     }
 };
 
 TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
 {
+#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__)
     {
         // double
         TestUnionMemberClass val1(1.0);
@@ -191,6 +195,9 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
         EXPECT_EQ(val1.value.i, 1);
         EXPECT_EQ(val1.value.i, val2.value.i);
     }
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#pragma GCC diagnostic pop
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
 }
 
 // inheritance
@@ -389,7 +396,14 @@ TEST(MSGPACK_INHERIT, define_map_non_virtual)
     msgpack::pack(sbuf, b);
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
+#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__)
     dm_bottom br = oh.get().as<dm_bottom>();
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#pragma GCC diagnostic pop
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
     EXPECT_EQ(b.b, br.b);
     EXPECT_EQ(b.m1, br.m1);
     EXPECT_EQ(b.m2, br.m2);
@@ -530,3 +544,60 @@ TEST(MSGPACK_USER_DEFINED, test_non_intrusive)
 
     EXPECT_EQ(t1.name(), t2.name());
 }
+
+struct nvp_base {
+    int a;
+    int b;
+    MSGPACK_DEFINE_MAP(MSGPACK_NVP("aaa", a), b);
+};
+
+struct nvp_derived : nvp_base {
+    int c;
+    std::string d;
+    MSGPACK_DEFINE_MAP(MSGPACK_NVP("ccc", c), MSGPACK_NVP("base", MSGPACK_BASE(nvp_base)), MSGPACK_NVP("ddd", d));
+};
+
+TEST(MSGPACK_NVP, combination)
+{
+    msgpack::sbuffer sbuf;
+    nvp_derived d1;
+    d1.a = 1;
+    d1.b = 2;
+    d1.c = 3;
+    d1.d = "ABC";
+
+    msgpack::pack(sbuf, d1);
+    msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size());
+    msgpack::object obj = oh.get();
+
+    EXPECT_EQ(obj.via.map.size, static_cast<size_t>(3));
+
+    EXPECT_EQ(std::string(obj.via.map.ptr[0].key.via.str.ptr, obj.via.map.ptr[0].key.via.str.size), "ccc");
+    EXPECT_EQ(obj.via.map.ptr[0].val.via.i64, 3);
+
+    EXPECT_EQ(std::string(obj.via.map.ptr[1].key.via.str.ptr, obj.via.map.ptr[1].key.via.str.size), "base");
+    EXPECT_EQ(obj.via.map.ptr[1].val.via.map.size, static_cast<size_t>(2));
+    EXPECT_EQ(
+        std::string(
+            obj.via.map.ptr[1].val.via.map.ptr[0].key.via.str.ptr,
+            obj.via.map.ptr[1].val.via.map.ptr[0].key.via.str.size),
+        "aaa"
+    );
+    EXPECT_EQ(obj.via.map.ptr[1].val.via.map.ptr[0].val.via.i64, 1);
+    EXPECT_EQ(
+        std::string(
+            obj.via.map.ptr[1].val.via.map.ptr[1].key.via.str.ptr,
+            obj.via.map.ptr[1].val.via.map.ptr[1].key.via.str.size),
+        "b"
+    );
+    EXPECT_EQ(obj.via.map.ptr[1].val.via.map.ptr[1].val.via.i64, 2);
+
+    EXPECT_EQ(std::string(obj.via.map.ptr[2].key.via.str.ptr, obj.via.map.ptr[2].key.via.str.size), "ddd");
+    EXPECT_EQ(std::string(obj.via.map.ptr[2].val.via.str.ptr, obj.via.map.ptr[2].val.via.str.size), "ABC");
+
+    nvp_derived d2 = obj.as<nvp_derived>();
+    EXPECT_EQ(d2.a, 1);
+    EXPECT_EQ(d2.b, 2);
+    EXPECT_EQ(d2.c, 3);
+    EXPECT_EQ(d2.d, "ABC");
+}

test/visitor.cpp

@@ -99,8 +99,8 @@ TEST(visitor, json_like)
 struct parse_error_check_visitor : msgpack::v2::null_visitor {
     parse_error_check_visitor(bool& called):m_called(called) {}
     void parse_error(size_t parsed_offset, size_t error_offset) {
-        EXPECT_EQ(1, parsed_offset);
-        EXPECT_EQ(2, error_offset);
+        EXPECT_EQ(static_cast<size_t>(1), parsed_offset);
+        EXPECT_EQ(static_cast<size_t>(2), error_offset);
         m_called = true;
     }
     bool& m_called;
@@ -120,8 +120,8 @@ TEST(visitor, parse_error)
 struct insuf_bytes_check_visitor : msgpack::v2::null_visitor {
     insuf_bytes_check_visitor(bool& called):m_called(called) {}
     void insufficient_bytes(size_t parsed_offset, size_t error_offset) {
-        EXPECT_EQ(2, parsed_offset);
-        EXPECT_EQ(3, error_offset);
+        EXPECT_EQ(static_cast<size_t>(2), parsed_offset);
+        EXPECT_EQ(static_cast<size_t>(3), error_offset);
         m_called = true;
     }
     bool& m_called;