Merge pull request #555 from redboltz/ver2.1.0

Updated the version to 2.1.0.

.travis.yml

@@ -1,91 +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_autotools.sh" VERSION="cpp03" ARCH="64" LIBPATH="/usr/local/lib"   BOOST="boost" BOOST_INC="/usr/local/boost" CHAR_SIGN="unsigned"
-  - ACTION="ci/build_autotools.sh" VERSION="cpp03" ARCH="32" LIBPATH="/usr/local/lib32" BOOST=""      BOOST_INC=""                 CHAR_SIGN="signed"
-  - ACTION="ci/build_cmake.sh"     VERSION="cpp11" ARCH="64" LIBPATH="/usr/local/lib"   BOOST="boost" BOOST_INC="/usr/local/boost" CHAR_SIGN="signed"
-  - ACTION="ci/build_cmake.sh"     VERSION="cpp11" ARCH="32" LIBPATH="/usr/local/lib32" BOOST=""      BOOST_INC=""                 SHARED="OFF" CHAR_SIGN="unsigned"
-  - ACTION="ci/build_autotools.sh" VERSION="cpp11" ARCH="64" LIBPATH="/usr/local/lib"   BOOST=""      BOOST_INC=""                 CHAR_SIGN="signed"
-  - ACTION="ci/build_autotools.sh" VERSION="cpp11" ARCH="32" LIBPATH="/usr/local/lib32" BOOST="boost" BOOST_INC="/usr/local/boost" CHAR_SIGN="unsigned"
-  - ACTION="ci/build_cmake.sh"     VERSION="cpp03" ARCH="64" LIBPATH="/usr/local/lib"   BOOST=""      BOOST_INC=""                 CHAR_SIGN="unsigned"
-  - ACTION="ci/build_cmake.sh"     VERSION="cpp03" ARCH="32" LIBPATH="/usr/local/lib32" BOOST="boost" BOOST_INC="/usr/local/boost" SHARED="OFF" CHAR_SIGN="signed"
-
-before_script:
- - export PATH=/usr/local/bin:$PATH && rm -rf install
+ - 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_autotools.sh" VERSION="cpp03" ARCH="32" LIBPATH="/usr/local/lib32" BOOST=""      BOOST_INC=""                 CHAR_SIGN="signed"
+      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="cpp11" ARCH="32" LIBPATH="/usr/local/lib32" BOOST=""      BOOST_INC=""                 SHARED="OFF" CHAR_SIGN="unsigned"
+      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_autotools.sh" VERSION="cpp11" ARCH="32" LIBPATH="/usr/local/lib32" BOOST="boost" BOOST_INC="/usr/local/boost" CHAR_SIGN="unsigned"
-    - os: osx
-      env: ACTION="ci/build_cmake.sh"     VERSION="cpp03" ARCH="32" LIBPATH="/usr/local/lib32" BOOST="boost" BOOST_INC="/usr/local/boost" SHARED="OFF" CHAR_SIGN="signed"
-
-    - os: linux
-      compiler: gcc
-      env: ACTION="ci/build_autotools.sh" VERSION="cpp03" ARCH="64" LIBPATH="/usr/local/lib"   BOOST="boost" BOOST_INC="/usr/local/boost" CHAR_SIGN="unsigned"
-    - os: linux
-      compiler: gcc
-      env: ACTION="ci/build_autotools.sh" VERSION="cpp03" ARCH="32" LIBPATH="/usr/local/lib32" BOOST=""      BOOST_INC=""                 CHAR_SIGN="signed"
-    - os: linux
-      compiler: gcc
-      env: ACTION="ci/build_cmake.sh"     VERSION="cpp11" ARCH="64" LIBPATH="/usr/local/lib"   BOOST="boost" BOOST_INC="/usr/local/boost" CHAR_SIGN="signed"
-    - os: linux
-      compiler: gcc
-      env: ACTION="ci/build_cmake.sh"     VERSION="cpp11" ARCH="32" LIBPATH="/usr/local/lib32" BOOST=""      BOOST_INC=""                 SHARED="OFF" CHAR_SIGN="unsigned"
-
+      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_autotools.sh" VERSION="cpp11" ARCH="64" LIBPATH="/usr/local/lib"   BOOST=""      BOOST_INC=""                 CHAR_SIGN="signed"
+      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_autotools.sh" VERSION="cpp11" ARCH="32" LIBPATH="/usr/local/lib32" BOOST="boost" BOOST_INC="/usr/local/boost" CHAR_SIGN="unsigned"
+      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="cpp03" ARCH="64" LIBPATH="/usr/local/lib"   BOOST=""      BOOST_INC=""                 CHAR_SIGN="unsigned"
+      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="32" LIBPATH="/usr/local/lib32" BOOST="boost" BOOST_INC="/usr/local/boost" SHARED="OFF" CHAR_SIGN="signed"
+      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: 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: 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,71 @@
+# 2017-01-10 version 2.1.0
+
+## << breaking changes >>
+
+  * Fix object internal data type is float if msgpack format is float32 (#531)
+
+## << recommended changes >>
+
+  * Add `FLOAT64` type. Please use it instead of `DOUBLE` (#531)
+  * Add `FLOAT32` type. Please use it instead of `FLOAT` (#531)
+
+## << other updates >>
+
+  * Add iterator based parse/unpack function(experimental) (#553)
+  * Add `[[deprecated]]` attribute for C++14 (#552)
+  * Fix `msgpack_unpack()` return code (#548)
+  * Fix integer overflow (#547, #549, #550)
+  * Add example codes (#542)
+  * Add MSGPACK_NVP. You can use not only variable name but also any strings (#535)
+  * Fix and Improve build system (#532, #545)
+  * Fix `gcc_atomic.hpp` include path (#529, #530)
+  * Improve CI environment (#526)
+  * Improve documents (#524)
+  * Add msgpack_unpacker_next_with_size() function (#515)
+  * Fix `as()` applying condition (#511)
+  * Fix fbuffer write (#504)
+  * Add gcc bug workaround (#499)
+  * Improve object print (#497, #500, #505, #533)
+  * Remove some warnings (#495, #506, #508, #513, #528, #538, #545)
+
+# 2016-06-25 version 2.0.0
+
+## << breaking changes >>
+
+  * Removed autotools support. Use cmake instead (#476, #479)
+  * Removed pointer version of msgpack::unpack APIs. Use reference version instead (#453)
+  * Removed MSGPACK_DISABLE_LEGACY_CONVERT. msgpack::object::convert(T*) is removed by default. Use msgpack::object::convert(T&) instead (#451)
+  * Removed msgpacl::type::nil. Use nil_t or define MSGPACK_USE_LECACY_NIL (#444)
+  * Removed std::string to msgpack::object conversion (#434)
+
+## << recommended changes >>
+
+  * Replaced msgpack::unpacked with msgpack::object_handle. msgpack::unpacked is kept as a typedef of msgpack::object_handle. (#448)
+
+## << other updates >>
+
+  * Add strict size checking adaptor. Relaxed tuple conversion (#489)
+  * Fix and Improve example codes (#487)
+  * Add C++/CLI support for nullptr (#481)
+  * Update the boost libraries that are contained by msgpack-c (#475)
+  * Fix gcc_atomic.hpp location (#474)
+  * Add C-Style array support (#466, #488)
+  * Fix include file dependency (#464)
+  * Add a visitor version of unpack API (#461)
+  * Fix JSON string conversion from "nil" to "null" (#458)
+  * Fix and Improve build system (#455, #471, #473, #486, #491)
+  * Fix comments (#452)
+  * Fix unintentional msgpack::zone moving problem (#447)
+  * Fix operator>> and << for msgpack::object (#443)
+  * Fix C++03 msgpack::zone::clear() memory access violation bug (#441)
+  * Fix TARGET_OS_IPHONE checking (#436)
+  * Fix invalid front() call for empty container (#435)
+  * Fix compile error on g++6 (C++11 only) (#426, #430)
+  * Fix zone size expansion logic (#423)
+  * Fix wrong hader file dependency (#421)
+  * Fix msvc specific problem (#420)
+  * Add v2 API support (#415)
+
 # 2016-01-22 version 1.4.0
 
 ## << recommended changes >>

CMakeLists.txt

@@ -1,4 +1,10 @@
 CMAKE_MINIMUM_REQUIRED (VERSION 2.8.6)
+
+IF ((CMAKE_VERSION VERSION_GREATER 3.1) OR
+    (CMAKE_VERSION VERSION_EQUAL 3.1))
+    CMAKE_POLICY(SET CMP0054 NEW)
+ENDIF ()
+
 PROJECT (msgpack)
 
 FILE (READ ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/version_master.h contents)
@@ -15,15 +21,11 @@ SET (exec_prefix "\${prefix}")
 SET (libdir "\${exec_prefix}/lib")
 SET (includedir "\${prefix}/include")
 SET (GNUCXX_STD_SUPPORT_VERSION "4.3")
-SET (GNUCXX_NO_MISMATCHED_TAGS_SUPPORT_VERSION "4.4")
 
 OPTION (MSGPACK_CXX11 "Using c++11 compiler" OFF)
 OPTION (MSGPACK_32BIT "32bit compile" OFF)
 OPTION (MSGPACK_BOOST "Using boost libraries" OFF)
 
-SET (CMAKE_CXX_FLAGS "-DMSGPACK_DISABLE_LEGACY_NIL ${CMAKE_CXX_FLAGS}")
-SET (CMAKE_CXX_FLAGS "-DMSGPACK_DISABLE_LEGACY_CONVERT ${CMAKE_CXX_FLAGS}")
-
 IF (APPLE)
     SET(CMAKE_MACOSX_RPATH ON)
     SET(CMAKE_SKIP_BUILD_RPATH FALSE)
@@ -36,6 +38,18 @@ IF (APPLE)
     ENDIF ()
 ENDIF ()
 
+IF (MSGPACK_USE_X3_PARSE)
+   IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+      SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_X3_PARSE -std=c++14 ${CMAKE_CXX_FLAGS}")
+   ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+      SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_X3_PARSE -std=c++14 ${CMAKE_CXX_FLAGS}")
+   ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+      SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_X3_PARSE ${CMAKE_CXX_FLAGS}")
+      IF (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19)
+          MESSAGE ( FATAL_ERROR "MSVC doesn't support C++14.")
+      ENDIF ()
+   ENDIF ()
+ELSE ()
    IF (MSGPACK_CXX11)
       IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
          SET (CMAKE_CXX_FLAGS "-std=c++11 ${CMAKE_CXX_FLAGS}")
@@ -50,16 +64,17 @@ 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}")
+             SET (CMAKE_CXX_FLAGS "-std=c++98 ${CMAKE_CXX_FLAGS}")
          ENDIF ()
       ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-      SET (CMAKE_CXX_FLAGS "-std=c++03 ${CMAKE_CXX_FLAGS}")
+         SET (CMAKE_CXX_FLAGS "-std=c++98 ${CMAKE_CXX_FLAGS}")
       ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
          IF (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 18)
              SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_CPP03 ${CMAKE_CXX_FLAGS}")
          ENDIF ()
       ENDIF ()
    ENDIF ()
+ENDIF ()
 
 IF (MSGPACK_32BIT)
    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
@@ -73,12 +88,22 @@ 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}")
+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 timer system)
+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}
     )
@@ -89,6 +114,12 @@ IF (MSGPACK_CHAR_SIGN)
    SET (CMAKE_CXX_FLAGS "-f${MSGPACK_CHAR_SIGN}-char ${CMAKE_CXX_FLAGS}")
 ENDIF ()
 
+IF (MSGPACK_DEFAULT_API_VERSION)
+   SET (CMAKE_CXX_FLAGS "-DMSGPACK_DEFAULT_API_VERSION=${MSGPACK_DEFAULT_API_VERSION} ${CMAKE_CXX_FLAGS}")
+ELSE ()
+   SET (CMAKE_CXX_FLAGS "-DMSGPACK_DEFAULT_API_VERSION=2 ${CMAKE_CXX_FLAGS}")
+ENDIF ()
+
 FILE (GLOB_RECURSE PREDEF_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/external/boost/predef/include/boost ${CMAKE_CURRENT_SOURCE_DIR}/external/boost/predef/include/boost/*.h)
 FOREACH (F ${PREDEF_FILES})
    SET(M "Converting ${F}")
@@ -115,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)
@@ -132,113 +162,7 @@ int main(int argc, char * argv[])
 }
 " MSGPACK_ENABLE_GCC_CXX_ATOMIC)
 
-
-LIST (APPEND msgpackc_SOURCES
-    src/unpack.c
-    src/objectc.c
-    src/version.c
-    src/vrefbuffer.c
-    src/zone.c
-)
-
-LIST (APPEND msgpackc_HEADERS
-    include/msgpack/pack_define.h
-    include/msgpack/pack_template.h
-    include/msgpack/unpack_define.h
-    include/msgpack/unpack_template.h
-    include/msgpack/util.h
-    include/msgpack/sysdep.h
-    include/msgpack/gcc_atomic.h
-    include/msgpack.h
-    include/msgpack/sbuffer.h
-    include/msgpack/version.h
-    include/msgpack/version_master.h
-    include/msgpack/vrefbuffer.h
-    include/msgpack/zbuffer.h
-    include/msgpack/fbuffer.h
-    include/msgpack/pack.h
-    include/msgpack/unpack.h
-    include/msgpack/object.h
-    include/msgpack/zone.h
-)
-
-FILE (GLOB_RECURSE PREDEF_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/predef/*.h)
-
-LIST (APPEND msgpackc_HEADERS ${PREDEF_FILES})
-LIST (APPEND msgpackc_HEADERS include/msgpack/predef.h)
-
-IF (MSGPACK_ENABLE_CXX)
-    LIST (APPEND msgpack_HEADERS
-        include/msgpack.hpp
-        include/msgpack/adaptor/adaptor_base.hpp
-        include/msgpack/adaptor/array_ref.hpp
-        include/msgpack/adaptor/bool.hpp
-        include/msgpack/adaptor/boost/fusion.hpp
-        include/msgpack/adaptor/boost/msgpack_variant.hpp
-        include/msgpack/adaptor/boost/optional.hpp
-        include/msgpack/adaptor/boost/string_ref.hpp
-        include/msgpack/adaptor/char_ptr.hpp
-        include/msgpack/adaptor/check_container_size.hpp
-        include/msgpack/adaptor/cpp11/array.hpp
-        include/msgpack/adaptor/cpp11/array_char.hpp
-        include/msgpack/adaptor/cpp11/array_unsigned_char.hpp
-        include/msgpack/adaptor/cpp11/forward_list.hpp
-        include/msgpack/adaptor/cpp11/reference_wrapper.hpp
-        include/msgpack/adaptor/cpp11/shared_ptr.hpp
-        include/msgpack/adaptor/cpp11/tuple.hpp
-        include/msgpack/adaptor/cpp11/unique_ptr.hpp
-        include/msgpack/adaptor/cpp11/unordered_map.hpp
-        include/msgpack/adaptor/cpp11/unordered_set.hpp
-        include/msgpack/adaptor/define.hpp
-        include/msgpack/adaptor/deque.hpp
-        include/msgpack/adaptor/detail/cpp03_define_array.hpp
-        include/msgpack/adaptor/detail/cpp03_define_map.hpp
-        include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp
-        include/msgpack/adaptor/detail/cpp11_define_array.hpp
-        include/msgpack/adaptor/detail/cpp11_define_map.hpp
-        include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp
-        include/msgpack/adaptor/ext.hpp
-        include/msgpack/adaptor/fixint.hpp
-        include/msgpack/adaptor/float.hpp
-        include/msgpack/adaptor/int.hpp
-        include/msgpack/adaptor/list.hpp
-        include/msgpack/adaptor/map.hpp
-        include/msgpack/adaptor/msgpack_tuple.hpp
-        include/msgpack/adaptor/nil.hpp
-        include/msgpack/adaptor/pair.hpp
-        include/msgpack/adaptor/raw.hpp
-        include/msgpack/adaptor/v4raw.hpp
-        include/msgpack/adaptor/set.hpp
-        include/msgpack/adaptor/string.hpp
-        include/msgpack/adaptor/tr1/unordered_map.hpp
-        include/msgpack/adaptor/tr1/unordered_set.hpp
-        include/msgpack/adaptor/vector.hpp
-        include/msgpack/adaptor/vector_bool.hpp
-        include/msgpack/adaptor/vector_char.hpp
-        include/msgpack/adaptor/vector_unsigned_char.hpp
-        include/msgpack/cpp_config.hpp
-        include/msgpack/detail/cpp03_zone.hpp
-        include/msgpack/detail/cpp11_zone.hpp
-        include/msgpack/fbuffer.hpp
-        include/msgpack/iterator.hpp
-        include/msgpack/meta.hpp
-        include/msgpack/object.hpp
-        include/msgpack/object_fwd.hpp
-        include/msgpack/pack.hpp
-        include/msgpack/sbuffer.hpp
-        include/msgpack/type.hpp
-        include/msgpack/unpack.hpp
-        include/msgpack/version.hpp
-        include/msgpack/versioning.hpp
-        include/msgpack/vrefbuffer.hpp
-        include/msgpack/zbuffer.hpp
-        include/msgpack/zone.hpp
-    )
-    FILE (GLOB_RECURSE PREPROCESSOR_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/preprocessor/*.hpp)
-
-    LIST (APPEND msgpackc_HEADERS ${PREPROCESSOR_FILES})
-    LIST (APPEND msgpackc_HEADERS include/msgpack/preprocessor.hpp)
-ENDIF ()
+INCLUDE (Files.cmake)
 
 EXECUTE_PROCESS (
     COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/src/msgpack
@@ -270,7 +194,11 @@ ADD_LIBRARY (msgpackc-static STATIC
 
 SET_TARGET_PROPERTIES (msgpackc-static PROPERTIES OUTPUT_NAME "msgpackc")
 IF (MSGPACK_ENABLE_SHARED)
+    IF (MSVC)
         SET_TARGET_PROPERTIES (msgpackc PROPERTIES IMPORT_SUFFIX "_import.lib")
+    ELSEIF (MINGW)
+        SET_TARGET_PROPERTIES (msgpackc PROPERTIES IMPORT_SUFFIX ".dll.a")
+    ENDIF ()
     SET_TARGET_PROPERTIES (msgpackc PROPERTIES SOVERSION 2 VERSION 2.0.0)
 ENDIF ()
 
@@ -291,14 +219,10 @@ IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" ST
 ENDIF ()
 
 IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+    IF (MSGPACK_ENABLE_SHARED)
         SET_PROPERTY (TARGET msgpackc APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
     ENDIF ()
-
-IF ("${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 msgpackc APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
-    ENDIF ()
+    SET_PROPERTY (TARGET msgpackc-static APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
 ENDIF ()
 
 IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
@@ -313,6 +237,10 @@ IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC90" OR "${CMAKE_CXX_COMPILER_ID}" S
     SET_SOURCE_FILES_PROPERTIES(${msgpackc_SOURCES} PROPERTIES LANGUAGE CXX)
 ENDIF()
 
+IF (NOT DEFINED CMAKE_INSTALL_BINDIR)
+    SET(CMAKE_INSTALL_BINDIR bin)
+ENDIF ()
+
 IF (NOT DEFINED CMAKE_INSTALL_LIBDIR)
     SET(CMAKE_INSTALL_LIBDIR lib)
 ENDIF ()
@@ -327,7 +255,9 @@ ELSE()
     SET (MSGPACK_INSTALLTARGETS msgpackc-static)
 ENDIF ()
 
-INSTALL (TARGETS ${MSGPACK_INSTALLTARGETS} DESTINATION ${CMAKE_INSTALL_LIBDIR})
+INSTALL (TARGETS ${MSGPACK_INSTALLTARGETS} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+                                           LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+                                           ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
 INSTALL (DIRECTORY include DESTINATION ${CMAKE_INSTALL_PREFIX})
 IF (NOT MSVC)
     INSTALL (FILES ${CMAKE_CURRENT_BINARY_DIR}/msgpack.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)

Files.cmake

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

Makefile.am

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

QUICKSTART-CPP.md

@@ -31,11 +31,11 @@ int main(void) {
         msgpack::pack(sbuf, vec);
 
         // deserialize it.
-        msgpack::unpacked msg;
-        msgpack::unpack(&msg, sbuf.data(), sbuf.size());
+        msgpack::object_handle oh =
+            msgpack::unpack(sbuf.data(), sbuf.size());
 
         // print the deserialized object.
-        msgpack::object obj = msg.get();
+        msgpack::object obj = oh.get();
         std::cout << obj << std::endl;  //=> ["Hello", "MessagePack"]
 
         // convert it into statically typed object.
@@ -47,13 +47,11 @@ int main(void) {
 Compile it as follows:
 
 ```
-$ g++ -Ipath_to_msgpack/include -DMSGPACK_DISABLE_LEGACY_NIL -DMSGPACK_DISABLE_LEGACY_CONVERT hello.cc -o hello
+$ g++ -Ipath_to_msgpack/include hello.cc -o hello
 $ ./hello
 ["Hello", "MessagePack"]
 ```
 
-See [MSGPACK_DISABLE_LEGACY_NIL](https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_configure#msgpack_disable_legacy_nil-since-140) and [MSGPACK_DISABLE_LEGACY_CONVERT](https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_configure#msgpack_disable_legacy_convert-since-140).
-
 ## Streaming feature
 
 ```cpp
@@ -79,13 +77,13 @@ int main(void) {
         pac.buffer_consumed(buffer.size());
 
         // now starts streaming deserialization.
-        msgpack::unpacked result;
-        while(pac.next(&result)) {
-            std::cout << result.get() << std::endl;
+        msgpack::object_handle oh;
+        while(pac.next(&oh)) {
+            std::cout << oh.get() << std::endl;
         }
 
         // results:
-        // $ g++ -Ipath_to_msgpack/include -DMSGPACK_DISABLE_LEGACY_NIL -DMSGPACK_DISABLE_LEGACY_CONVERT stream.cc -o stream
+        // $ g++ -Ipath_to_msgpack/include stream.cc -o stream
         // $ ./stream
         // "Log message ... 1"
         // "Log message ... 2"
@@ -93,8 +91,6 @@ int main(void) {
 }
 ```
 
-See [MSGPACK_DISABLE_LEGACY_NIL](https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_configure#msgpack_disable_legacy_nil-since-140) and [MSGPACK_DISABLE_LEGACY_CONVERT](https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_configure#msgpack_disable_legacy_convert-since-140).
-
 ### Streaming into an array or map
 
 ```cpp
@@ -151,10 +147,10 @@ int main(void) {
         msgpack::sbuffer sbuf;
         msgpack::pack(sbuf, vec);
 
-        msgpack::unpacked msg;
-        msgpack::unpack(&msg, sbuf.data(), sbuf.size());
+        msgpack::object_handle oh =
+            msgpack::unpack(sbuf.data(), sbuf.size());
 
-        msgpack::object obj = msg.get();
+        msgpack::object obj = oh.get();
 
         // you can convert object to myclass directly
         std::vector<myclass> rvec;

README.md

@@ -1,7 +1,7 @@
 `msgpack` for C/C++
 ===================
 
-Version 1.4.0 [![Build Status](https://travis-ci.org/msgpack/msgpack-c.svg?branch=master)](https://travis-ci.org/msgpack/msgpack-c) [![Build status](https://ci.appveyor.com/api/projects/status/8kstcgt79qj123mw/branch/master?svg=true)](https://ci.appveyor.com/project/redboltz/msgpack-c/branch/master)
+Version 2.1.0 [![Build Status](https://travis-ci.org/msgpack/msgpack-c.svg?branch=master)](https://travis-ci.org/msgpack/msgpack-c) [![Build status](https://ci.appveyor.com/api/projects/status/8kstcgt79qj123mw/branch/master?svg=true)](https://ci.appveyor.com/project/redboltz/msgpack-c/branch/master)
 
 It's like JSON but small and fast.
 
@@ -83,12 +83,11 @@ int main(void)
     // deserialize the buffer into msgpack::object instance.
     std::string str(buffer.str());
 
-    msgpack::unpacked result;
+    msgpack::object_handle oh =
+        msgpack::unpack(str.data(), str.size());
 
-    msgpack::unpack(result, str.data(), str.size());
-
-    // deserialized object is valid during the msgpack::unpacked instance alive.
-    msgpack::object deserialized = result.get();
+    // deserialized object is valid during the msgpack::object_handle instance is alive.
+    msgpack::object deserialized = oh.get();
 
     // msgpack::object supports ostream.
     std::cout << deserialized << std::endl;
@@ -112,9 +111,7 @@ Usage
 When you use msgpack on C++03 and C++11, you can just add
 msgpack-c/include to your include path:
 
-    g++ -I msgpack-c/include -DMSGPACK_DISABLE_LEGACY_NIL -DMSGPACK_DISABLE_LEGACY_CONVERT your_source_file.cpp
-
-See [MSGPACK_DISABLE_LEGACY_NIL](https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_configure#msgpack_disable_legacy_nil-since-140) and [MSGPACK_DISABLE_LEGACY_CONVERT](https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_configure#msgpack_disable_legacy_convert-since-140).
+    g++ -I msgpack-c/include your_source_file.cpp
 
 If you want to use C version of msgpack, you need to build it. You can
 also install the C and C++ versions of msgpack.
@@ -123,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:
 
@@ -175,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,42 +1,54 @@
-version: 1.1.0.{build}
-before_build:
-- appveyor DownloadFile http://googletest.googlecode.com/files/gtest-1.7.0.zip -FileName gtest-1.7.0.zip
-- 7z x gtest-1.7.0.zip > NUL
-- cd gtest-1.7.0
+version: 2.1.0.{build}
+
+environment:
+  matrix:
+    - cpp11: -DMSGPACK_CXX11=OFF
+      boost: -DMSGPACK_BOOST=ON
+      msvc: '"Visual Studio 10 2010"'
+    - cpp11: -DMSGPACK_CXX11=OFF
+      boost: -DMSGPACK_BOOST=ON
+      msvc: '"Visual Studio 11 2012"'
+    - cpp11: -DMSGPACK_CXX11=OFF
+      boost: -DMSGPACK_BOOST=ON
+      msvc: '"Visual Studio 12 2013"'
+    - cpp11: -DMSGPACK_CXX11=ON
+      boost: -DMSGPACK_BOOST=ON
+      msvc: '"Visual Studio 14 2015"'
+    - cpp11: -DMSGPACK_CXX11=OFF
+      boost: -DMSGPACK_BOOST=ON
+      msvc: '"Visual Studio 14 2015"'
+    - cpp11: -DMSGPACK_CXX11=ON
+      boost: -DMSGPACK_BOOST=OFF
+      msvc: '"Visual Studio 14 2015"'
+    - cpp11: -DMSGPACK_CXX11=OFF
+      boost: -DMSGPACK_BOOST=OFF
+      msvc: '"Visual Studio 14 2015"'
+build_script:
+- appveyor DownloadFile https://github.com/google/googletest/archive/release-1.7.0.zip -FileName googletest-release-1.7.0.zip
+- 7z x googletest-release-1.7.0.zip > NUL
+- cd googletest-release-1.7.0
 - md build
 - cd build
-- cmake -DBUILD_SHARED_LIBS=ON ..
+- cmake -G %msvc% -DBUILD_SHARED_LIBS=ON -DCMAKE_CXX_FLAGS=/D_VARIADIC_MAX=10 ..
 - cmake --build . --config Release
 - cd ..
 - cd ..
-- appveyor DownloadFile http://zlib.net/zlib-1.2.8.tar.gz -FileName zlib-1.2.8.tar.gz
-- 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.10.tar.gz -FileName zlib-1.2.10.tar.gz
+- 7z x zlib-1.2.10.tar.gz > NUL
+- 7z x zlib-1.2.10.tar > NUL
+- cd zlib-1.2.10
 - md build
 - cd build
-- cmake ..
+- cmake -G %msvc% ..
 - cmake --build . --config Release
 - copy zconf.h ..
 - cd ..
 - cd ..
-
-environment:
-  matrix:
-    - cpp11: -DMSGPACK_CXX11=ON
-      boost: -DMSGPACK_BOOST=ON
-    - cpp11: -DMSGPACK_CXX11=OFF
-      boost: -DMSGPACK_BOOST=ON
-    - cpp11: -DMSGPACK_CXX11=ON
-      boost: -DMSGPACK_BOOST=OFF
-    - cpp11: -DMSGPACK_CXX11=OFF
-      boost: -DMSGPACK_BOOST=OFF
-build_script:
 - md build
 - cd build
-- cmake %cpp11% %boost% -DMSGPACK_BOOST_DIR=C:\Libraries\\boost_1_58_0 -DGTEST_LIBRARY=%APPVEYOR_BUILD_FOLDER%\gtest-1.7.0\build\Release\gtest.lib -DGTEST_MAIN_LIBRARY=%APPVEYOR_BUILD_FOLDER%\gtest-1.7.0\build\Release\gtest_main.lib -DGTEST_INCLUDE_DIR=%APPVEYOR_BUILD_FOLDER%\gtest-1.7.0\include -DZLIB_LIBRARY=%APPVEYOR_BUILD_FOLDER%\zlib-1.2.8\build\Release\zlib.lib -DZLIB_INCLUDE_DIR=%APPVEYOR_BUILD_FOLDER%\zlib-1.2.8 ..
+- cmake -G %msvc% %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.10\build\Release\zlib.lib -DZLIB_INCLUDE_DIR=%APPVEYOR_BUILD_FOLDER%\zlib-1.2.10 -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.10\build\Release;%APPVEYOR_BUILD_FOLDER%\build\release
 - ctest -V

bootstrap

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

ci/build_autotools.sh

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

ci/build_cmake.sh

@@ -16,42 +16,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} ..
+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
 

configure.in

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

erb/v1/cpp03_define_array.hpp.erb

@@ -1,91 +1,27 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+// 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_CPP03_DEFINE_ARRAY_HPP
-#define MSGPACK_CPP03_DEFINE_ARRAY_HPP
+#ifndef MSGPACK_V1_CPP03_DEFINE_ARRAY_HPP
+#define MSGPACK_V1_CPP03_DEFINE_ARRAY_HPP
 
-#include "msgpack/versioning.hpp"
+#include "msgpack/v1/adaptor/detail/cpp03_define_array_decl.hpp"
 #include "msgpack/adaptor/msgpack_tuple.hpp"
 #include "msgpack/adaptor/adaptor_base.hpp"
 #include "msgpack/object_fwd.hpp"
 
-#define MSGPACK_DEFINE_ARRAY(...) \
-    template <typename Packer> \
-    void msgpack_pack(Packer& pk) const \
-    { \
-        msgpack::type::make_define_array(__VA_ARGS__).msgpack_pack(pk); \
-    } \
-    void msgpack_unpack(msgpack::object const& o) \
-    { \
-        msgpack::type::make_define_array(__VA_ARGS__).msgpack_unpack(o); \
-    }\
-    template <typename MSGPACK_OBJECT> \
-    void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone& z) const \
-    { \
-        msgpack::type::make_define_array(__VA_ARGS__).msgpack_object(o, z); \
-    }
-
-#define MSGPACK_BASE_ARRAY(base) (*const_cast<base *>(static_cast<base const*>(this)))
-
-// MSGPACK_ADD_ENUM must be used in the global namespace.
-#define MSGPACK_ADD_ENUM(enum_name) \
-  namespace msgpack { \
-  /** @cond */ \
-  MSGPACK_API_VERSION_NAMESPACE(v1) { \
-  /** @endcond */ \
-  namespace adaptor { \
-    template<> \
-    struct convert<enum_name> { \
-      msgpack::object const& operator()(msgpack::object const& o, enum_name& v) const {\
-        int tmp; \
-        o >> tmp; \
-        v = static_cast<enum_name>(tmp); \
-        return o; \
-      } \
-    }; \
-    template<> \
-    struct object<enum_name> { \
-      void operator()(msgpack::object& o, const enum_name& v) const {\
-        o << static_cast<int>(v); \
-      } \
-    }; \
-    template<> \
-    struct object_with_zone<enum_name> { \
-      void operator()(msgpack::object::with_zone& o, const enum_name& v) const { \
-        o << static_cast<int>(v); \
-      } \
-    }; \
-    template<> \
-    struct pack<enum_name> { \
-      template <typename Stream> \
-      msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const enum_name& v) const { \
-        return o << static_cast<int>(v); \
-      } \
-    }; \
-  } \
-  /** @cond */ \
-  } \
-  /** @endcond */ \
-  }
-
 namespace msgpack {
 /// @cond
 MSGPACK_API_VERSION_NAMESPACE(v1) {
 /// @endcond
 namespace type {
 
-/// @cond
 <% GENERATION_LIMIT = 31 %>
-template <typename A0 = void<%1.upto(GENERATION_LIMIT+1) {|i|%>, typename A<%=i%> = void<%}%>>
-struct define_array;
-/// @endcond
-
 template <>
 struct define_array<> {
     typedef define_array<> value_type;
@@ -102,7 +38,7 @@ struct define_array<> {
     void msgpack_object(msgpack::object* o, msgpack::zone&) const
     {
         o->type = msgpack::type::ARRAY;
-        o->via.array.ptr = nullptr;
+        o->via.array.ptr = MSGPACK_NULLPTR;
         o->via.array.size = 0;
     }
 };
@@ -169,5 +105,4 @@ inline define_array<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_define_array(A0& a0
 /// @endcond
 }  // namespace msgpack
 
-
-#endif // MSGPACK_CPP03_DEFINE_ARRAY_HPP
+#endif // MSGPACK_V1_CPP03_DEFINE_ARRAY_HPP

erb/v1/cpp03_define_array_decl.hpp.erb

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

erb/v1/cpp03_define_map.hpp.erb

@@ -1,70 +1,21 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2015 KONDO Takatoshi
+// Copyright (C) 2015-2016 KONDO Takatoshi
 //
 //    Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //    http://www.boost.org/LICENSE_1_0.txt)
 //
-#ifndef MSGPACK_CPP03_DEFINE_MAP_HPP
-#define MSGPACK_CPP03_DEFINE_MAP_HPP
+#ifndef MSGPACK_V1_CPP03_DEFINE_MAP_HPP
+#define MSGPACK_V1_CPP03_DEFINE_MAP_HPP
 
-// BOOST_PP_VARIADICS is defined in boost/preprocessor/config/config.hpp
-// http://www.boost.org/libs/preprocessor/doc/ref/variadics.html
-// However, supporting compiler detection is not complete. msgpack-c requires
-// variadic macro arguments support. So BOOST_PP_VARIADICS is defined here explicitly.
-#if !defined(MSGPACK_PP_VARIADICS)
-#define MSGPACK_PP_VARIADICS
-#endif
-
-#include <msgpack/preprocessor.hpp>
-
-#include "msgpack/versioning.hpp"
+#include "msgpack/v1/adaptor/detail/cpp03_define_map_decl.hpp"
 #include "msgpack/adaptor/msgpack_tuple.hpp"
 #include "msgpack/adaptor/adaptor_base.hpp"
 #include "msgpack/object_fwd.hpp"
 
-#define MSGPACK_DEFINE_MAP_EACH_PROC(r, data, elem) \
-    MSGPACK_PP_IF( \
-        MSGPACK_PP_IS_BEGIN_PARENS(elem), \
-        elem, \
-        (MSGPACK_PP_STRINGIZE(elem))(elem) \
-    )
-
-#define MSGPACK_DEFINE_MAP_IMPL(...) \
-    MSGPACK_PP_SEQ_TO_TUPLE( \
-        MSGPACK_PP_SEQ_FOR_EACH( \
-            MSGPACK_DEFINE_MAP_EACH_PROC, \
-            0, \
-            MSGPACK_PP_VARIADIC_TO_SEQ(__VA_ARGS__) \
-        ) \
-    )
-
-#define MSGPACK_DEFINE_MAP(...) \
-    template <typename Packer> \
-    void msgpack_pack(Packer& pk) const \
-    { \
-        msgpack::type::make_define_map \
-            MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \
-            .msgpack_pack(pk); \
-    } \
-    void msgpack_unpack(msgpack::object const& o) \
-    { \
-        msgpack::type::make_define_map \
-            MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \
-            .msgpack_unpack(o); \
-    }\
-    template <typename MSGPACK_OBJECT> \
-    void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone& z) const \
-    { \
-        msgpack::type::make_define_map \
-            MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \
-            .msgpack_object(o, z); \
-    }
-
-#define MSGPACK_BASE_MAP(base) \
-    (MSGPACK_PP_STRINGIZE(base))(*const_cast<base *>(static_cast<base const*>(this)))
+#include <map>
 
 namespace msgpack {
 /// @cond
@@ -72,12 +23,7 @@ MSGPACK_API_VERSION_NAMESPACE(v1) {
 /// @endcond
 namespace type {
 
-/// @cond
 <% GENERATION_LIMIT = 31 %>
-template <typename A0 = void<%1.upto(GENERATION_LIMIT+1) {|i|%>, typename A<%=i%> = void<%}%>>
-struct define_map;
-/// @endcond
-
 template <>
 struct define_map<> {
     template <typename Packer>
@@ -92,7 +38,7 @@ struct define_map<> {
     void msgpack_object(msgpack::object* o, msgpack::zone&) const
     {
         o->type = msgpack::type::MAP;
-        o->via.map.ptr = nullptr;
+        o->via.map.ptr = MSGPACK_NULLPTR;
         o->via.map.size = 0;
     }
 };
@@ -170,4 +116,4 @@ inline define_map<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_define_map(A0& a0<%1.
 /// @endcond
 }  // namespace msgpack
 
-#endif // MSGPACK_CPP03_DEFINE_MAP_HPP
+#endif // MSGPACK_V1_CPP03_DEFINE_MAP_HPP

erb/v1/cpp03_define_map_decl.hpp.erb

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

erb/v1/cpp03_msgpack_tuple.hpp.erb

@@ -1,18 +1,16 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi
+// 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_CPP03_MSGPACK_TUPLE_HPP
-#define MSGPACK_CPP03_MSGPACK_TUPLE_HPP
+#ifndef MSGPACK_V1_CPP03_MSGPACK_TUPLE_HPP
+#define MSGPACK_V1_CPP03_MSGPACK_TUPLE_HPP
 
-#include "msgpack/versioning.hpp"
-#include "msgpack/object.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/v1/adaptor/msgpack_tuple_decl.hpp"
 
 namespace msgpack {
 
@@ -26,17 +24,6 @@ namespace type {
 // FIXME operator!=
 <% GENERATION_LIMIT = 31 %>
 
-/// @cond
-template <typename A0 = void<%1.upto(GENERATION_LIMIT+1) {|i|%>, typename A<%=i%> = void<%}%>>
-struct tuple;
-/// @endcond
-
-template <typename Tuple, int N>
-struct tuple_element;
-
-template <typename Tuple, int N>
-struct const_tuple_element;
-
 template <typename T>
 struct tuple_type {
     typedef T type;
@@ -96,6 +83,7 @@ struct tuple<> {
     tuple() {}
     tuple(msgpack::object const& o) { o.convert(*this); }
     typedef tuple<> value_type;
+    std::size_t size() const { return 0; }
 };
 
 /// @cond
@@ -103,6 +91,7 @@ struct tuple<> {
 template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
 struct tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
     typedef tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> value_type;
+    std::size_t size() const { return <%=i+1%>; }
     tuple() {}
     tuple(typename tuple_type<A0>::transparent_reference _a0<%1.upto(i) {|j|%>, typename tuple_type<A<%=j%>>::transparent_reference _a<%=j%><%}%>) :
         a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {}
@@ -161,9 +150,9 @@ struct convert<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> > {
         msgpack::object const& o,
         type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) const {
         if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        if(o.via.array.size < <%=i+1%>) { throw msgpack::type_error(); }
         <%0.upto(i) {|j|%>
         // In order to avoid clang++'s invalid warning, msgpack::object:: has been added.
+        if(o.via.array.size > <%=j%>)
             o.via.array.ptr[<%=j%>].msgpack::object::convert<typename type::tuple_type<A<%=j%>>::type>(v.template get<<%=j%>>());<%}%>
         return o;
     }
@@ -205,7 +194,7 @@ struct object_with_zone<type::tuple<> > {
         msgpack::object::with_zone& o,
         const type::tuple<>&) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = nullptr;
+        o.via.array.ptr = MSGPACK_NULLPTR;
         o.via.array.size = 0;
     }
 };
@@ -235,4 +224,4 @@ struct object_with_zone<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> > {
 
 }  // namespace msgpack
 
-#endif // MSGPACK_CPP03_MSGPACK_TUPLE_HPP
+#endif // MSGPACK_V1_CPP03_MSGPACK_TUPLE_HPP

erb/v1/cpp03_msgpack_tuple_decl.hpp.erb

@@ -0,0 +1,69 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_V1_CPP03_MSGPACK_TUPLE_DECL_HPP
+#define MSGPACK_V1_CPP03_MSGPACK_TUPLE_DECL_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/object.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace type {
+
+// FIXME operator==
+// FIXME operator!=
+<% GENERATION_LIMIT = 31 %>
+
+/// @cond
+template <typename A0 = void<%1.upto(GENERATION_LIMIT+1) {|i|%>, typename A<%=i%> = void<%}%>>
+struct tuple;
+/// @endcond
+
+template <typename Tuple, int N>
+struct tuple_element;
+
+template <typename Tuple, int N>
+struct const_tuple_element;
+
+template <typename T>
+struct tuple_type;
+
+/// @cond
+<%0.upto(GENERATION_LIMIT) {|i|%>
+template <int N, typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
+typename type::tuple_element<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>, N>::reference get(type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& t);
+template <int N, typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
+typename type::const_tuple_element<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>, N>::const_reference get(type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> const& t);
+<%}%>
+/// @endcond
+
+tuple<> make_tuple();
+
+/// @cond
+<%0.upto(GENERATION_LIMIT) {|i|%>
+template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
+tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_tuple(typename tuple_type<A0>::transparent_reference a0<%1.upto(i) {|j|%>, typename tuple_type<A<%=j%>>::transparent_reference a<%=j%><%}%>);
+<%}%>
+/// @endcond
+
+}  // namespace type
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+}  // namespace msgpack
+
+#endif // MSGPACK_V1_CPP03_MSGPACK_TUPLE_DECL_HPP

erb/v1/cpp03_zone.hpp.erb

@@ -1,28 +1,16 @@
 //
 // MessagePack for C++ memory pool
 //
-// Copyright (C) 2008-2010 FURUHASHI Sadayuki
+// 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_CPP03_ZONE_HPP
-#define MSGPACK_CPP03_ZONE_HPP
+#ifndef MSGPACK_V1_CPP03_ZONE_HPP
+#define MSGPACK_V1_CPP03_ZONE_HPP
 
-#include <cstdlib>
-#include <memory>
-#include <vector>
-
-#include "msgpack/versioning.hpp"
-
-#ifndef MSGPACK_ZONE_CHUNK_SIZE
-#define MSGPACK_ZONE_CHUNK_SIZE 8192
-#endif
-
-#ifndef MSGPACK_ZONE_ALIGN
-#define MSGPACK_ZONE_ALIGN sizeof(void*)
-#endif
+#include "msgpack/zone_decl.hpp"
 
 <% GENERATION_LIMIT = 15 %>
 namespace msgpack {
@@ -39,7 +27,7 @@ class zone {
         void* m_data;
     };
     struct finalizer_array {
-        finalizer_array():m_tail(nullptr), m_end(nullptr), m_array(nullptr) {}
+        finalizer_array():m_tail(MSGPACK_NULLPTR), m_end(MSGPACK_NULLPTR), m_array(MSGPACK_NULLPTR) {}
         void call() {
             finalizer* fin = m_tail;
             for(; fin != m_array; --fin) (*(fin-1))();
@@ -105,7 +93,7 @@ class zone {
             m_head = c;
             m_free = chunk_size;
             m_ptr  = reinterpret_cast<char*>(c) + sizeof(chunk);
-            c->m_next = nullptr;
+            c->m_next = MSGPACK_NULLPTR;
         }
         ~chunk_list()
         {
@@ -125,10 +113,11 @@ class zone {
                     ::free(c);
                     c = n;
                 } else {
+                    m_head = c;
                     break;
                 }
             }
-            m_head->m_next = nullptr;
+            m_head->m_next = MSGPACK_NULLPTR;
             m_free = chunk_size;
             m_ptr  = reinterpret_cast<char*>(m_head) + sizeof(chunk);
         }
@@ -302,7 +291,7 @@ inline void zone::undo_allocate(size_t size)
 
 inline std::size_t aligned_size(
     std::size_t size,
-    std::size_t align = MSGPACK_ZONE_ALIGN) {
+    std::size_t align) {
     return (size + align - 1) / align * align;
 }
 
@@ -335,4 +324,4 @@ T* zone::allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>)
 
 }  // namespace msgpack
 
-#endif // MSGPACK_CPP03_ZONE_HPP
+#endif // MSGPACK_V1_CPP03_ZONE_HPP

erb/v1/cpp03_zone_decl.hpp.erb

@@ -0,0 +1,46 @@
+//
+// MessagePack for C++ memory pool
+//
+// Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_V1_CPP03_ZONE_DECL_HPP
+#define MSGPACK_V1_CPP03_ZONE_DECL_HPP
+
+#include <cstdlib>
+#include <memory>
+#include <vector>
+
+#include "msgpack/versioning.hpp"
+
+#ifndef MSGPACK_ZONE_CHUNK_SIZE
+#define MSGPACK_ZONE_CHUNK_SIZE 8192
+#endif
+
+#ifndef MSGPACK_ZONE_ALIGN
+#define MSGPACK_ZONE_ALIGN sizeof(void*)
+#endif
+
+<% GENERATION_LIMIT = 15 %>
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+class zone;
+
+std::size_t aligned_size(
+    std::size_t size,
+    std::size_t align = MSGPACK_ZONE_ALIGN);
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+}  // namespace msgpack
+
+#endif // MSGPACK_V1_CPP03_ZONE_DECL_HPP

example/CMakeLists.txt

@@ -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/boost/msgpack_variant_capitalize.cpp

@@ -73,8 +73,8 @@ int main() {
     msgpack::pack(ss1, u);
     print(ss1.str());
 
-    msgpack::unpacked unp1 = msgpack::unpack(ss1.str().data(), ss1.str().size());
-    msgpack::object const& obj1 = unp1.get();
+    msgpack::object_handle oh1 = msgpack::unpack(ss1.str().data(), ss1.str().size());
+    msgpack::object const& obj1 = oh1.get();
     std::cout << "Unpacked msgpack object." << std::endl;
     std::cout << obj1 << std::endl;
 
@@ -87,8 +87,8 @@ int main() {
     msgpack::pack(ss2, v);
     print(ss2.str());
 
-    msgpack::unpacked unp2 = msgpack::unpack(ss2.str().data(), ss2.str().size());
-    msgpack::object const& obj2 = unp2.get();
+    msgpack::object_handle oh2 = msgpack::unpack(ss2.str().data(), ss2.str().size());
+    msgpack::object const& obj2 = oh2.get();
     std::cout << "Modified msgpack object." << std::endl;
     std::cout << obj2 << std::endl;
 }

example/boost/msgpack_variant_mapbased.cpp

@@ -45,7 +45,11 @@ struct proc:boost::static_visitor<void> {
                 // You can remove key-value pair from msgpack::type::variant_ref
 
 #if defined(MSGPACK_USE_CPP03)
+#  if MSGPACK_LIB_STD_CXX
+                v.erase(std::multimap<msgpack::type::variant_ref, msgpack::type::variant_ref>::const_iterator(it++));
+#  else  // MSGPACK_LIB_STD_CXX
                 v.erase(it++);
+#  endif // MSGPACK_LIB_STD_CXX
 #else  // defined(MSGPACK_USE_CPP03)
 #  if MSGPACK_LIB_STD_CXX
                 it = v.erase(std::multimap<msgpack::type::variant_ref, msgpack::type::variant_ref>::const_iterator(it));
@@ -79,8 +83,8 @@ int main() {
     u.address = "Tokyo";
     msgpack::pack(ss, u);
 
-    msgpack::unpacked unp = msgpack::unpack(ss.str().data(), ss.str().size());
-    msgpack::object const& obj = unp.get();
+    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    msgpack::object const& obj = oh.get();
     std::cout << "Unpacked msgpack object." << std::endl;
     std::cout << obj << std::endl;
     msgpack::type::variant_ref v = obj.as<msgpack::type::variant_ref>();

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/lib_buffer_unpack.c

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

example/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

@@ -5,26 +5,29 @@ LIST (APPEND exec_PROGRAMS
     custom.cpp
     enum.cpp
     map_based_versionup.cpp
-    protocol.cpp
     protocol_new.cpp
     reuse_zone.cpp
     simple.cpp
 )
 
+IF (MSGPACK_DEFAULT_API_VERSION EQUAL 1)
+    LIST (APPEND exec_PROGRAMS
+        protocol.cpp
+    )
+ENDIF ()
+
 IF (NOT MSVC)
     LIST (APPEND with_pthread_PROGRAMS
         stream.cpp
     )
 ENDIF ()
 
-IF (MSGPACK_BOOST)
-    IF (NOT MSVC)
+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 ()
-ENDIF ()
 
 FOREACH (source_file ${exec_PROGRAMS})
     GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
@@ -51,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]")
@@ -95,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/cpp03/class_intrusive.cpp

@@ -84,9 +84,9 @@ int main() {
 
         print(ss.str());
 
-        msgpack::unpacked unp;
-        msgpack::unpack(unp, ss.str().data(), ss.str().size());
-        msgpack::object obj = unp.get();
+        msgpack::object_handle oh =
+            msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::object obj = oh.get();
         std::cout << obj << std::endl;
         assert(obj.as<my_class>() == my);
     }

example/cpp03/class_intrusive_map.cpp

@@ -59,9 +59,9 @@ int main() {
 
         print(ss.str());
 
-        msgpack::unpacked unp;
-        msgpack::unpack(unp, ss.str().data(), ss.str().size());
-        msgpack::object obj = unp.get();
+        msgpack::object_handle oh =
+            msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::object obj = oh.get();
         std::cout << obj << std::endl;
         assert(obj.as<my_class>() == my);
     }

example/cpp03/class_non_intrusive.cpp

@@ -102,9 +102,9 @@ int main() {
 
         print(ss.str());
 
-        msgpack::unpacked unp;
-        msgpack::unpack(unp, ss.str().data(), ss.str().size());
-        msgpack::object obj = unp.get();
+        msgpack::object_handle oh =
+            msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::object obj = oh.get();
         std::cout << obj << std::endl;
         assert(obj.as<my_class>() == my);
     }

example/cpp03/custom.cpp

@@ -40,9 +40,9 @@ int main(void)
         std::stringstream sbuf;
         msgpack::pack(sbuf, oc);
 
-        msgpack::unpacked result;
-        msgpack::unpack(result, sbuf.str().data(), sbuf.str().size());
-        msgpack::object obj = result.get();
+        msgpack::object_handle oh =
+            msgpack::unpack(sbuf.str().data(), sbuf.str().size());
+        msgpack::object obj = oh.get();
 
         obj.convert(nc);
 
@@ -56,9 +56,9 @@ int main(void)
         std::stringstream sbuf;
         msgpack::pack(sbuf, nc);
 
-        msgpack::unpacked result;
-        msgpack::unpack(result, sbuf.str().data(), sbuf.str().size());
-        msgpack::object obj = result.get();
+        msgpack::object_handle oh =
+            msgpack::unpack(sbuf.str().data(), sbuf.str().size());
+        msgpack::object obj = oh.get();
 
         obj.convert(oc);
 

example/cpp03/enum.cpp

@@ -30,20 +30,20 @@ int main(void)
         my_enum e3 = elem3;
         msgpack::pack(sbuf, e3);
 
-        msgpack::unpacked result;
+        msgpack::object_handle oh;
         std::size_t off = 0;
 
-        msgpack::unpack(result, sbuf.str().data(), sbuf.str().size(), off);
-        std::cout << result.get().as<my_enum>() << std::endl;
-        assert(result.get().as<my_enum>() == elem1);
+        msgpack::unpack(oh, sbuf.str().data(), sbuf.str().size(), off);
+        std::cout << oh.get().as<my_enum>() << std::endl;
+        assert(oh.get().as<my_enum>() == elem1);
 
-        msgpack::unpack(result, sbuf.str().data(), sbuf.str().size(), off);
-        std::cout << result.get().as<my_enum>() << std::endl;
-        assert(result.get().as<my_enum>() == elem2);
+        msgpack::unpack(oh, sbuf.str().data(), sbuf.str().size(), off);
+        std::cout << oh.get().as<my_enum>() << std::endl;
+        assert(oh.get().as<my_enum>() == elem2);
 
-        msgpack::unpack(result, sbuf.str().data(), sbuf.str().size(), off);
-        std::cout << result.get().as<my_enum>() << std::endl;
-        assert(result.get().as<my_enum>() == elem3);
+        msgpack::unpack(oh, sbuf.str().data(), sbuf.str().size(), off);
+        std::cout << oh.get().as<my_enum>() << std::endl;
+        assert(oh.get().as<my_enum>() == elem3);
     }
     {   // create object without zone
         msgpack::object obj(elem2);

example/cpp03/map_based_versionup.cpp

@@ -71,9 +71,9 @@ int main() {
 
         print(ss.str());
 
-        msgpack::unpacked unp = msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
 
-        msgpack::object obj = unp.get();
+        msgpack::object obj = oh.get();
         std::cout << obj << std::endl;
 
         v2 newv = obj.as<v2>();

example/cpp03/protocol.cpp

@@ -57,9 +57,9 @@ int main(void)
     {
         std::string buffer(stream.str());
 
-        msgpack::unpacked result;
-        msgpack::unpack(result, buffer.data(), buffer.size());
-        msgpack::object o = result.get();
+        msgpack::object_handle oh =
+            msgpack::unpack(buffer.data(), buffer.size());
+        msgpack::object o = oh.get();
 
         myprotocol::Get req;
         o.convert(req);
@@ -85,9 +85,9 @@ int main(void)
     {
         std::string buffer(stream.str());
 
-        msgpack::unpacked result;
-        msgpack::unpack(result, buffer.data(), buffer.size());
-        msgpack::object o = result.get();
+        msgpack::object_handle oh =
+            msgpack::unpack(buffer.data(), buffer.size());
+        msgpack::object o = oh.get();
 
 
         myprotocol::MultiGet req;

example/cpp03/protocol_new.cpp

@@ -44,9 +44,9 @@ int main(void)
     {
         std::string buffer(stream.str());
 
-        msgpack::unpacked result;
-        msgpack::unpack(result, buffer.data(), buffer.size());
-        msgpack::object o = result.get();
+        msgpack::object_handle oh =
+            msgpack::unpack(buffer.data(), buffer.size());
+        msgpack::object o = oh.get();
 
         myprotocol::Get req;
         o.convert(req);
@@ -72,9 +72,9 @@ int main(void)
     {
         std::string buffer(stream.str());
 
-        msgpack::unpacked result;
-        msgpack::unpack(result, buffer.data(), buffer.size());
-        msgpack::object o = result.get();
+        msgpack::object_handle oh =
+            msgpack::unpack(buffer.data(), buffer.size());
+        msgpack::object o = oh.get();
 
 
         myprotocol::MultiGet req;

example/cpp03/simple.cpp

@@ -27,12 +27,10 @@ int main(void)
     // deserialize the buffer into msgpack::object instance.
     std::string str(buffer.str());
 
-    msgpack::unpacked result;
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
 
-    msgpack::unpack(result, str.data(), str.size());
-
-    // deserialized object is valid during the msgpack::unpacked instance alive.
-    msgpack::object deserialized = result.get();
+    // deserialized object is valid during the msgpack::object_handle instance alive.
+    msgpack::object deserialized = oh.get();
 
     // msgpack::object supports ostream.
     std::cout << deserialized << std::endl;

example/cpp03/speed_test.cpp

@@ -37,11 +37,11 @@ void test_map_pack_unpack() {
     buffer.seekg(0);
     std::string str(buffer.str());
 
-    msgpack::unpacked unpacked;
-    std::cout << "Start unpacking...by void unpack(unpacked& result, const char* data, size_t len)" << std::endl;
+    msgpack::object_handle oh;
+    std::cout << "Start unpacking...by void unpack(object_handle& oh, const char* data, size_t len)" << std::endl;
     {
         boost::timer::cpu_timer timer;
-        msgpack::unpack(unpacked, str.data(), str.size());
+        msgpack::unpack(oh, str.data(), str.size());
         std::string result = timer.format();
         std::cout << result << std::endl;
     }
@@ -50,7 +50,7 @@ void test_map_pack_unpack() {
     std::cout << "Start converting..." << std::endl;
     {
         boost::timer::cpu_timer timer;
-        unpacked.get().convert(m2);
+        oh.get().convert(m2);
         std::string result = timer.format();
         std::cout << result << std::endl;
     }

example/cpp03/speed_test_nested_array.cpp

@@ -60,11 +60,11 @@ void test_array_of_array() {
     buffer.seekg(0);
     std::string str(buffer.str());
 
-    msgpack::unpacked unpacked;
-    std::cout << "Start unpacking...by void unpack(unpacked& result, const char* data, size_t len)" << std::endl;
+    msgpack::object_handle oh;
+    std::cout << "Start unpacking...by void unpack(object_handle& oh, const char* data, size_t len)" << std::endl;
     {
         boost::timer::cpu_timer timer;
-        msgpack::unpack(unpacked, str.data(), str.size());
+        msgpack::unpack(oh, str.data(), str.size());
         std::string result = timer.format();
         std::cout << result << std::endl;
     }
@@ -73,7 +73,7 @@ void test_array_of_array() {
     std::cout << "Start converting..." << std::endl;
     {
         boost::timer::cpu_timer timer;
-        unpacked.get().convert(v2);
+        oh.get().convert(v2);
         std::string result = timer.format();
         std::cout << result << std::endl;
     }

example/cpp03/stream.cpp

@@ -16,6 +16,12 @@
 #include <errno.h>
 #include <pthread.h>
 
+#if defined(_MSC_VER) || defined(__MINGW32__)
+#include <io.h>
+#include <fcntl.h>
+#define pipe(fds) _pipe(fds, 4096, _O_BINARY)
+#endif // _MSC_VER || __MINGW32__
+
 class Server {
 public:
     Server(int sock) : m_sock(sock) { }
@@ -43,10 +49,10 @@ public:
 
         m_pac.buffer_consumed(count);
 
-        msgpack::unpacked result;
-        while (m_pac.next(&result)) {
-            msgpack::object msg = result.get();
-            unique_zone& life = result.zone();
+        msgpack::object_handle oh;
+        while (m_pac.next(oh)) {
+            msgpack::object msg = oh.get();
+            unique_zone& life = oh.zone();
             process_message(msg, life);
         }
 

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

@@ -25,8 +25,8 @@ void array() {
     std::stringstream ss;
     msgpack::pack(ss, a);
 
-    msgpack::unpacked und = msgpack::unpack(ss.str().data(), ss.str().size());
-    msgpack::object obj = und.get();
+    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    msgpack::object obj = oh.get();
 
     std::cout << obj << std::endl;
     assert((obj.as<std::array<int, 5>>()) == a);
@@ -37,8 +37,8 @@ void tuple() {
     std::stringstream ss;
     msgpack::pack(ss, t);
 
-    auto und = msgpack::unpack(ss.str().data(), ss.str().size());
-    auto obj = und.get();
+    auto oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    auto obj = oh.get();
 
     std::cout << obj << std::endl;
     assert(obj.as<decltype(t)>() == t);
@@ -49,8 +49,8 @@ void unordered_map() {
     std::stringstream ss;
     msgpack::pack(ss, m);
 
-    auto und = msgpack::unpack(ss.str().data(), ss.str().size());
-    msgpack::object obj = und.get();
+    auto oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    msgpack::object obj = oh.get();
 
     std::cout << obj << std::endl;
     assert(obj.as<decltype(m)>() == m);
@@ -61,8 +61,8 @@ void unordered_set() {
     std::stringstream ss;
     msgpack::pack(ss, s);
 
-    auto und = msgpack::unpack(ss.str().data(), ss.str().size());
-    auto obj = und.get();
+    auto oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    auto obj = oh.get();
 
     std::cout << obj << std::endl;
     assert(obj.as<decltype(s)>() == s);
@@ -74,8 +74,8 @@ void forward_list() {
     std::stringstream ss;
     msgpack::pack(ss, f);
 
-    auto und = msgpack::unpack(ss.str().data(), ss.str().size());
-    auto obj = und.get();
+    auto oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    auto obj = oh.get();
 
     std::cout << obj << std::endl;
     assert(obj.as<type>() == f);
@@ -98,40 +98,40 @@ void combi() {
     std::size_t offset = 0;
     std::cout << "offset: " << offset << std::endl;
     {
-        auto und = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
-        auto obj = und.get();
+        auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
+        auto obj = oh.get();
 
         std::cout << obj << std::endl;
         assert(obj.as<decltype(a)>() == a);
     }
     std::cout << "offset: " << offset << std::endl;
     {
-        auto und = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
-        auto obj = und.get();
+        auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
+        auto obj = oh.get();
 
         std::cout << obj << std::endl;
         assert(obj.as<decltype(t)>() == t);
     }
     std::cout << "offset: " << offset << std::endl;
     {
-        auto und = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
-        auto obj = und.get();
+        auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
+        auto obj = oh.get();
 
         std::cout << obj << std::endl;
         assert(obj.as<decltype(m)>() == m);
     }
     std::cout << "offset: " << offset << std::endl;
     {
-        auto und = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
-        auto obj = und.get();
+        auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
+        auto obj = oh.get();
 
         std::cout << obj << std::endl;
         assert(obj.as<decltype(s)>() == s);
     }
     std::cout << "offset: " << offset << std::endl;
     {
-        auto und = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
-        auto obj = und.get();
+        auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
+        auto obj = oh.get();
 
         std::cout << obj << std::endl;
         assert(obj.as<decltype(f)>() == f);

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

@@ -1,7 +1,7 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2015 KONDO Takatoshi
+// Copyright (C) 2015-2016 KONDO Takatoshi
 //
 //    Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
@@ -10,75 +10,9 @@
 #ifndef MSGPACK_ADAPTOR_BASE_HPP
 #define MSGPACK_ADAPTOR_BASE_HPP
 
-#include "msgpack/object_fwd.hpp"
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-template <typename Stream>
-class packer;
-
-namespace adaptor {
-
-// Adaptor functors
-
-template <typename T, typename Enabler = void>
-struct convert {
-    msgpack::object const& operator()(msgpack::object const& o, T& v) const;
-};
-
-template <typename T, typename Enabler = void>
-struct pack {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, T const& v) const;
-};
-
-template <typename T, typename Enabler = void>
-struct object {
-    void operator()(msgpack::object& o, T const& v) const;
-};
-
-template <typename T, typename Enabler = void>
-struct object_with_zone {
-    void operator()(msgpack::object::with_zone& o, T const& v) const;
-};
-
-} // namespace adaptor
-
-// operators
-
-template <typename T>
-inline
-msgpack::object const& operator>> (msgpack::object const& o, T& v) {
-    return adaptor::convert<T>()(o, v);
-}
-
-template <typename Stream, typename T>
-inline
-msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, T const& v) {
-    return adaptor::pack<T>()(o, v);
-}
-
-template <typename T>
-inline
-void operator<< (msgpack::object& o, T const& v) {
-    adaptor::object<T>()(o, v);
-}
-
-template <typename T>
-inline
-void operator<< (msgpack::object::with_zone& o, T const& v) {
-    adaptor::object_with_zone<T>()(o, v);
-}
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
+#include "msgpack/adaptor/adaptor_base_decl.hpp"
 
+#include "msgpack/v1/adaptor/adaptor_base.hpp"
+#include "msgpack/v2/adaptor/adaptor_base.hpp"
 
 #endif // MSGPACK_ADAPTOR_BASE_HPP

include/msgpack/adaptor/adaptor_base_decl.hpp

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

include/msgpack/adaptor/array_ref.hpp

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

include/msgpack/adaptor/array_ref_decl.hpp

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

include/msgpack/adaptor/bool.hpp

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

include/msgpack/adaptor/boost/fusion.hpp

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

include/msgpack/adaptor/boost/msgpack_variant.hpp

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

include/msgpack/adaptor/boost/msgpack_variant_decl.hpp

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

include/msgpack/adaptor/boost/optional.hpp

@@ -1,7 +1,7 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2015 KONDO Takatoshi
+// Copyright (C) 2016 KONDO Takatoshi
 //
 //    Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
@@ -10,87 +10,6 @@
 #ifndef MSGPACK_TYPE_BOOST_OPTIONAL_HPP
 #define MSGPACK_TYPE_BOOST_OPTIONAL_HPP
 
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-// To suppress warning on Boost.1.58.0
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__)
-
-#include <boost/optional.hpp>
-
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__)
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-#if !defined (MSGPACK_USE_CPP03)
-
-template <typename T>
-struct as<boost::optional<T>, typename std::enable_if<msgpack::has_as<T>::value>::type> {
-    boost::optional<T> operator()(msgpack::object const& o) const {
-        if(o.is_nil()) return boost::none;
-        return o.as<T>();
-    }
-};
-
-#endif // !defined (MSGPACK_USE_CPP03)
-
-template <typename T>
-struct convert<boost::optional<T> > {
-    msgpack::object const& operator()(msgpack::object const& o, boost::optional<T>& v) const {
-        if(o.is_nil()) v = boost::none;
-        else {
-            T t;
-            msgpack::adaptor::convert<T>()(o, t);
-            v = t;
-        }
-        return o;
-    }
-};
-
-template <typename T>
-struct pack<boost::optional<T> > {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const boost::optional<T>& v) const {
-        if (v) o.pack(*v);
-        else o.pack_nil();
-        return o;
-    }
-};
-
-template <typename T>
-struct object<boost::optional<T> > {
-    void operator()(msgpack::object& o, const boost::optional<T>& v) const {
-        if (v) msgpack::adaptor::object<T>()(o, *v);
-        else o.type = msgpack::type::NIL;
-    }
-};
-
-template <typename T>
-struct object_with_zone<boost::optional<T> > {
-    void operator()(msgpack::object::with_zone& o, const boost::optional<T>& v) const {
-        if (v) msgpack::adaptor::object_with_zone<T>()(o, *v);
-        else o.type = msgpack::type::NIL;
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
+#include "msgpack/v1/adaptor/boost/optional.hpp"
 
 #endif // MSGPACK_TYPE_BOOST_OPTIONAL_HPP

include/msgpack/adaptor/boost/string_ref.hpp

@@ -1,7 +1,7 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2015 KONDO Takatoshi
+// Copyright (C) 2016 KONDO Takatoshi
 //
 //    Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
@@ -10,78 +10,6 @@
 #ifndef MSGPACK_TYPE_BOOST_STRING_REF_HPP
 #define MSGPACK_TYPE_BOOST_STRING_REF_HPP
 
-#include <boost/version.hpp>
-#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
-
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#include <boost/utility/string_ref.hpp>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-template <>
-struct convert<boost::string_ref> {
-    msgpack::object const& operator()(msgpack::object const& o, boost::string_ref& v) const {
-        switch (o.type) {
-        case msgpack::type::BIN:
-            v = boost::string_ref(o.via.bin.ptr, o.via.bin.size);
-            break;
-        case msgpack::type::STR:
-            v = boost::string_ref(o.via.str.ptr, o.via.str.size);
-            break;
-        default:
-            throw msgpack::type_error();
-            break;
-        }
-        return o;
-    }
-};
-
-template <>
-struct pack<boost::string_ref> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const boost::string_ref& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.pack_str(size);
-        o.pack_str_body(v.data(), size);
-        return o;
-    }
-};
-
-template <>
-struct object<boost::string_ref> {
-    void operator()(msgpack::object& o, const boost::string_ref& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.type = msgpack::type::STR;
-        o.via.str.ptr = v.data();
-        o.via.str.size = size;
-    }
-};
-
-template <>
-struct object_with_zone<boost::string_ref> {
-    void operator()(msgpack::object::with_zone& o, const boost::string_ref& v) const {
-        static_cast<msgpack::object&>(o) << v;
-    }
-};
-
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
-
-#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+#include "msgpack/v1/adaptor/boost/string_ref.hpp"
 
 #endif // MSGPACK_TYPE_BOOST_STRING_REF_HPP

include/msgpack/adaptor/carray.hpp

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

include/msgpack/adaptor/char_ptr.hpp

@@ -1,7 +1,7 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2014-2015 KONDO Takatoshi
+// Copyright (C) 2016 KONDO Takatoshi
 //
 //    Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
@@ -10,148 +10,6 @@
 #ifndef MSGPACK_TYPE_CHAR_PTR_HPP
 #define MSGPACK_TYPE_CHAR_PTR_HPP
 
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-
-#include <cstring>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-template <>
-struct pack<const char*> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const char* v) const {
-        uint32_t size = checked_get_container_size(std::strlen(v));
-        o.pack_str(size);
-        o.pack_str_body(v, size);
-        return o;
-    }
-};
-
-template <>
-struct object_with_zone<const char*> {
-    void operator()(msgpack::object::with_zone& o, const char* v) const {
-        uint32_t size = checked_get_container_size(std::strlen(v));
-        o.type = msgpack::type::STR;
-        char* ptr = static_cast<char*>(o.zone.allocate_align(size));
-        o.via.str.ptr = ptr;
-        o.via.str.size = size;
-        std::memcpy(ptr, v, size);
-    }
-};
-
-template <>
-struct object<const char*> {
-    void operator()(msgpack::object& o, const char* v) const {
-        uint32_t size = checked_get_container_size(std::strlen(v));
-        o.type = msgpack::type::STR;
-        o.via.str.ptr = v;
-        o.via.str.size = size;
-    }
-};
-
-
-template <>
-struct pack<char*> {
-    template <typename Stream>
-    packer<Stream>& operator()(packer<Stream>& o, char* v) const {
-        return o << static_cast<const char*>(v);
-    }
-};
-
-template <>
-struct object_with_zone<char*> {
-    void operator()(msgpack::object::with_zone& o, char* v) const {
-        o << static_cast<const char*>(v);
-    }
-};
-
-template <>
-struct object<char*> {
-    void operator()(msgpack::object& o, char* v) const {
-        o << static_cast<const char*>(v);
-    }
-};
-
-template <std::size_t N>
-struct pack<char[N]> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const char* v) const {
-        uint32_t size = checked_get_container_size(std::strlen(v));
-        o.pack_str(size);
-        o.pack_str_body(v, size);
-        return o;
-    }
-};
-
-template <std::size_t N>
-struct object_with_zone<char[N]> {
-    void operator()(msgpack::object::with_zone& o, const char* v) const {
-        uint32_t size = checked_get_container_size(std::strlen(v));
-        o.type = msgpack::type::STR;
-        char* ptr = static_cast<char*>(o.zone.allocate_align(size));
-        o.via.str.ptr = ptr;
-        o.via.str.size = size;
-        std::memcpy(ptr, v, size);
-    }
-};
-
-template <std::size_t N>
-struct object<char[N]> {
-    void operator()(msgpack::object& o, const char* v) const {
-        uint32_t size = checked_get_container_size(std::strlen(v));
-        o.type = msgpack::type::STR;
-        o.via.str.ptr = v;
-        o.via.str.size = size;
-    }
-};
-
-template <std::size_t N>
-struct pack<const char[N]> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const char* v) const {
-        uint32_t size = checked_get_container_size(std::strlen(v));
-        o.pack_str(size);
-        o.pack_str_body(v, size);
-        return o;
-    }
-};
-
-template <std::size_t N>
-struct object_with_zone<const char[N]> {
-    void operator()(msgpack::object::with_zone& o, const char* v) const {
-        uint32_t size = checked_get_container_size(std::strlen(v));
-        o.type = msgpack::type::STR;
-        char* ptr = static_cast<char*>(o.zone.allocate_align(size));
-        o.via.str.ptr = ptr;
-        o.via.str.size = size;
-        std::memcpy(ptr, v, size);
-    }
-};
-
-template <std::size_t N>
-struct object<const char[N]> {
-    void operator()(msgpack::object& o, const char* v) const {
-        uint32_t size = checked_get_container_size(std::strlen(v));
-        o.type = msgpack::type::STR;
-        o.via.str.ptr = v;
-        o.via.str.size = size;
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-}  // namespace msgpack
+#include "msgpack/v1/adaptor/char_ptr.hpp"
 
 #endif // MSGPACK_TYPE_CHAR_PTR_HPP

include/msgpack/adaptor/check_container_size.hpp

@@ -1,7 +1,7 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2015 KONDO Takatoshi
+// Copyright (C) 2015-2016 KONDO Takatoshi
 //
 //    Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
@@ -10,58 +10,8 @@
 #ifndef MSGPACK_CHECK_CONTAINER_SIZE_HPP
 #define MSGPACK_CHECK_CONTAINER_SIZE_HPP
 
-#include "msgpack/versioning.hpp"
-#include <stdexcept>
+#include "msgpack/adaptor/check_container_size_decl.hpp"
 
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-struct container_size_overflow : public std::runtime_error {
-    explicit container_size_overflow(const std::string& msg)
-        :std::runtime_error(msg) {}
-#if !defined(MSGPACK_USE_CPP03)
-    explicit container_size_overflow(const char* msg):
-        std::runtime_error(msg) {}
-#endif // !defined(MSGPACK_USE_CPP03)
-};
-
-namespace detail {
-
-template <std::size_t N>
-inline void check_container_size(std::size_t size) {
-    if (size > 0xffffffff) throw container_size_overflow("container size overflow");
-}
-
-template <>
-inline void check_container_size<4>(std::size_t /*size*/) {
-}
-
-template <std::size_t N>
-inline void check_container_size_for_ext(std::size_t size) {
-    if (size > 0xffffffff) throw container_size_overflow("container size overflow");
-}
-
-template <>
-inline void check_container_size_for_ext<4>(std::size_t size) {
-    if (size > 0xfffffffe) throw container_size_overflow("container size overflow");
-}
-
-} // namespace detail
-
-template <typename T>
-inline uint32_t checked_get_container_size(T size) {
-    detail::check_container_size<sizeof(T)>(size);
-    return static_cast<uint32_t>(size);
-}
-
-
-/// @cond
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-}  // namespace msgpack
+#include "msgpack/v1/adaptor/check_container_size.hpp"
 
 #endif // MSGPACK_CHECK_CONTAINER_SIZE_HPP

include/msgpack/adaptor/check_container_size_decl.hpp

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

include/msgpack/adaptor/cpp11/array.hpp

@@ -1,138 +1,16 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2014-2015 KONDO Takatoshi
+// Copyright (C) 2016 KONDO Takatoshi
 //
 //    Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //    http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#ifndef MSGPACK_CPP11_ARRAY_HPP
-#define MSGPACK_CPP11_ARRAY_HPP
+#ifndef MSGPACK_TYPE_CPP11_ARRAY_HPP
+#define MSGPACK_TYPE_CPP11_ARRAY_HPP
 
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-#include "msgpack/meta.hpp"
+#include "msgpack/v1/adaptor/cpp11/array.hpp"
 
-#include <array>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-namespace detail {
-
-namespace array {
-
-template<typename T, std::size_t N1, std::size_t... I1, std::size_t N2, std::size_t... I2>
-inline std::array<T, N1+N2> concat(
-    std::array<T, N1>&& a1,
-    std::array<T, N2>&& a2,
-    msgpack::seq<I1...>,
-    msgpack::seq<I2...>) {
-    return {{ std::move(a1[I1])..., std::move(a2[I2])... }};
-}
-
-template<typename T, std::size_t N1, std::size_t N2>
-inline std::array<T, N1+N2> concat(std::array<T, N1>&& a1, std::array<T, N2>&& a2) {
-    return concat(std::move(a1), std::move(a2), msgpack::gen_seq<N1>(), msgpack::gen_seq<N2>());
-}
-
-template <typename T, std::size_t N>
-struct as_impl {
-    static std::array<T, N> as(msgpack::object const& o) {
-        msgpack::object* p = o.via.array.ptr + N - 1;
-        return concat(as_impl<T, N-1>::as(o), std::array<T, 1>{{p->as<T>()}});
-    }
-};
-
-template <typename T>
-struct as_impl<T, 1> {
-    static std::array<T, 1> as(msgpack::object const& o) {
-        msgpack::object* p = o.via.array.ptr;
-        return std::array<T, 1>{{p->as<T>()}};
-    }
-};
-
-template <typename T>
-struct as_impl<T, 0> {
-    static std::array<T, 0> as(msgpack::object const&) {
-        return std::array<T, 0>();
-    }
-};
-
-} // namespace array
-
-} // namespace detail
-
-template <typename T, std::size_t N>
-struct as<std::array<T, N>, typename std::enable_if<msgpack::has_as<T>::value>::type> {
-    std::array<T, N> operator()(msgpack::object const& o) const {
-        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        if(o.via.array.size != N) { throw msgpack::type_error(); }
-        return detail::array::as_impl<T, N>::as(o);
-    }
-};
-
-template <typename T, std::size_t N>
-struct convert<std::array<T, N>> {
-    msgpack::object const& operator()(msgpack::object const& o, std::array<T, N>& v) const {
-        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        if(o.via.array.size != N) { throw msgpack::type_error(); }
-        if(o.via.array.size > 0) {
-            msgpack::object* p = o.via.array.ptr;
-            msgpack::object* const pend = o.via.array.ptr + o.via.array.size;
-            T* it = &v[0];
-            do {
-                p->convert(*it);
-                ++p;
-                ++it;
-            } while(p < pend);
-        }
-        return o;
-    }
-};
-
-template <typename T, std::size_t N>
-struct pack<std::array<T, N>> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::array<T, N>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.pack_array(size);
-        for(auto const& e : v) o.pack(e);
-        return o;
-    }
-};
-
-template <typename T, std::size_t N>
-struct object_with_zone<std::array<T, N>> {
-    void operator()(msgpack::object::with_zone& o, const std::array<T, N>& v) const {
-        o.type = msgpack::type::ARRAY;
-        if(v.empty()) {
-            o.via.array.ptr = nullptr;
-            o.via.array.size = 0;
-        } else {
-            uint32_t size = checked_get_container_size(v.size());
-            msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
-            o.via.array.size = size;
-            o.via.array.ptr = p;
-            for (auto const& e : v) *p++ = msgpack::object(e, o.zone);
-        }
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
-
-#endif // MSGPACK_CPP11_ARRAY_HPP
+#endif // MSGPACK_TYPE_CPP11_ARRAY_HPP

include/msgpack/adaptor/cpp11/array_char.hpp

@@ -1,89 +1,16 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2014-2015 KONDO Takatoshi
+// Copyright (C) 2016 KONDO Takatoshi
 //
 //    Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //    http://www.boost.org/LICENSE_1_0.txt)
 //
-#ifndef MSGPACK_TYPE_ARRAY_CHAR_HPP
-#define MSGPACK_TYPE_ARRAY_CHAR_HPP
 
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
+#ifndef MSGPACK_TYPE_CPP11_ARRAY_CHAR_HPP
+#define MSGPACK_TYPE_CPP11_ARRAY_CHAR_HPP
 
-#include <array>
+#include "msgpack/v1/adaptor/cpp11/array_char.hpp"
 
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-template <std::size_t N>
-struct convert<std::array<char, N>> {
-    msgpack::object const& operator()(msgpack::object const& o, std::array<char, N>& v) const {
-        switch (o.type) {
-        case msgpack::type::BIN:
-            if(o.via.bin.size != N) { throw msgpack::type_error(); }
-            std::memcpy(v.data(), o.via.bin.ptr, o.via.bin.size);
-            break;
-        case msgpack::type::STR:
-            if(o.via.str.size != N) { throw msgpack::type_error(); }
-            std::memcpy(v.data(), o.via.str.ptr, N);
-            break;
-        default:
-            throw msgpack::type_error();
-            break;
-        }
-        return o;
-    }
-};
-
-template <std::size_t N>
-struct pack<std::array<char, N>> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::array<char, N>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.pack_bin(size);
-        o.pack_bin_body(v.data(), size);
-
-        return o;
-    }
-};
-
-template <std::size_t N>
-struct object<std::array<char, N>> {
-    void operator()(msgpack::object& o, const std::array<char, N>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.type = msgpack::type::BIN;
-        o.via.bin.ptr = v.data();
-        o.via.bin.size = size;
-    }
-};
-
-template <std::size_t N>
-struct object_with_zone<std::array<char, N>> {
-    void operator()(msgpack::object::with_zone& o, const std::array<char, N>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.type = msgpack::type::BIN;
-        char* ptr = static_cast<char*>(o.zone.allocate_align(size));
-        o.via.bin.ptr = ptr;
-        o.via.bin.size = size;
-        std::memcpy(ptr, v.data(), size);
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
-
-#endif // MSGPACK_TYPE_ARRAY_CHAR_HPP
+#endif // MSGPACK_TYPE_CPP11_ARRAY_CHAR_HPP

include/msgpack/adaptor/cpp11/array_unsigned_char.hpp

@@ -1,89 +1,16 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2014-2015 KONDO Takatoshi
+// Copyright (C) 2016 KONDO Takatoshi
 //
 //    Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //    http://www.boost.org/LICENSE_1_0.txt)
 //
-#ifndef MSGPACK_TYPE_ARRAY_UNSIGNED_CHAR_HPP
-#define MSGPACK_TYPE_ARRAY_UNSIGNED_CHAR_HPP
 
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
+#ifndef MSGPACK_TYPE_CPP11_ARRAY_UNSIGNED_CHAR_HPP
+#define MSGPACK_TYPE_CPP11_ARRAY_UNSIGNED_CHAR_HPP
 
-#include <array>
+#include "msgpack/v1/adaptor/cpp11/array_unsigned_char.hpp"
 
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-template <std::size_t N>
-struct convert<std::array<unsigned char, N>> {
-    msgpack::object const& operator()(msgpack::object const& o, std::array<unsigned char, N>& v) const {
-        switch (o.type) {
-        case msgpack::type::BIN:
-            if(o.via.bin.size != N) { throw msgpack::type_error(); }
-            std::memcpy(v.data(), o.via.bin.ptr, o.via.bin.size);
-            break;
-        case msgpack::type::STR:
-            if(o.via.str.size != N) { throw msgpack::type_error(); }
-            std::memcpy(v.data(), o.via.str.ptr, N);
-            break;
-        default:
-            throw msgpack::type_error();
-            break;
-        }
-        return o;
-    }
-};
-
-template <std::size_t N>
-struct pack<std::array<unsigned char, N>> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::array<unsigned char, N>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.pack_bin(size);
-        o.pack_bin_body(reinterpret_cast<char const*>(v.data()), size);
-
-        return o;
-    }
-};
-
-template <std::size_t N>
-struct object<std::array<unsigned char, N>> {
-    void operator()(msgpack::object& o, const std::array<unsigned char, N>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.type = msgpack::type::BIN;
-        o.via.bin.ptr = reinterpret_cast<char const*>(v.data());
-        o.via.bin.size = size;
-    }
-};
-
-template <std::size_t N>
-struct object_with_zone<std::array<unsigned char, N>> {
-    void operator()(msgpack::object::with_zone& o, const std::array<unsigned char, N>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.type = msgpack::type::BIN;
-        char* ptr = static_cast<char*>(o.zone.allocate_align(size));
-        o.via.bin.ptr = ptr;
-        o.via.bin.size = size;
-        std::memcpy(ptr, v.data(), size);
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
-
-#endif // MSGPACK_TYPE_ARRAY_UNSIGNED_CHAR_HPP
+#endif // MSGPACK_TYPE_CPP11_ARRAY_UNSIGNED_CHAR_HPP

include/msgpack/adaptor/cpp11/forward_list.hpp

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

include/msgpack/adaptor/cpp11/reference_wrapper.hpp

@@ -1,68 +1,16 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2015 KONDO Takatoshi
+// Copyright (C) 2016 KONDO Takatoshi
 //
 //    Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //    http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#ifndef MSGPACK_CPP11_REFERENCE_WRAPPER_HPP
-#define MSGPACK_CPP11_REFERENCE_WRAPPER_HPP
+#ifndef MSGPACK_TYPE_CPP11_REFERENCE_WRAPPER_HPP
+#define MSGPACK_TYPE_CPP11_REFERENCE_WRAPPER_HPP
 
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
+#include "msgpack/v1/adaptor/cpp11/reference_wrapper.hpp"
 
-#include <memory>
-#include <type_traits>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-template <typename T>
-struct convert<std::reference_wrapper<T>> {
-    msgpack::object const& operator()(msgpack::object const& o, std::reference_wrapper<T>& v) const {
-        msgpack::adaptor::convert<T>()(o, v.get());
-        return o;
-    }
-};
-
-template <typename T>
-struct pack<std::reference_wrapper<T>> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::reference_wrapper<T>& v) const {
-        o.pack(v.get());
-        return o;
-    }
-};
-
-template <typename T>
-struct object<std::reference_wrapper<T> > {
-    void operator()(msgpack::object& o, const std::reference_wrapper<T>& v) const {
-        msgpack::adaptor::object<typename std::remove_const<T>::type>()(o, v.get());
-    }
-};
-
-template <typename T>
-struct object_with_zone<std::reference_wrapper<T>> {
-    void operator()(msgpack::object::with_zone& o, const std::reference_wrapper<T>& v) const {
-        msgpack::adaptor::object_with_zone<typename std::remove_const<T>::type>()(o, v.get());
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
-
-#endif // MSGPACK_CPP11_REFERENCE_WRAPPER_HPP
+#endif // MSGPACK_TYPE_CPP11_REFERENCE_WRAPPER_HPP

include/msgpack/adaptor/cpp11/shared_ptr.hpp

@@ -1,82 +1,16 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2015 KONDO Takatoshi
+// Copyright (C) 2016 KONDO Takatoshi
 //
 //    Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //    http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#ifndef MSGPACK_CPP11_SHARED_PTR_HPP
-#define MSGPACK_CPP11_SHARED_PTR_HPP
+#ifndef MSGPACK_TYPE_CPP11_SHARED_PTR_HPP
+#define MSGPACK_TYPE_CPP11_SHARED_PTR_HPP
 
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
+#include "msgpack/v1/adaptor/cpp11/shared_ptr.hpp"
 
-#include <memory>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-template <typename T>
-struct as<std::shared_ptr<T>, typename std::enable_if<msgpack::has_as<T>::value>::type> {
-    std::shared_ptr<T> operator()(msgpack::object const& o) const {
-        if(o.is_nil()) return nullptr;
-        return std::make_shared<T>(o.as<T>());
-    }
-};
-
-template <typename T>
-struct convert<std::shared_ptr<T>> {
-    msgpack::object const& operator()(msgpack::object const& o, std::shared_ptr<T>& v) const {
-        if(o.is_nil()) v.reset();
-        else {
-            v = std::make_shared<T>();
-            msgpack::adaptor::convert<T>()(o, *v);
-        }
-        return o;
-    }
-};
-
-template <typename T>
-struct pack<std::shared_ptr<T>> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::shared_ptr<T>& v) const {
-        if (v) o.pack(*v);
-        else o.pack_nil();
-        return o;
-    }
-};
-
-template <typename T>
-struct object<std::shared_ptr<T> > {
-    void operator()(msgpack::object& o, const std::shared_ptr<T>& v) const {
-        if (v) msgpack::adaptor::object<T>()(o, *v);
-        else o.type = msgpack::type::NIL;
-    }
-};
-
-template <typename T>
-struct object_with_zone<std::shared_ptr<T>> {
-    void operator()(msgpack::object::with_zone& o, const std::shared_ptr<T>& v) const {
-        if (v) msgpack::adaptor::object_with_zone<T>()(o, *v);
-        else o.type = msgpack::type::NIL;
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
-
-#endif // MSGPACK_CPP11_SHARED_PTR_HPP
+#endif // MSGPACK_TYPE_CPP11_SHARED_PTR_HPP

include/msgpack/adaptor/cpp11/tuple.hpp

@@ -1,176 +1,16 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi
+// Copyright (C) 2016 KONDO Takatoshi
 //
 //    Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //    http://www.boost.org/LICENSE_1_0.txt)
 //
-#ifndef MSGPACK_CPP11_TUPLE_HPP
-#define MSGPACK_CPP11_TUPLE_HPP
 
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-#include "msgpack/meta.hpp"
+#ifndef MSGPACK_TYPE_CPP11_TUPLE_HPP
+#define MSGPACK_TYPE_CPP11_TUPLE_HPP
 
-#include <tuple>
+#include "msgpack/v1/adaptor/cpp11/tuple.hpp"
 
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-// --- Pack from tuple to packer stream ---
-template <typename Stream, typename Tuple, std::size_t N>
-struct StdTuplePacker {
-    static void pack(
-        msgpack::packer<Stream>& o,
-        const Tuple& v) {
-        StdTuplePacker<Stream, Tuple, N-1>::pack(o, v);
-        o.pack(std::get<N-1>(v));
-    }
-};
-
-template <typename Stream, typename Tuple>
-struct StdTuplePacker<Stream, Tuple, 0> {
-    static void pack (
-        msgpack::packer<Stream>&,
-        const Tuple&) {
-    }
-};
-
-namespace adaptor {
-
-template <typename... Args>
-struct pack<std::tuple<Args...>> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(
-        msgpack::packer<Stream>& o,
-        const std::tuple<Args...>& v) const {
-        uint32_t size = checked_get_container_size(sizeof...(Args));
-        o.pack_array(size);
-        StdTuplePacker<Stream, decltype(v), sizeof...(Args)>::pack(o, v);
-        return o;
-    }
-};
-
-} // namespace adaptor
-
-// --- Convert from tuple to object ---
-
-template <typename... Args>
-struct StdTupleAs;
-
-template <typename T, typename... Args>
-struct StdTupleAsImpl {
-    static std::tuple<T, Args...> as(msgpack::object const& o) {
-        return std::tuple_cat(
-            std::make_tuple(o.via.array.ptr[o.via.array.size - sizeof...(Args) - 1].as<T>()),
-            StdTupleAs<Args...>::as(o));
-    }
-};
-
-template <typename... Args>
-struct StdTupleAs {
-    static std::tuple<Args...> as(msgpack::object const& o) {
-        return StdTupleAsImpl<Args...>::as(o);
-    }
-};
-
-template <>
-struct StdTupleAs<> {
-    static std::tuple<> as (msgpack::object const&) {
-        return std::tuple<>();
-    }
-};
-
-template <typename Tuple, std::size_t N>
-struct StdTupleConverter {
-    static void convert(
-        msgpack::object const& o,
-        Tuple& v) {
-        StdTupleConverter<Tuple, N-1>::convert(o, v);
-        o.via.array.ptr[N-1].convert<typename std::remove_reference<decltype(std::get<N-1>(v))>::type>(std::get<N-1>(v));
-    }
-};
-
-template <typename Tuple>
-struct StdTupleConverter<Tuple, 0> {
-    static void convert (
-        msgpack::object const&,
-        Tuple&) {
-    }
-};
-
-namespace adaptor {
-
-template <typename... Args>
-struct as<std::tuple<Args...>, typename std::enable_if<msgpack::all_of<msgpack::has_as, Args...>::value>::type>  {
-    std::tuple<Args...> operator()(
-        msgpack::object const& o) const {
-        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        if (o.via.array.size < sizeof...(Args)) { throw msgpack::type_error(); }
-        return StdTupleAs<Args...>::as(o);
-    }
-};
-
-template <typename... Args>
-struct convert<std::tuple<Args...>> {
-    msgpack::object const& operator()(
-        msgpack::object const& o,
-        std::tuple<Args...>& v) const {
-        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        if(o.via.array.size < sizeof...(Args)) { throw msgpack::type_error(); }
-        StdTupleConverter<decltype(v), sizeof...(Args)>::convert(o, v);
-        return o;
-    }
-};
-
-} // namespace adaptor
-
-// --- Convert from tuple to object with zone ---
-template <typename Tuple, std::size_t N>
-struct StdTupleToObjectWithZone {
-    static void convert(
-        msgpack::object::with_zone& o,
-        const Tuple& v) {
-        StdTupleToObjectWithZone<Tuple, N-1>::convert(o, v);
-        o.via.array.ptr[N-1] = msgpack::object(std::get<N-1>(v), o.zone);
-    }
-};
-
-template <typename Tuple>
-struct StdTupleToObjectWithZone<Tuple, 0> {
-    static void convert (
-        msgpack::object::with_zone&,
-        const Tuple&) {
-    }
-};
-
-namespace adaptor {
-
-template <typename... Args>
-struct object_with_zone<std::tuple<Args...>> {
-    void operator()(
-        msgpack::object::with_zone& o,
-        std::tuple<Args...> const& v) const {
-        uint32_t size = checked_get_container_size(sizeof...(Args));
-        o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
-        o.via.array.size = size;
-        StdTupleToObjectWithZone<decltype(v), sizeof...(Args)>::convert(o, v);
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
-
-#endif // MSGPACK_CPP11_TUPLE_HPP
+#endif // MSGPACK_TYPE_CPP11_TUPLE_HPP

include/msgpack/adaptor/cpp11/unique_ptr.hpp

@@ -1,82 +1,16 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2015 KONDO Takatoshi
+// Copyright (C) 2016 KONDO Takatoshi
 //
 //    Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //    http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#ifndef MSGPACK_CPP11_UNIQUE_PTR_HPP
-#define MSGPACK_CPP11_UNIQUE_PTR_HPP
+#ifndef MSGPACK_TYPE_CPP11_UNIQUE_PTR_HPP
+#define MSGPACK_TYPE_CPP11_UNIQUE_PTR_HPP
 
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
+#include "msgpack/v1/adaptor/cpp11/unique_ptr.hpp"
 
-#include <memory>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-template <typename T>
-struct as<std::unique_ptr<T>, typename std::enable_if<msgpack::has_as<T>::value>::type> {
-    std::unique_ptr<T> operator()(msgpack::object const& o) const {
-        if(o.is_nil()) return nullptr;
-        return std::unique_ptr<T>(new T(o.as<T>()));
-    }
-};
-
-template <typename T>
-struct convert<std::unique_ptr<T>> {
-    msgpack::object const& operator()(msgpack::object const& o, std::unique_ptr<T>& v) const {
-        if(o.is_nil()) v.reset();
-        else {
-            v.reset(new T);
-            msgpack::adaptor::convert<T>()(o, *v);
-        }
-        return o;
-    }
-};
-
-template <typename T>
-struct pack<std::unique_ptr<T>> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::unique_ptr<T>& v) const {
-        if (v) o.pack(*v);
-        else o.pack_nil();
-        return o;
-    }
-};
-
-template <typename T>
-struct object<std::unique_ptr<T> > {
-    void operator()(msgpack::object& o, const std::unique_ptr<T>& v) const {
-        if (v) msgpack::adaptor::object<T>()(o, *v);
-        else o.type = msgpack::type::NIL;
-    }
-};
-
-template <typename T>
-struct object_with_zone<std::unique_ptr<T>> {
-    void operator()(msgpack::object::with_zone& o, const std::unique_ptr<T>& v) const {
-        if (v) msgpack::adaptor::object_with_zone<T>()(o, *v);
-        else o.type = msgpack::type::NIL;
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
-
-#endif // MSGPACK_CPP11_UNIQUE_PTR_HPP
+#endif // MSGPACK_TYPE_CPP11_UNIQUE_PTR_HPP

include/msgpack/adaptor/cpp11/unordered_map.hpp

@@ -1,182 +1,16 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2014-2015 KONDO Takatoshi
+// Copyright (C) 2016 KONDO Takatoshi
 //
 //    Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //    http://www.boost.org/LICENSE_1_0.txt)
 //
-#ifndef MSGPACK_TYPE_UNORDERED_MAP_HPP
-#define MSGPACK_TYPE_UNORDERED_MAP_HPP
 
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
+#ifndef MSGPACK_TYPE_CPP11_UNORDERED_MAP_HPP
+#define MSGPACK_TYPE_CPP11_UNORDERED_MAP_HPP
 
-#include <unordered_map>
+#include "msgpack/v1/adaptor/cpp11/unordered_map.hpp"
 
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
-struct as<
-    std::unordered_map<K, V, Hash, Compare, Alloc>,
-    typename std::enable_if<msgpack::has_as<K>::value && msgpack::has_as<V>::value>::type> {
-    std::unordered_map<K, V, Hash, Compare, Alloc> operator()(msgpack::object const& o) const {
-        if (o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
-        msgpack::object_kv* p(o.via.map.ptr);
-        msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
-        std::unordered_map<K, V, Hash, Compare, Alloc> v;
-        for (; p != pend; ++p) {
-            v.emplace(p->key.as<K>(), p->val.as<V>());
-        }
-        return v;
-    }
-};
-
-template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
-struct convert<std::unordered_map<K, V, Hash, Compare, Alloc>> {
-    msgpack::object const& operator()(msgpack::object const& o, std::unordered_map<K, V, Hash, Compare, Alloc>& v) const {
-        if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
-        msgpack::object_kv* p(o.via.map.ptr);
-        msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
-        std::unordered_map<K, V, Hash, Compare, Alloc> tmp;
-        for(; p != pend; ++p) {
-            K key;
-            p->key.convert(key);
-            p->val.convert(tmp[std::move(key)]);
-        }
-        v = std::move(tmp);
-        return o;
-    }
-};
-
-template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
-struct pack<std::unordered_map<K, V, Hash, Compare, Alloc>> {
-    template <typename Stream>
-        msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::unordered_map<K, V, Hash, Compare, Alloc>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.pack_map(size);
-        for(typename std::unordered_map<K, V, Hash, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
-            it != it_end; ++it) {
-            o.pack(it->first);
-            o.pack(it->second);
-        }
-        return o;
-    }
-};
-
-template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
-struct object_with_zone<std::unordered_map<K, V, Hash, Compare, Alloc>> {
-    void operator()(msgpack::object::with_zone& o, const std::unordered_map<K, V, Hash, Compare, Alloc>& v) const {
-        o.type = msgpack::type::MAP;
-        if(v.empty()) {
-            o.via.map.ptr  = nullptr;
-            o.via.map.size = 0;
-        } else {
-            uint32_t size = checked_get_container_size(v.size());
-            msgpack::object_kv* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size));
-            msgpack::object_kv* const pend = p + size;
-            o.via.map.ptr  = p;
-            o.via.map.size = size;
-            typename std::unordered_map<K, V, Hash, Compare, Alloc>::const_iterator it(v.begin());
-            do {
-                p->key = msgpack::object(it->first, o.zone);
-                p->val = msgpack::object(it->second, o.zone);
-                ++p;
-                ++it;
-            } while(p < pend);
-        }
-    }
-};
-
-
-template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
-struct as<
-    std::unordered_multimap<K, V, Hash, Compare, Alloc>,
-    typename std::enable_if<msgpack::has_as<K>::value && msgpack::has_as<V>::value>::type> {
-    std::unordered_multimap<K, V, Hash, Compare, Alloc> operator()(msgpack::object const& o) const {
-        if (o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
-        msgpack::object_kv* p(o.via.map.ptr);
-        msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
-        std::unordered_multimap<K, V, Hash, Compare, Alloc> v;
-        for (; p != pend; ++p) {
-            v.emplace(p->key.as<K>(), p->val.as<V>());
-        }
-        return v;
-    }
-};
-
-template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
-struct convert<std::unordered_multimap<K, V, Hash, Compare, Alloc>> {
-    msgpack::object const& operator()(msgpack::object const& o, std::unordered_multimap<K, V, Hash, Compare, Alloc>& v) const {
-        if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
-        msgpack::object_kv* p(o.via.map.ptr);
-        msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
-        std::unordered_multimap<K, V, Hash, Compare, Alloc> tmp;
-        for(; p != pend; ++p) {
-            std::pair<K, V> value;
-            p->key.convert(value.first);
-            p->val.convert(value.second);
-            tmp.insert(std::move(value));
-        }
-        v = std::move(tmp);
-        return o;
-    }
-};
-
-template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
-struct pack<std::unordered_multimap<K, V, Hash, Compare, Alloc>> {
-    template <typename Stream>
-        msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::unordered_multimap<K, V, Hash, Compare, Alloc>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.pack_map(size);
-        for(typename std::unordered_multimap<K, V, Hash, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
-            it != it_end; ++it) {
-            o.pack(it->first);
-            o.pack(it->second);
-        }
-        return o;
-    }
-};
-
-template <typename K, typename V, typename Hash, typename Compare, typename Alloc>
-struct object_with_zone<std::unordered_multimap<K, V, Hash, Compare, Alloc>> {
-    void operator()(msgpack::object::with_zone& o, const std::unordered_multimap<K, V, Hash, Compare, Alloc>& v) const {
-        o.type = msgpack::type::MAP;
-        if(v.empty()) {
-            o.via.map.ptr  = nullptr;
-            o.via.map.size = 0;
-        } else {
-            uint32_t size = checked_get_container_size(v.size());
-            msgpack::object_kv* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size));
-            msgpack::object_kv* const pend = p + size;
-            o.via.map.ptr  = p;
-            o.via.map.size = size;
-            typename std::unordered_multimap<K, V, Hash, Compare, Alloc>::const_iterator it(v.begin());
-            do {
-                p->key = msgpack::object(it->first, o.zone);
-                p->val = msgpack::object(it->second, o.zone);
-                ++p;
-                ++it;
-            } while(p < pend);
-        }
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
-
-
-#endif // MSGPACK_TYPE_UNORDERED_MAP_HPP
+#endif // MSGPACK_TYPE_CPP11_UNORDERED_MAP_HPP

include/msgpack/adaptor/cpp11/unordered_set.hpp

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

include/msgpack/adaptor/define.hpp

@@ -1,7 +1,7 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi
+// 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
@@ -10,22 +10,8 @@
 #ifndef MSGPACK_DEFINE_HPP
 #define MSGPACK_DEFINE_HPP
 
-#include "msgpack/cpp_config.hpp"
+#include "msgpack/adaptor/define_decl.hpp"
 
-#if defined(MSGPACK_USE_CPP03)
-#include "detail/cpp03_define_array.hpp"
-#include "detail/cpp03_define_map.hpp"
-#else  // MSGPACK_USE_CPP03
-#include "detail/cpp11_define_array.hpp"
-#include "detail/cpp11_define_map.hpp"
-#endif // MSGPACK_USE_CPP03
-
-#if defined(MSGPACK_USE_DEFINE_MAP)
-#define MSGPACK_DEFINE MSGPACK_DEFINE_MAP
-#define MSGPACK_BASE MSGPACK_BASE_MAP
-#else  // defined(MSGPACK_USE_DEFINE_MAP)
-#define MSGPACK_DEFINE MSGPACK_DEFINE_ARRAY
-#define MSGPACK_BASE MSGPACK_BASE_ARRAY
-#endif // defined(MSGPACK_USE_DEFINE_MAP)
+#include "msgpack/v1/adaptor/define.hpp"
 
 #endif // MSGPACK_DEFINE_HPP

include/msgpack/adaptor/define_decl.hpp

@@ -0,0 +1,143 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2016 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_DEFINE_DECL_HPP
+#define MSGPACK_DEFINE_DECL_HPP
+
+// BOOST_PP_VARIADICS is defined in boost/preprocessor/config/config.hpp
+// http://www.boost.org/libs/preprocessor/doc/ref/variadics.html
+// However, supporting compiler detection is not complete. msgpack-c requires
+// variadic macro arguments support. So BOOST_PP_VARIADICS is defined here explicitly.
+#if !defined(MSGPACK_PP_VARIADICS)
+#define MSGPACK_PP_VARIADICS
+#endif
+
+#include <msgpack/preprocessor.hpp>
+
+#include "msgpack/versioning.hpp"
+
+// for MSGPACK_ADD_ENUM
+#include "msgpack/adaptor/int.hpp"
+
+#define MSGPACK_DEFINE_ARRAY(...) \
+    template <typename Packer> \
+    void msgpack_pack(Packer& pk) const \
+    { \
+        msgpack::type::make_define_array(__VA_ARGS__).msgpack_pack(pk); \
+    } \
+    void msgpack_unpack(msgpack::object const& o) \
+    { \
+        msgpack::type::make_define_array(__VA_ARGS__).msgpack_unpack(o); \
+    }\
+    template <typename MSGPACK_OBJECT> \
+    void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone& z) const \
+    { \
+        msgpack::type::make_define_array(__VA_ARGS__).msgpack_object(o, z); \
+    }
+
+#define MSGPACK_BASE_ARRAY(base) (*const_cast<base *>(static_cast<base const*>(this)))
+#define MSGPACK_NVP(name, value) (name) (value)
+
+#define MSGPACK_DEFINE_MAP_EACH_PROC(r, data, elem) \
+    MSGPACK_PP_IF( \
+        MSGPACK_PP_IS_BEGIN_PARENS(elem), \
+        elem, \
+        (MSGPACK_PP_STRINGIZE(elem))(elem) \
+    )
+
+#define MSGPACK_DEFINE_MAP_IMPL(...) \
+    MSGPACK_PP_SEQ_TO_TUPLE( \
+        MSGPACK_PP_SEQ_FOR_EACH( \
+            MSGPACK_DEFINE_MAP_EACH_PROC, \
+            0, \
+            MSGPACK_PP_VARIADIC_TO_SEQ(__VA_ARGS__) \
+        ) \
+    )
+
+#define MSGPACK_DEFINE_MAP(...) \
+    template <typename Packer> \
+    void msgpack_pack(Packer& pk) const \
+    { \
+        msgpack::type::make_define_map \
+            MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \
+            .msgpack_pack(pk); \
+    } \
+    void msgpack_unpack(msgpack::object const& o) \
+    { \
+        msgpack::type::make_define_map \
+            MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \
+            .msgpack_unpack(o); \
+    }\
+    template <typename MSGPACK_OBJECT> \
+    void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone& z) const \
+    { \
+        msgpack::type::make_define_map \
+            MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \
+            .msgpack_object(o, z); \
+    }
+
+#define MSGPACK_BASE_MAP(base) \
+    (MSGPACK_PP_STRINGIZE(base))(*const_cast<base *>(static_cast<base const*>(this)))
+
+// MSGPACK_ADD_ENUM must be used in the global namespace.
+#define MSGPACK_ADD_ENUM(enum_name) \
+  namespace msgpack { \
+  /** @cond */ \
+  MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) { \
+  /** @endcond */ \
+  namespace adaptor { \
+    template<> \
+    struct convert<enum_name> { \
+      msgpack::object const& operator()(msgpack::object const& o, enum_name& v) const { \
+        msgpack::underlying_type<enum_name>::type tmp; \
+        msgpack::operator>>(o, tmp);                   \
+        v = static_cast<enum_name>(tmp);   \
+        return o; \
+      } \
+    }; \
+    template<> \
+    struct object<enum_name> { \
+      void operator()(msgpack::object& o, const enum_name& v) const { \
+        msgpack::underlying_type<enum_name>::type tmp = static_cast<msgpack::underlying_type<enum_name>::type>(v); \
+        msgpack::operator<<(o, tmp);                                    \
+      } \
+    }; \
+    template<> \
+    struct object_with_zone<enum_name> { \
+      void operator()(msgpack::object::with_zone& o, const enum_name& v) const {  \
+        msgpack::underlying_type<enum_name>::type tmp = static_cast<msgpack::underlying_type<enum_name>::type>(v); \
+        msgpack::operator<<(o, tmp);                                    \
+      } \
+    }; \
+    template <> \
+    struct pack<enum_name> { \
+      template <typename Stream> \
+      msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const enum_name& v) const { \
+          return msgpack::operator<<(o, static_cast<msgpack::underlying_type<enum_name>::type>(v)); \
+      } \
+    }; \
+  } \
+  /** @cond */ \
+  } \
+  /** @endcond */ \
+  }
+
+#if defined(MSGPACK_USE_DEFINE_MAP)
+#define MSGPACK_DEFINE MSGPACK_DEFINE_MAP
+#define MSGPACK_BASE MSGPACK_BASE_MAP
+#else  // defined(MSGPACK_USE_DEFINE_MAP)
+#define MSGPACK_DEFINE MSGPACK_DEFINE_ARRAY
+#define MSGPACK_BASE MSGPACK_BASE_ARRAY
+#endif // defined(MSGPACK_USE_DEFINE_MAP)
+
+
+#include "msgpack/v1/adaptor/define_decl.hpp"
+#include "msgpack/v2/adaptor/define_decl.hpp"
+
+#endif // MSGPACK_DEFINE_DECL_HPP

include/msgpack/adaptor/deque.hpp

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

include/msgpack/adaptor/ext.hpp

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

include/msgpack/adaptor/ext_decl.hpp

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

include/msgpack/adaptor/fixint.hpp

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

include/msgpack/adaptor/fixint_decl.hpp

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

include/msgpack/adaptor/float.hpp

@@ -1,7 +1,7 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+// Copyright (C) 2016 KONDO Takatoshi
 //
 //    Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
@@ -10,114 +10,6 @@
 #ifndef MSGPACK_TYPE_FLOAT_HPP
 #define MSGPACK_TYPE_FLOAT_HPP
 
-#include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include <vector>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-// FIXME check overflow, underflow
-
-namespace adaptor {
-
-template <>
-struct convert<float> {
-    msgpack::object const& operator()(msgpack::object const& o, float& v) const {
-        if(o.type == msgpack::type::FLOAT) {
-            v = static_cast<float>(o.via.f64);
-        }
-        else if (o.type == msgpack::type::POSITIVE_INTEGER) {
-            v = static_cast<float>(o.via.u64);
-        }
-        else if (o.type == msgpack::type::NEGATIVE_INTEGER) {
-            v = static_cast<float>(o.via.i64);
-        }
-        else {
-            throw msgpack::type_error();
-        }
-        return o;
-    }
-};
-
-template <>
-struct pack<float> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const float& v) const {
-        o.pack_float(v);
-        return o;
-    }
-};
-
-
-template <>
-struct convert<double> {
-    msgpack::object const& operator()(msgpack::object const& o, double& v) const {
-        if(o.type == msgpack::type::FLOAT) {
-            v = o.via.f64;
-        }
-        else if (o.type == msgpack::type::POSITIVE_INTEGER) {
-            v = static_cast<double>(o.via.u64);
-        }
-        else if (o.type == msgpack::type::NEGATIVE_INTEGER) {
-            v = static_cast<double>(o.via.i64);
-        }
-        else {
-            throw msgpack::type_error();
-        }
-        return o;
-    }
-};
-
-template <>
-struct pack<double> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const double& v) const {
-        o.pack_double(v);
-        return o;
-    }
-};
-
-
-template <>
-struct object<float> {
-    void operator()(msgpack::object& o, float v) const {
-        o.type = msgpack::type::FLOAT;
-        o.via.f64 = static_cast<double>(v);
-    }
-};
-
-template <>
-struct object<double> {
-    void operator()(msgpack::object& o, double v) const {
-        o.type = msgpack::type::FLOAT;
-        o.via.f64 = v;
-    }
-};
-
-template <>
-struct object_with_zone<float> {
-    void operator()(msgpack::object::with_zone& o, float v) const {
-        static_cast<msgpack::object&>(o) << v;
-    }
-};
-
-template <>
-struct object_with_zone<double> {
-    void operator()(msgpack::object::with_zone& o, double v) const {
-        static_cast<msgpack::object&>(o) << v;
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-}  // namespace msgpack
+#include "msgpack/v1/adaptor/float.hpp"
 
 #endif // MSGPACK_TYPE_FLOAT_HPP

include/msgpack/adaptor/int.hpp

@@ -1,7 +1,7 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+// Copyright (C) 2016 KONDO Takatoshi
 //
 //    Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
@@ -10,421 +10,8 @@
 #ifndef MSGPACK_TYPE_INT_HPP
 #define MSGPACK_TYPE_INT_HPP
 
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include <limits>
+#include "msgpack/adaptor/int_decl.hpp"
 
-namespace msgpack {
+#include "msgpack/v1/adaptor/int.hpp"
 
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1){
-/// @endcond
-
-namespace type {
-namespace detail {
-    template <typename T, bool Signed>
-    struct convert_integer_sign;
-
-    template <typename T>
-    struct convert_integer_sign<T, true> {
-        static T convert(msgpack::object const& o) {
-            if(o.type == msgpack::type::POSITIVE_INTEGER) {
-                if(o.via.u64 > static_cast<uint64_t>(std::numeric_limits<T>::max()))
-                    { throw msgpack::type_error(); }
-                return static_cast<T>(o.via.u64);
-            } else if(o.type == msgpack::type::NEGATIVE_INTEGER) {
-                if(o.via.i64 < static_cast<int64_t>(std::numeric_limits<T>::min()))
-                    { throw msgpack::type_error(); }
-                return static_cast<T>(o.via.i64);
-            }
-            throw msgpack::type_error();
-        }
-    };
-
-    template <typename T>
-    struct convert_integer_sign<T, false> {
-        static T convert(msgpack::object const& o) {
-            if(o.type == msgpack::type::POSITIVE_INTEGER) {
-                if(o.via.u64 > static_cast<uint64_t>(std::numeric_limits<T>::max()))
-                    { throw msgpack::type_error(); }
-                return static_cast<T>(o.via.u64);
-            }
-            throw msgpack::type_error();
-        }
-    };
-
-    template <typename T>
-    struct is_signed {
-        static const bool value = std::numeric_limits<T>::is_signed;
-    };
-
-    template <typename T>
-    static inline T convert_integer(msgpack::object const& o)
-    {
-        return detail::convert_integer_sign<T, is_signed<T>::value>::convert(o);
-    }
-
-    template <bool Signed>
-    struct object_char_sign;
-
-    template <>
-    struct object_char_sign<true> {
-        template <typename T>
-        static typename msgpack::enable_if<msgpack::is_same<T, char>::value>::type
-        make(msgpack::object& o, T v) {
-            if (v < 0) {
-                o.type = msgpack::type::NEGATIVE_INTEGER;
-                o.via.i64 = v;
-            }
-            else {
-                o.type = msgpack::type::POSITIVE_INTEGER;
-                o.via.u64 = v;
-            }
-        }
-    };
-
-    template <>
-    struct object_char_sign<false> {
-        static void make(msgpack::object& o, char v) {
-            o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v;
-        }
-    };
-
-    static inline void object_char(msgpack::object& o, char v) {
-        return object_char_sign<is_signed<char>::value>::make(o, v);
-    }
-
-}  // namespace detail
-}  // namespace type
-
-namespace adaptor {
-
-template <>
-struct convert<char> {
-    msgpack::object const& operator()(msgpack::object const& o, char& v) const
-    { v = type::detail::convert_integer<char>(o); return o; }
-};
-
-template <>
-struct convert<signed char> {
-    msgpack::object const& operator()(msgpack::object const& o, signed char& v) const
-    { v = type::detail::convert_integer<signed char>(o); return o; }
-};
-
-template <>
-struct convert<signed short> {
-    msgpack::object const& operator()(msgpack::object const& o, signed short& v) const
-    { v = type::detail::convert_integer<signed short>(o); return o; }
-};
-
-template <>
-struct convert<signed int> {
-    msgpack::object const& operator()(msgpack::object const& o, signed int& v) const
-    { v = type::detail::convert_integer<signed int>(o); return o; }
-};
-
-template <>
-struct convert<signed long> {
-    msgpack::object const& operator()(msgpack::object const& o, signed long& v) const
-    { v = type::detail::convert_integer<signed long>(o); return o; }
-};
-
-template <>
-struct convert<signed long long> {
-    msgpack::object const& operator()(msgpack::object const& o, signed long long& v) const
-    { v = type::detail::convert_integer<signed long long>(o); return o; }
-};
-
-
-template <>
-struct convert<unsigned char> {
-    msgpack::object const& operator()(msgpack::object const& o, unsigned char& v) const
-    { v = type::detail::convert_integer<unsigned char>(o); return o; }
-};
-
-template <>
-struct convert<unsigned short> {
-    msgpack::object const& operator()(msgpack::object const& o, unsigned short& v) const
-    { v = type::detail::convert_integer<unsigned short>(o); return o; }
-};
-
-template <>
-struct convert<unsigned int> {
-    msgpack::object const& operator()(msgpack::object const& o, unsigned int& v) const
-    { v = type::detail::convert_integer<unsigned int>(o); return o; }
-};
-
-template <>
-struct convert<unsigned long> {
-    msgpack::object const& operator()(msgpack::object const& o, unsigned long& v) const
-    { v = type::detail::convert_integer<unsigned long>(o); return o; }
-};
-
-template <>
-struct convert<unsigned long long> {
-    msgpack::object const& operator()(msgpack::object const& o, unsigned long long& v) const
-    { v = type::detail::convert_integer<unsigned long long>(o); return o; }
-};
-
-
-template <>
-struct pack<char> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, char v) const
-    { o.pack_char(v); return o; }
-};
-
-template <>
-struct pack<signed char> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, signed char v) const
-    { o.pack_signed_char(v); return o; }
-};
-
-template <>
-struct pack<signed short> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, signed short v) const
-    { o.pack_short(v); return o; }
-};
-
-template <>
-struct pack<signed int> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, signed int v) const
-    { o.pack_int(v); return o; }
-};
-
-template <>
-struct pack<signed long> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, signed long v) const
-    { o.pack_long(v); return o; }
-};
-
-template <>
-struct pack<signed long long> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, signed long long v) const
-    { o.pack_long_long(v); return o; }
-};
-
-
-template <>
-struct pack<unsigned char> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, unsigned char v) const
-    { o.pack_unsigned_char(v); return o; }
-};
-
-template <>
-struct pack<unsigned short> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, unsigned short v) const
-    { o.pack_unsigned_short(v); return o; }
-};
-
-template <>
-struct pack<unsigned int> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, unsigned int v) const
-    { o.pack_unsigned_int(v); return o; }
-};
-
-template <>
-struct pack<unsigned long> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, unsigned long v) const
-    { o.pack_unsigned_long(v); return o; }
-};
-
-template <>
-struct pack<unsigned long long> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, unsigned long long v) const
-    { o.pack_unsigned_long_long(v); return o; }
-};
-
-
-template <>
-struct object<char> {
-    void operator()(msgpack::object& o, char v) const
-    { type::detail::object_char(o, v); }
-};
-
-template <>
-struct object<signed char> {
-    void operator()(msgpack::object& o, signed char v) const {
-        if (v < 0) {
-            o.type = msgpack::type::NEGATIVE_INTEGER;
-            o.via.i64 = v;
-        }
-        else {
-            o.type = msgpack::type::POSITIVE_INTEGER;
-            o.via.u64 = v;
-        }
-    }
-};
-
-template <>
-struct object<signed short> {
-    void operator()(msgpack::object& o, signed short v) const {
-        if (v < 0) {
-            o.type = msgpack::type::NEGATIVE_INTEGER;
-            o.via.i64 = v;
-        }
-        else {
-            o.type = msgpack::type::POSITIVE_INTEGER;
-            o.via.u64 = v;
-        }
-    }
-};
-
-template <>
-struct object<signed int> {
-    void operator()(msgpack::object& o, signed int v) const {
-        if (v < 0) {
-            o.type = msgpack::type::NEGATIVE_INTEGER;
-            o.via.i64 = v;
-        }
-        else {
-            o.type = msgpack::type::POSITIVE_INTEGER;
-            o.via.u64 = v;
-        }
-    }
-};
-
-template <>
-struct object<signed long> {
-    void operator()(msgpack::object& o, signed long v) const {
-        if (v < 0) {
-            o.type = msgpack::type::NEGATIVE_INTEGER;
-            o.via.i64 = v;
-        }
-        else {
-            o.type = msgpack::type::POSITIVE_INTEGER;
-            o.via.u64 = v;
-        }
-    }
-};
-
-template <>
-struct object<signed long long> {
-    void operator()(msgpack::object& o, signed long long v) const {
-        if (v < 0) {
-            o.type = msgpack::type::NEGATIVE_INTEGER;
-            o.via.i64 = v;
-        }
-        else{
-            o.type = msgpack::type::POSITIVE_INTEGER;
-            o.via.u64 = v;
-        }
-    }
-};
-
-template <>
-struct object<unsigned char> {
-    void operator()(msgpack::object& o, unsigned char v) const
-    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; }
-};
-
-template <>
-struct object<unsigned short> {
-    void operator()(msgpack::object& o, unsigned short v) const
-    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; }
-};
-
-template <>
-struct object<unsigned int> {
-    void operator()(msgpack::object& o, unsigned int v) const
-    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; }
-};
-
-template <>
-struct object<unsigned long> {
-    void operator()(msgpack::object& o, unsigned long v) const
-    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; }
-};
-
-template <>
-struct object<unsigned long long> {
-    void operator()(msgpack::object& o, unsigned long long v) const
-    { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; }
-};
-
-
-template <>
-struct object_with_zone<char> {
-    void operator()(msgpack::object::with_zone& o, char v) const
-    { static_cast<msgpack::object&>(o) << v; }
-};
-
-template <>
-struct object_with_zone<signed char> {
-    void operator()(msgpack::object::with_zone& o, signed char v) const
-    { static_cast<msgpack::object&>(o) << v; }
-};
-
-template <>
-struct object_with_zone<signed short> {
-    void operator()(msgpack::object::with_zone& o, signed short v) const
-    { static_cast<msgpack::object&>(o) << v; }
-};
-
-template <>
-struct object_with_zone<signed int> {
-    void operator()(msgpack::object::with_zone& o, signed int v) const
-    { static_cast<msgpack::object&>(o) << v; }
-};
-
-template <>
-struct object_with_zone<signed long> {
-    void operator()(msgpack::object::with_zone& o, signed long v) const
-    { static_cast<msgpack::object&>(o) << v; }
-};
-
-template <>
-struct object_with_zone<signed long long> {
-    void operator()(msgpack::object::with_zone& o, const signed long long& v) const
-    { static_cast<msgpack::object&>(o) << v; }
-};
-
-template <>
-struct object_with_zone<unsigned char> {
-    void operator()(msgpack::object::with_zone& o, unsigned char v) const
-    { static_cast<msgpack::object&>(o) << v; }
-};
-
-template <>
-struct object_with_zone<unsigned short> {
-    void operator()(msgpack::object::with_zone& o, unsigned short v) const
-    { static_cast<msgpack::object&>(o) << v; }
-};
-
-template <>
-struct object_with_zone<unsigned int> {
-    void operator()(msgpack::object::with_zone& o, unsigned int v) const
-    { static_cast<msgpack::object&>(o) << v; }
-};
-
-template <>
-struct object_with_zone<unsigned long> {
-    void operator()(msgpack::object::with_zone& o, unsigned long v) const
-    { static_cast<msgpack::object&>(o) << v; }
-};
-
-template <>
-struct object_with_zone<unsigned long long> {
-    void operator()(msgpack::object::with_zone& o, const unsigned long long& v) const
-    { static_cast<msgpack::object&>(o) << v; }
-};
-
-} // namespace adaptor
-
-/// @cond
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-}  // namespace msgpack
-
-#endif /* msgpack/type/int.hpp */
+#endif // MSGPACK_TYPE_INT_HPP

include/msgpack/adaptor/int_decl.hpp

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

include/msgpack/adaptor/list.hpp

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

include/msgpack/adaptor/map.hpp

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

include/msgpack/adaptor/map_decl.hpp

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

include/msgpack/adaptor/msgpack_tuple.hpp

@@ -10,12 +10,8 @@
 #ifndef MSGPACK_MSGPACK_TUPLE_HPP
 #define MSGPACK_MSGPACK_TUPLE_HPP
 
-#include "msgpack/cpp_config.hpp"
+#include "msgpack/adaptor/msgpack_tuple_decl.hpp"
 
-#if defined(MSGPACK_USE_CPP03)
-#include "detail/cpp03_msgpack_tuple.hpp"
-#else  // MSGPACK_USE_CPP03
-#include "detail/cpp11_msgpack_tuple.hpp"
-#endif // MSGPACK_USE_CPP03
+#include "msgpack/v1/adaptor/msgpack_tuple.hpp"
 
 #endif // MSGPACK_MSGPACK_TUPLE_HPP

include/msgpack/adaptor/msgpack_tuple_decl.hpp

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

include/msgpack/adaptor/nil.hpp

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

include/msgpack/adaptor/nil_decl.hpp

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

include/msgpack/adaptor/pair.hpp

@@ -1,7 +1,7 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+// Copyright (C) 2016 KONDO Takatoshi
 //
 //    Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
@@ -10,74 +10,6 @@
 #ifndef MSGPACK_TYPE_PAIR_HPP
 #define MSGPACK_TYPE_PAIR_HPP
 
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/meta.hpp"
-
-#include <utility>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-#if !defined(MSGPACK_USE_CPP03)
-
-template <typename T1, typename T2>
-struct as<std::pair<T1, T2>,
-          typename std::enable_if<msgpack::all_of<msgpack::has_as, T1, T2>::value>::type> {
-    std::pair<T1, T2> operator()(msgpack::object const& o) const {
-        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        if (o.via.array.size != 2) { throw msgpack::type_error(); }
-        return std::make_pair(o.via.array.ptr[0].as<T1>(), o.via.array.ptr[1].as<T2>());
-    }
-};
-
-#endif // !defined(MSGPACK_USE_CPP03)
-
-template <typename T1, typename T2>
-struct convert<std::pair<T1, T2> > {
-    msgpack::object const& operator()(msgpack::object const& o, std::pair<T1, T2>& v) const {
-        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        if(o.via.array.size != 2) { throw msgpack::type_error(); }
-        o.via.array.ptr[0].convert(v.first);
-        o.via.array.ptr[1].convert(v.second);
-        return o;
-    }
-};
-
-template <typename T1, typename T2>
-struct pack<std::pair<T1, T2> > {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::pair<T1, T2>& v) const {
-        o.pack_array(2);
-        o.pack(v.first);
-        o.pack(v.second);
-        return o;
-    }
-};
-
-template <typename T1, typename T2>
-struct object_with_zone<std::pair<T1, T2> > {
-    void operator()(msgpack::object::with_zone& o, const std::pair<T1, T2>& v) const {
-        o.type = msgpack::type::ARRAY;
-        msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*2));
-        o.via.array.ptr = p;
-        o.via.array.size = 2;
-        p[0] = msgpack::object(v.first, o.zone);
-        p[1] = msgpack::object(v.second, o.zone);
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-}  // namespace msgpack
+#include "msgpack/v1/adaptor/pair.hpp"
 
 #endif // MSGPACK_TYPE_PAIR_HPP

include/msgpack/adaptor/raw.hpp

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

include/msgpack/adaptor/raw_decl.hpp

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

include/msgpack/adaptor/set.hpp

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

include/msgpack/adaptor/size_equal_only.hpp

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

include/msgpack/adaptor/size_equal_only_decl.hpp

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

include/msgpack/adaptor/string.hpp

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

include/msgpack/adaptor/tr1/unordered_map.hpp

@@ -80,7 +80,7 @@ struct object_with_zone<MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc>
     void operator()(msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc>& v) const {
         o.type = msgpack::type::MAP;
         if(v.empty()) {
-            o.via.map.ptr  = nullptr;
+            o.via.map.ptr  = MSGPACK_NULLPTR;
             o.via.map.size = 0;
         } else {
             uint32_t size = checked_get_container_size(v.size());
@@ -137,7 +137,7 @@ struct object_with_zone<MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Al
     void operator()(msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Alloc>& v) const {
         o.type = msgpack::type::MAP;
         if(v.empty()) {
-            o.via.map.ptr  = nullptr;
+            o.via.map.ptr  = MSGPACK_NULLPTR;
             o.via.map.size = 0;
         } else {
             uint32_t size = checked_get_container_size(v.size());

include/msgpack/adaptor/tr1/unordered_set.hpp

@@ -78,7 +78,7 @@ struct object_with_zone<MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc>
     void operator()(msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc>& v) const {
         o.type = msgpack::type::ARRAY;
         if(v.empty()) {
-            o.via.array.ptr = nullptr;
+            o.via.array.ptr = MSGPACK_NULLPTR;
             o.via.array.size = 0;
         } else {
             uint32_t size = checked_get_container_size(v.size());
@@ -132,7 +132,7 @@ struct object_with_zone<MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Al
     void operator()(msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Alloc>& v) const {
         o.type = msgpack::type::ARRAY;
         if(v.empty()) {
-            o.via.array.ptr = nullptr;
+            o.via.array.ptr = MSGPACK_NULLPTR;
             o.via.array.size = 0;
         } else {
             uint32_t size = checked_get_container_size(v.size());

include/msgpack/adaptor/v4raw.hpp

@@ -1,7 +1,7 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi
+// 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
@@ -10,97 +10,8 @@
 #ifndef MSGPACK_TYPE_V4RAW_HPP
 #define MSGPACK_TYPE_V4RAW_HPP
 
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include <cstring>
-#include <string>
+#include "msgpack/adaptor/v4raw_decl.hpp"
 
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace type {
-
-struct v4raw_ref {
-    v4raw_ref() : size(0), ptr(nullptr) {}
-    v4raw_ref(const char* p, uint32_t s) : size(s), ptr(p) {}
-
-    uint32_t size;
-    const char* ptr;
-
-    std::string str() const { return std::string(ptr, size); }
-
-    bool operator== (const v4raw_ref& x) const
-    {
-        return size == x.size && std::memcmp(ptr, x.ptr, size) == 0;
-    }
-
-    bool operator!= (const v4raw_ref& x) const
-    {
-        return !(*this == x);
-    }
-
-    bool operator< (const v4raw_ref& x) const
-    {
-        if(size == x.size) { return std::memcmp(ptr, x.ptr, size) < 0; }
-        else { return size < x.size; }
-    }
-
-    bool operator> (const v4raw_ref& x) const
-    {
-        if(size == x.size) { return std::memcmp(ptr, x.ptr, size) > 0; }
-        else { return size > x.size; }
-    }
-};
-
-} // namespace type
-
-namespace adaptor {
-
-template <>
-struct convert<msgpack::type::v4raw_ref> {
-    msgpack::object const& operator()(msgpack::object const& o, msgpack::type::v4raw_ref& v) const {
-        if(o.type != msgpack::type::STR) { throw msgpack::type_error(); }
-        v.ptr  = o.via.str.ptr;
-        v.size = o.via.str.size;
-        return o;
-    }
-};
-
-template <>
-struct pack<msgpack::type::v4raw_ref> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const msgpack::type::v4raw_ref& v) const {
-        o.pack_v4raw(v.size);
-        o.pack_v4raw_body(v.ptr, v.size);
-        return o;
-    }
-};
-
-template <>
-struct object<msgpack::type::v4raw_ref> {
-    void operator()(msgpack::object& o, const msgpack::type::v4raw_ref& v) const {
-        o.type = msgpack::type::STR;
-        o.via.str.ptr = v.ptr;
-        o.via.str.size = v.size;
-    }
-};
-
-template <>
-struct object_with_zone<msgpack::type::v4raw_ref> {
-    void operator()(msgpack::object::with_zone& o, const msgpack::type::v4raw_ref& v) const {
-        static_cast<msgpack::object&>(o) << v;
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
+#include "msgpack/v1/adaptor/v4raw.hpp"
 
 #endif // MSGPACK_TYPE_V4RAW_HPP