Merge pull request #621 from redboltz/v2.1.4

Updated the version to 2.1.4.

.travis.yml

@@ -10,7 +10,7 @@ install:
  - 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
+ - if [ "$CXX" = "clang++" ] && [ "$TRAVIS_OS_NAME" == "linux" ]; then export CXX="clang++-3.9" CC="clang-3.9"; 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
@@ -27,7 +27,7 @@ install:
 # 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
+ - 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-chrono --with-context --with-system --with-timer address-model=${ARCH} install > /dev/null && cd ..; fi
 
 matrix:
   include:
@@ -36,7 +36,7 @@ matrix:
       env: ACTION="ci/build_cmake.sh"  CXX11="ON" ARCH="64"   BOOST="ON" SHARED="ON"  CHAR_SIGN="unsigned" API_VERSION="1"
     - os: osx
       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"
+      env:  ACTION="ci/build_cmake.sh" CXX11="ON" ARCH="64"   BOOST="ON" SHARED="ON"  CHAR_SIGN="signed"   API_VERSION="2"
     - os: osx
       compiler: clang
       env: ACTION="ci/build_cmake.sh"  CXX11="ON" ARCH="64"              SHARED="ON"  CHAR_SIGN="signed"   API_VERSION="2"
@@ -50,7 +50,7 @@ matrix:
         apt:
           sources:
             - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.7
+            - llvm-toolchain-precise-3.9
             - llvm-toolchain-precise
           packages:
             - g++-multilib
@@ -58,7 +58,7 @@ matrix:
             - gcc-5-multilib
             - g++-5-multilib
             - bzip2
-            - clang-3.7
+            - clang-3.9
             - libc6-dbg
     - os: linux
       compiler: clang
@@ -67,7 +67,7 @@ matrix:
         apt:
           sources:
             - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.7
+            - llvm-toolchain-precise-3.9
             - llvm-toolchain-precise
           packages:
             - g++-multilib
@@ -79,7 +79,7 @@ matrix:
             - libc6-i386
             - lib32z1-dev
             - bzip2
-            - clang-3.7
+            - clang-3.9
             - libc6-dbg
     - os: linux
       compiler: clang
@@ -88,7 +88,7 @@ matrix:
         apt:
           sources:
             - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.7
+            - llvm-toolchain-precise-3.9
             - llvm-toolchain-precise
           packages:
             - g++-multilib
@@ -96,7 +96,7 @@ matrix:
             - gcc-5-multilib
             - g++-5-multilib
             - bzip2
-            - clang-3.7
+            - clang-3.9
             - libc6-dbg
     - os: linux
       compiler: clang
@@ -105,7 +105,7 @@ matrix:
         apt:
           sources:
             - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.7
+            - llvm-toolchain-precise-3.9
             - llvm-toolchain-precise
           packages:
             - g++-multilib
@@ -117,7 +117,7 @@ matrix:
             - libc6-i386
             - lib32z1-dev
             - bzip2
-            - clang-3.7
+            - clang-3.9
             - libc6-dbg
     - os: linux
       compiler: gcc

CHANGELOG.md

@@ -1,3 +1,34 @@
+# 2017-08-03 version 2.1.4
+  * Add boost asio examples (including zlib) (#610)
+  * Remove some warnings (#611)
+  * Fix unpack visitor to treat float32/64 correctly (#613)
+  * Improve documents (#616)
+  * Fix alignment problem on some platform (#617, #518)
+  * Fix conflict std::tuple, std::pair, and boost::fusion::sequence problem (#619)
+
+# 2017-06-15 version 2.1.3
+  * Improve build system (#603)
+  * Add C++17 adaptors `std::optional` and `std::string_view`. (#607, #608)
+  * Improve cross platform configuration (#601)
+  * Remove some warnings (#599, #602, #605)
+
+# 2017-06-07 version 2.1.2
+
+* Improve documents (#565)
+  * Fix empty map parse bug (#568)
+  * Improve build system (#569, #570, #572, #579, #591, #592)
+  * Remove some warnings (#574, #578, #586, #588)
+  * Improve cross platform configuration (#577, #582)
+  * Add cmake package config support (#580)
+  * Fix streaming unpack bug (#585)
+
+# 2017-02-04 version 2.1.1
+
+  * Fix unpacker's buffer management bug (#561)
+  * Add boost string_view adaptor (#558)
+  * Remove some warnings (#557, #559)
+  * Improve coding style (#556)
+
 # 2017-01-10 version 2.1.0
 
 ## << breaking changes >>

CMakeLists.txt

@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED (VERSION 2.8.6)
+CMAKE_MINIMUM_REQUIRED (VERSION 2.8.12)
 
 IF ((CMAKE_VERSION VERSION_GREATER 3.1) OR
     (CMAKE_VERSION VERSION_EQUAL 3.1))
@@ -50,7 +50,15 @@ IF (MSGPACK_USE_X3_PARSE)
       ENDIF ()
    ENDIF ()
 ELSE ()
-   IF (MSGPACK_CXX11)
+   IF (MSGPACK_CXX17)
+      IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+         SET (CMAKE_CXX_FLAGS "-std=c++17 ${CMAKE_CXX_FLAGS}")
+      ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+         SET (CMAKE_CXX_FLAGS "-std=c++17 ${CMAKE_CXX_FLAGS}")
+      ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+         MESSAGE ( FATAL_ERROR "MSVC doesn't support C++17.")
+      ENDIF ()
+   ELSEIF (MSGPACK_CXX11)
       IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
          SET (CMAKE_CXX_FLAGS "-std=c++11 ${CMAKE_CXX_FLAGS}")
       ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
@@ -92,21 +100,20 @@ 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 context timer system)
-IF (Boost_INCLUDE_DIRS)
+   SET (Boost_USE_MULTITHREADED      ON)
+   SET (Boost_USE_STATIC_RUNTIME    OFF)
+   FIND_PACKAGE (Boost REQUIRED COMPONENTS chrono context system timer)
    INCLUDE_DIRECTORIES (
       ${Boost_INCLUDE_DIRS}
    )
-ENDIF ()
-IF (MSGPACK_BOOST_DIR)
+   LINK_DIRECTORIES (
+      ${Boost_LIBRARY_DIRS}
+   )
+   IF (MSGPACK_BOOST_DIR)
       INCLUDE_DIRECTORIES (
          ${MSGPACK_BOOST_DIR}
       )
+   ENDIF ()
 ENDIF ()
 
 IF (MSGPACK_CHAR_SIGN)
@@ -127,7 +134,7 @@ FOREACH (F ${PREDEF_FILES})
    FILE (READ ${CMAKE_CURRENT_SOURCE_DIR}/external/boost/predef/include/boost/${F} CONTENT)
    STRING(REPLACE "BOOST_" "MSGPACK_" CONTENT ${CONTENT})
    STRING(REPLACE "boost/" "msgpack/" CONTENT ${CONTENT})
-   FILE (WRITE ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/${F} ${CONTENT})
+   FILE (GENERATE OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/${F} CONTENT ${CONTENT})
 ENDFOREACH ()
 
 FILE (GLOB_RECURSE PREPROCESSOR_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/external/boost/preprocessor/include/boost ${CMAKE_CURRENT_SOURCE_DIR}/external/boost/preprocessor/include/boost/*.hpp)
@@ -137,7 +144,7 @@ FOREACH (F ${PREPROCESSOR_FILES})
    FILE (READ ${CMAKE_CURRENT_SOURCE_DIR}/external/boost/preprocessor/include/boost/${F} CONTENT)
    STRING(REPLACE "BOOST_" "MSGPACK_" CONTENT ${CONTENT})
    STRING(REPLACE "boost/" "msgpack/" CONTENT ${CONTENT})
-   FILE (WRITE ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/${F} ${CONTENT})
+   FILE (GENERATE OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/${F} CONTENT ${CONTENT})
 ENDFOREACH ()
 
 FIND_PACKAGE (GTest)
@@ -174,17 +181,20 @@ CONFIGURE_FILE (
     @ONLY
 )
 
-INCLUDE_DIRECTORIES (
-    ./
-    include/
-    ${CMAKE_CURRENT_BINARY_DIR}/include/
-)
-
 IF (MSGPACK_ENABLE_SHARED)
     ADD_LIBRARY (msgpackc SHARED
         ${msgpackc_SOURCES}
         ${msgpackc_HEADERS}
     )
+
+    TARGET_INCLUDE_DIRECTORIES (msgpackc
+        PUBLIC
+            $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+            $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
+            $<INSTALL_INTERFACE:include>
+        PRIVATE
+            ${CMAKE_CURRENT_SOURCE_DIR}
+    )
 ENDIF ()
 
 ADD_LIBRARY (msgpackc-static STATIC
@@ -192,6 +202,20 @@ ADD_LIBRARY (msgpackc-static STATIC
     ${msgpackc_HEADERS}
 )
 
+TARGET_INCLUDE_DIRECTORIES (msgpackc-static
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+    PRIVATE
+        ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+IF (NOT MSGPACK_ENABLE_SHARED)
+    # Add alias for subdirectories
+    ADD_LIBRARY (msgpackc ALIAS msgpackc-static)
+ENDIF ()
+
 SET_TARGET_PROPERTIES (msgpackc-static PROPERTIES OUTPUT_NAME "msgpackc")
 IF (MSGPACK_ENABLE_SHARED)
     IF (MSVC)
@@ -235,7 +259,12 @@ ENDIF ()
 
 IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC90" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC10")
     SET_SOURCE_FILES_PROPERTIES(${msgpackc_SOURCES} PROPERTIES LANGUAGE CXX)
-ENDIF()
+ENDIF ()
+
+IF ("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "sparc")
+    SET (CMAKE_C_FLAGS   "-DMSGPACK_ZONE_ALIGN=8 ${CMAKE_C_FLAGS}")
+    SET (CMAKE_CXX_FLAGS "-DMSGPACK_ZONE_ALIGN=8 ${CMAKE_CXX_FLAGS}")
+ENDIF ()
 
 IF (NOT DEFINED CMAKE_INSTALL_BINDIR)
     SET(CMAKE_INSTALL_BINDIR bin)
@@ -255,10 +284,15 @@ ELSE()
     SET (MSGPACK_INSTALLTARGETS msgpackc-static)
 ENDIF ()
 
-INSTALL (TARGETS ${MSGPACK_INSTALLTARGETS} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+INSTALL (TARGETS ${MSGPACK_INSTALLTARGETS} EXPORT msgpack-targets
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-                                           ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
-INSTALL (DIRECTORY include DESTINATION ${CMAKE_INSTALL_PREFIX})
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+)
+FOREACH (file ${msgpackc_HEADERS})
+    GET_FILENAME_COMPONENT (dir ${file} PATH)
+    INSTALL (FILES ${file} DESTINATION ${CMAKE_INSTALL_PREFIX}/${dir})
+ENDFOREACH ()
 IF (NOT MSVC)
     INSTALL (FILES ${CMAKE_CURRENT_BINARY_DIR}/msgpack.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
 ENDIF ()
@@ -309,3 +343,39 @@ IF (DOXYGEN_FOUND)
         DEPENDS doxygen_c doxygen_cpp
     )
 ENDIF ()
+
+INCLUDE (CMakePackageConfigHelpers)
+
+SET (CMAKE_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/msgpack")
+
+WRITE_BASIC_PACKAGE_VERSION_FILE (
+    msgpack-config-version.cmake
+    VERSION ${VERSION}
+    COMPATIBILITY SameMajorVersion
+)
+
+IF (NOT CMAKE_VERSION VERSION_LESS 3.0)
+    EXPORT (EXPORT msgpack-targets
+        FILE "${CMAKE_CURRENT_BINARY_DIR}/msgpack-targets.cmake"
+    )
+ENDIF ()
+
+CONFIGURE_PACKAGE_CONFIG_FILE (msgpack-config.cmake.in
+    msgpack-config.cmake
+    INSTALL_DESTINATION "${CMAKE_INSTALL_CMAKEDIR}"
+)
+
+INSTALL (EXPORT msgpack-targets
+    FILE
+        msgpack-targets.cmake
+    DESTINATION
+        "${CMAKE_INSTALL_CMAKEDIR}"
+)
+
+INSTALL (
+    FILES
+        "${CMAKE_CURRENT_BINARY_DIR}/msgpack-config.cmake"
+        "${CMAKE_CURRENT_BINARY_DIR}/msgpack-config-version.cmake"
+    DESTINATION
+        "${CMAKE_INSTALL_CMAKEDIR}"
+)

Files.cmake

@@ -165,6 +165,7 @@ IF (MSGPACK_ENABLE_CXX)
         include/msgpack/adaptor/boost/msgpack_variant_decl.hpp
         include/msgpack/adaptor/boost/optional.hpp
         include/msgpack/adaptor/boost/string_ref.hpp
+        include/msgpack/adaptor/boost/string_view.hpp
         include/msgpack/adaptor/carray.hpp
         include/msgpack/adaptor/char_ptr.hpp
         include/msgpack/adaptor/check_container_size.hpp
@@ -179,6 +180,8 @@ IF (MSGPACK_ENABLE_CXX)
         include/msgpack/adaptor/cpp11/unique_ptr.hpp
         include/msgpack/adaptor/cpp11/unordered_map.hpp
         include/msgpack/adaptor/cpp11/unordered_set.hpp
+        include/msgpack/adaptor/cpp17/optional.hpp
+        include/msgpack/adaptor/cpp17/string_view.hpp
         include/msgpack/adaptor/define.hpp
         include/msgpack/adaptor/define_decl.hpp
         include/msgpack/adaptor/deque.hpp
@@ -512,6 +515,7 @@ IF (MSGPACK_ENABLE_CXX)
         include/msgpack/v1/adaptor/boost/msgpack_variant_decl.hpp
         include/msgpack/v1/adaptor/boost/optional.hpp
         include/msgpack/v1/adaptor/boost/string_ref.hpp
+        include/msgpack/v1/adaptor/boost/string_view.hpp
         include/msgpack/v1/adaptor/carray.hpp
         include/msgpack/v1/adaptor/char_ptr.hpp
         include/msgpack/v1/adaptor/check_container_size.hpp
@@ -526,6 +530,8 @@ IF (MSGPACK_ENABLE_CXX)
         include/msgpack/v1/adaptor/cpp11/unique_ptr.hpp
         include/msgpack/v1/adaptor/cpp11/unordered_map.hpp
         include/msgpack/v1/adaptor/cpp11/unordered_set.hpp
+        include/msgpack/v1/adaptor/cpp17/optional.hpp
+        include/msgpack/v1/adaptor/cpp17/string_view.hpp
         include/msgpack/v1/adaptor/define.hpp
         include/msgpack/v1/adaptor/define_decl.hpp
         include/msgpack/v1/adaptor/deque.hpp

QUICKSTART-C.md

@@ -96,7 +96,7 @@ int main(void) {
         /* deserializes it. */
         msgpack_unpacked msg;
         msgpack_unpacked_init(&msg);
-        bool success = msgpack_unpack_next(&msg, buffer->data, buffer->size, NULL);
+        msgpack_unpack_return ret = msgpack_unpack_next(&msg, buffer->data, buffer->size, NULL);
 
         /* prints the deserialized object. */
         msgpack_object obj = msg.data;
@@ -137,7 +137,7 @@ int main(void) {
            /* deserializes it. */
            msgpack_unpacked msg;
            msgpack_unpacked_init(&msg);
-           bool success = msgpack_unpack_next(&msg, buffer->data, buffer->size, NULL);
+           msgpack_unpack_return ret = msgpack_unpack_next(&msg, buffer->data, buffer->size, NULL);
 
            /* prints the deserialized object. */
            msgpack_object obj = msg.data;

QUICKSTART-CPP.md

@@ -78,7 +78,7 @@ int main(void) {
 
         // now starts streaming deserialization.
         msgpack::object_handle oh;
-        while(pac.next(&oh)) {
+        while(pac.next(oh)) {
             std::cout << oh.get() << std::endl;
         }
 

README.md

@@ -1,7 +1,7 @@
 `msgpack` for C/C++
 ===================
 
-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)
+Version 2.1.3 [![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.
 

appveyor.yml

@@ -1,15 +1,19 @@
-version: 2.1.0.{build}
+version: 2.1.4.{build}
 
+image:
+- Visual Studio 2015
 environment:
+  global:
+    BOOST_ROOT: C:\Libraries\boost_1_60_0
   matrix:
     - cpp11: -DMSGPACK_CXX11=OFF
-      boost: -DMSGPACK_BOOST=ON
+      boost: -DMSGPACK_BOOST=OFF
       msvc: '"Visual Studio 10 2010"'
     - cpp11: -DMSGPACK_CXX11=OFF
-      boost: -DMSGPACK_BOOST=ON
+      boost: -DMSGPACK_BOOST=OFF
       msvc: '"Visual Studio 11 2012"'
     - cpp11: -DMSGPACK_CXX11=OFF
-      boost: -DMSGPACK_BOOST=ON
+      boost: -DMSGPACK_BOOST=OFF
       msvc: '"Visual Studio 12 2013"'
     - cpp11: -DMSGPACK_CXX11=ON
       boost: -DMSGPACK_BOOST=ON
@@ -33,10 +37,10 @@ build_script:
 - cmake --build . --config Release
 - cd ..
 - cd ..
-- 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
+- appveyor DownloadFile http://zlib.net/zlib-1.2.11.tar.gz -FileName zlib-1.2.11.tar.gz
+- 7z x zlib-1.2.11.tar.gz > NUL
+- 7z x zlib-1.2.11.tar > NUL
+- cd zlib-1.2.11
 - md build
 - cd build
 - cmake -G %msvc% ..
@@ -46,9 +50,9 @@ build_script:
 - cd ..
 - md build
 - cd build
-- 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 -G %msvc% %cpp11% %boost% %x3_parse% -DGTEST_LIBRARY=%APPVEYOR_BUILD_FOLDER%\googletest-release-1.7.0\build\Release\gtest.lib -DGTEST_MAIN_LIBRARY=%APPVEYOR_BUILD_FOLDER%\googletest-release-1.7.0\build\Release\gtest_main.lib -DGTEST_INCLUDE_DIR=%APPVEYOR_BUILD_FOLDER%\googletest-release-1.7.0\include -DZLIB_LIBRARY=%APPVEYOR_BUILD_FOLDER%\zlib-1.2.11\build\Release\zlib.lib -DZLIB_INCLUDE_DIR=%APPVEYOR_BUILD_FOLDER%\zlib-1.2.11 -DCMAKE_CXX_FLAGS='"/D_VARIADIC_MAX=10 /EHsc"' ..
 - cmake --build . --config Release
 
 test_script:
-- set PATH=%PATH%;%APPVEYOR_BUILD_FOLDER%\googletest-release-1.7.0\build\Release;%APPVEYOR_BUILD_FOLDER%\zlib-1.2.10\build\Release;%APPVEYOR_BUILD_FOLDER%\build\release
+- set PATH=%PATH%;%APPVEYOR_BUILD_FOLDER%\googletest-release-1.7.0\build\Release;%APPVEYOR_BUILD_FOLDER%\zlib-1.2.11\build\Release;%APPVEYOR_BUILD_FOLDER%\build\release
 - ctest -V

erb/v1/cpp03_define_array.hpp.erb

@@ -66,14 +66,16 @@ struct define_array<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
             msgpack::object *ptr = o.via.array.ptr;
             switch(size) {
             default:<%(i).downto(0) {|j|%>
-            case <%=j+1%>: ptr[<%=j%>].convert(a<%=j%>);<%}%>
+            case <%=j+1%>: ptr[<%=j%>].convert(a<%=j%>);
+            // fallthrough
+<%}%>
             }
         }
     }
     void msgpack_object(msgpack::object* o, msgpack::zone& z) const
     {
         o->type = msgpack::type::ARRAY;
-        o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*<%=i+1%>));
+        o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*<%=i+1%>, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o->via.array.size = <%=i+1%>;
         <%0.upto(i) {|j|%>
         o->via.array.ptr[<%=j%>] = msgpack::object(a<%=j%>, z);<%}%>

erb/v1/cpp03_define_map.hpp.erb

@@ -82,7 +82,7 @@ struct define_map<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
     void msgpack_object(msgpack::object* o, msgpack::zone& z) const
     {
         o->type = msgpack::type::MAP;
-        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*<%=(i+1)/2%>));
+        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*<%=(i+1)/2%>, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
         o->via.map.size = <%=(i+1)/2%>;
         <%0.step(i,2) {|j|%>
         o->via.map.ptr[<%=j/2%>].key = msgpack::object(a<%=j%>, z);

erb/v1/cpp03_msgpack_tuple.hpp.erb

@@ -207,7 +207,7 @@ struct object_with_zone<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> > {
         msgpack::object::with_zone& o,
         const type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*<%=i+1%>));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*<%=i+1%>, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = <%=i+1%>;
         <%0.upto(i) {|j|%>
         o.via.array.ptr[<%=j%>] = msgpack::object(v.template get<<%=j%>>(), o.zone);<%}%>

erb/v1/cpp03_zone.hpp.erb

@@ -178,7 +178,9 @@ private:
     template <typename T>
     static void object_delete(void* obj);
 
-    void* allocate_expand(size_t size);
+    static char* get_aligned(char* ptr, size_t align);
+
+    char* allocate_expand(size_t size);
 private:
     zone(const zone&);
     zone& operator=(const zone&);
@@ -188,37 +190,42 @@ inline zone::zone(size_t chunk_size) /* throw() */ :m_chunk_size(chunk_size), m_
 {
 }
 
-inline void* zone::allocate_align(size_t size, size_t align)
+inline char* zone::get_aligned(char* ptr, size_t align)
 {
-    char* aligned =
+    return
         reinterpret_cast<char*>(
             reinterpret_cast<size_t>(
-                (m_chunk_list.m_ptr + (align - 1))) / align * align);
+            (ptr + (align - 1))) / align * align);
+}
+
+inline void* zone::allocate_align(size_t size, size_t align)
+{
+    char* aligned = get_aligned(m_chunk_list.m_ptr, align);
     size_t adjusted_size = size + (aligned - m_chunk_list.m_ptr);
-    if(m_chunk_list.m_free >= adjusted_size) {
+    if (m_chunk_list.m_free < adjusted_size) {
+        size_t enough_size = size + align - 1;
+        char* ptr = allocate_expand(enough_size);
+        aligned = get_aligned(ptr, align);
+        adjusted_size = size + (aligned - m_chunk_list.m_ptr);
+    }
     m_chunk_list.m_free -= adjusted_size;
     m_chunk_list.m_ptr  += adjusted_size;
     return aligned;
-    }
-    return reinterpret_cast<char*>(
-        reinterpret_cast<size_t>(
-            allocate_expand(size + (align - 1))) / align * align);
 }
 
 inline void* zone::allocate_no_align(size_t size)
 {
-    if(m_chunk_list.m_free < size) {
-        return allocate_expand(size);
-    }
-
     char* ptr = m_chunk_list.m_ptr;
+    if(m_chunk_list.m_free < size) {
+        ptr = allocate_expand(size);
+    }
     m_chunk_list.m_free -= size;
     m_chunk_list.m_ptr  += size;
 
     return ptr;
 }
 
-inline void* zone::allocate_expand(size_t size)
+inline char* zone::allocate_expand(size_t size)
 {
     chunk_list* const cl = &m_chunk_list;
 
@@ -240,8 +247,8 @@ inline void* zone::allocate_expand(size_t size)
 
     c->m_next  = cl->m_head;
     cl->m_head = c;
-    cl->m_free = sz - size;
-    cl->m_ptr  = ptr + size;
+    cl->m_free = sz;
+    cl->m_ptr  = ptr;
 
     return ptr;
 }
@@ -300,7 +307,7 @@ inline std::size_t aligned_size(
 template <typename T<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
 T* zone::allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>)
 {
-    void* x = allocate_align(sizeof(T));
+    void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
     try {
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {

erb/v1/cpp03_zone_decl.hpp.erb

@@ -24,6 +24,14 @@
 #define MSGPACK_ZONE_ALIGN sizeof(void*)
 #endif
 
+#if defined(_MSC_VER)
+#define MSGPACK_ZONE_ALIGNOF(type) __alignof(type)
+#else
+#define MSGPACK_ZONE_ALIGNOF(type) __alignof__(type)
+#endif
+// For a compiler that doesn't support __alignof__:
+// #define MSGPACK_ZONE_ALIGNOF(type) MSGPACK_ZONE_ALIGN
+
 <% GENERATION_LIMIT = 15 %>
 namespace msgpack {
 

example/boost/CMakeLists.txt

@@ -3,6 +3,20 @@ IF (MSGPACK_BOOST)
         msgpack_variant_capitalize.cpp
         msgpack_variant_mapbased.cpp
     )
+    IF (MSGPACK_CXX11 OR MSGPACK_CXX17)
+        FIND_PACKAGE (Threads REQUIRED)
+        LIST (APPEND exec_PROGRAMS
+            asio_send_recv.cpp
+        )
+        IF (ZLIB_FOUND)
+            INCLUDE_DIRECTORIES (
+                ${ZLIB_INCLUDE_DIRS}
+            )
+            LIST (APPEND exec_PROGRAMS
+                asio_send_recv_zlib.cpp
+            )
+        ENDIF ()
+    ENDIF ()
 ENDIF ()
 
 FOREACH (source_file ${exec_PROGRAMS})
@@ -11,6 +25,19 @@ FOREACH (source_file ${exec_PROGRAMS})
         ${source_file_we}
         ${source_file}
     )
+    TARGET_INCLUDE_DIRECTORIES (${source_file_we}
+        PRIVATE
+            $<TARGET_PROPERTY:msgpackc,INTERFACE_INCLUDE_DIRECTORIES>
+    )
+    TARGET_LINK_LIBRARIES (${source_file_we}
+        ${Boost_SYSTEM_LIBRARY}
+        ${CMAKE_THREAD_LIBS_INIT}
+    )
+    IF (ZLIB_FOUND)
+        TARGET_LINK_LIBRARIES (${source_file_we}
+            ${ZLIB_LIBRARIES}
+        )
+    ENDIF()
     IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
         SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Werror -g -O3")
     ENDIF ()

example/boost/asio_send_recv.cpp

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

example/boost/asio_send_recv_zlib.cpp

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

example/c/speed_test_uint32_array.c

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

example/c/speed_test_uint64_array.c

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

example/cpp03/CMakeLists.txt

@@ -22,7 +22,7 @@ IF (NOT MSVC)
     )
 ENDIF ()
 
-IF (Boost_TIMER_LIBRARY AND Boost_CHRONO_LIBRARY AND Boost_SYSTEM_LIBRARY)
+IF (MSGPACK_BOOST)
     LIST (APPEND with_boost_lib_PROGRAMS
         speed_test.cpp
         speed_test_nested_array.cpp
@@ -35,6 +35,10 @@ FOREACH (source_file ${exec_PROGRAMS})
         ${source_file_we}
         ${source_file}
     )
+    TARGET_INCLUDE_DIRECTORIES (${source_file_we}
+        PRIVATE
+            $<TARGET_PROPERTY:msgpackc,INTERFACE_INCLUDE_DIRECTORIES>
+    )
     IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
         SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Werror -g -O3")
     ENDIF ()
@@ -53,6 +57,10 @@ FOREACH (source_file ${with_pthread_PROGRAMS})
         ${source_file_we}
         ${source_file}
     )
+    TARGET_INCLUDE_DIRECTORIES (${source_file_we}
+        PRIVATE
+            $<TARGET_PROPERTY:msgpackc,INTERFACE_INCLUDE_DIRECTORIES>
+    )
     TARGET_LINK_LIBRARIES (${source_file_we}
         ${CMAKE_THREAD_LIBS_INIT}
     )
@@ -78,6 +86,10 @@ FOREACH (source_file ${with_boost_lib_PROGRAMS})
         ${source_file_we}
         ${source_file}
     )
+    TARGET_INCLUDE_DIRECTORIES (${source_file_we}
+        PRIVATE
+            $<TARGET_PROPERTY:msgpackc,INTERFACE_INCLUDE_DIRECTORIES>
+    )
     LINK_DIRECTORIES(${Boost_LIBRARY_DIRS})
     TARGET_LINK_LIBRARIES (${source_file_we}
         ${Boost_TIMER_LIBRARY}

example/cpp03/class_non_intrusive.cpp

@@ -69,7 +69,7 @@ struct object_with_zone<my_class> {
         o.type = type::ARRAY;
         o.via.array.size = 2;
         o.via.array.ptr = static_cast<msgpack::object*>(
-            o.zone.allocate_align(sizeof(msgpack::object) * o.via.array.size));
+            o.zone.allocate_align(sizeof(msgpack::object) * o.via.array.size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.ptr[0] = msgpack::object(v.get_name(), o.zone);
         o.via.array.ptr[1] = msgpack::object(v.get_age(), o.zone);
     }

example/cpp11/CMakeLists.txt

@@ -20,6 +20,10 @@ IF (MSGPACK_CXX11)
             ${source_file_we}
             ${source_file}
         )
+        TARGET_INCLUDE_DIRECTORIES (${source_file_we}
+            PRIVATE
+                $<TARGET_PROPERTY:msgpackc,INTERFACE_INCLUDE_DIRECTORIES>
+        )
         IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
             SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Werror -g -O3 ")
         ENDIF ()

example/x3/CMakeLists.txt

@@ -7,7 +7,7 @@ IF (MSGPACK_USE_X3_PARSE)
         unpack.cpp
         parse.cpp
     )
-    IF (Boost_CONTEXT_LIBRARY AND Boost_SYSTEM_LIBRARY AND CMAKE_THREAD_LIBS_INIT)
+    IF (MSGPACK_BOOST)
         LIST (APPEND with_boost_PROGRAMS
             stream_unpack.cpp
         )
@@ -18,6 +18,10 @@ IF (MSGPACK_USE_X3_PARSE)
             ${source_file_we}
             ${source_file}
         )
+        TARGET_INCLUDE_DIRECTORIES (${source_file_we}
+            PRIVATE
+                $<TARGET_PROPERTY:msgpackc,INTERFACE_INCLUDE_DIRECTORIES>
+        )
         IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
             SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Werror -g ")
         ENDIF ()
@@ -40,6 +44,10 @@ IF (MSGPACK_USE_X3_PARSE)
             ${source_file_we}
             ${source_file}
         )
+        TARGET_INCLUDE_DIRECTORIES (${source_file_we}
+            PRIVATE
+                $<TARGET_PROPERTY:msgpackc,INTERFACE_INCLUDE_DIRECTORIES>
+        )
         TARGET_LINK_LIBRARIES (${source_file_we}
             ${Boost_CONTEXT_LIBRARY}
             ${Boost_SYSTEM_LIBRARY}

example/x3/parse.cpp

@@ -40,7 +40,13 @@ struct json_like_visitor : msgpack::v2::null_visitor {
         m_s += ss.str();
         return true;
     }
-    bool visit_float(double v) {
+    bool visit_float32(float v) {
+        std::stringstream ss;
+        ss << v;
+        m_s += ss.str();
+        return true;
+    }
+    bool visit_float64(double v) {
         std::stringstream ss;
         ss << v;
         m_s += ss.str();

example/x3/stream_unpack.cpp

@@ -21,8 +21,17 @@
 
 #include <boost/asio.hpp>
 #include <boost/coroutine2/all.hpp>
+
+#if defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif // defined(__clang__)
+
 #include <boost/spirit/home/support/multi_pass.hpp>
 
+#if defined(__clang__)
+#pragma GCC diagnostic pop
+#endif // defined(__clang__)
 
 namespace as = boost::asio;
 namespace x3 = boost::spirit::x3;

include/msgpack/adaptor/boost/string_view.hpp

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

include/msgpack/adaptor/cpp17/optional.hpp

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

include/msgpack/adaptor/cpp17/string_view.hpp

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

include/msgpack/adaptor/tr1/unordered_map.hpp

@@ -84,7 +84,7 @@ struct object_with_zone<MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc>
             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* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
             msgpack::object_kv* const pend = p + size;
             o.via.map.ptr  = p;
             o.via.map.size = size;
@@ -141,7 +141,7 @@ struct object_with_zone<MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Al
             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* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
             msgpack::object_kv* const pend = p + size;
             o.via.map.ptr  = p;
             o.via.map.size = size;

include/msgpack/adaptor/tr1/unordered_set.hpp

@@ -82,7 +82,7 @@ struct object_with_zone<MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc>
             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* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
             msgpack::object* const pend = p + size;
             o.via.array.ptr = p;
             o.via.array.size = size;
@@ -136,7 +136,7 @@ struct object_with_zone<MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Al
             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* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
             msgpack::object* const pend = p + size;
             o.via.array.ptr = p;
             o.via.array.size = size;

include/msgpack/sysdep.h

@@ -45,6 +45,9 @@
 
 #ifdef _WIN32
 #   define _msgpack_atomic_counter_header <windows.h>
+#   if !defined(WIN32_LEAN_AND_MEAN)
+#       define WIN32_LEAN_AND_MEAN
+#   endif /* WIN32_LEAN_AND_MEAN */
     typedef long _msgpack_atomic_counter_t;
 #   define _msgpack_sync_decr_and_fetch(ptr) InterlockedDecrement(ptr)
 #   define _msgpack_sync_incr_and_fetch(ptr) InterlockedIncrement(ptr)
@@ -74,7 +77,7 @@
 #       endif
 #   endif
 
-#else /* _*/
+#elif defined(unix) || defined(__unix) || defined(__APPLE__) || defined(__OpenBSD__)
 
 #include <arpa/inet.h>  /* __BYTE_ORDER */
 #   if defined(linux)
@@ -85,7 +88,9 @@
 
 #if MSGPACK_ENDIAN_LITTLE_BYTE
 
-#   ifdef _WIN32
+#   if defined(unix) || defined(__unix) || defined(__APPLE__) || defined(__OpenBSD__)
+#       define _msgpack_be16(x) ntohs(x)
+#   else
 #       if defined(ntohs)
 #           define _msgpack_be16(x) ntohs(x)
 #       elif defined(_byteswap_ushort) || (defined(_MSC_VER) && _MSC_VER >= 1400)
@@ -95,11 +100,11 @@
                 ((((uint16_t)x) <<  8) ) | \
                 ((((uint16_t)x) >>  8) ) )
 #        endif
-#   else
-#        define _msgpack_be16(x) ntohs(x)
 #   endif
 
-#   ifdef _WIN32
+#   if defined(unix) || defined(__unix) || defined(__APPLE__) || defined(__OpenBSD__)
+#       define _msgpack_be32(x) ntohl(x)
+#   else
 #       if defined(ntohl)
 #           define _msgpack_be32(x) ntohl(x)
 #       elif defined(_byteswap_ulong) || (defined(_MSC_VER) && _MSC_VER >= 1400)
@@ -111,8 +116,6 @@
                   ((((uint32_t)x) >>  8) & 0x0000ff00U ) | \
                   ((((uint32_t)x) >> 24)               ) )
 #       endif
-#   else
-#        define _msgpack_be32(x) ntohl(x)
 #   endif
 
 #   if defined(_byteswap_uint64) || (defined(_MSC_VER) && _MSC_VER >= 1400)

include/msgpack/type.hpp

@@ -42,6 +42,13 @@
 #include "adaptor/cpp11/unordered_map.hpp"
 #include "adaptor/cpp11/unordered_set.hpp"
 
+#if __cplusplus >= 201703
+
+#include "adaptor/cpp17/optional.hpp"
+#include "adaptor/cpp17/string_view.hpp"
+
+#endif // __cplusplus >= 201703
+
 #endif // defined(MSGPACK_USE_CPP03)
 
 #if defined(MSGPACK_USE_BOOST)
@@ -50,5 +57,6 @@
 #include "adaptor/boost/msgpack_variant.hpp"
 #include "adaptor/boost/optional.hpp"
 #include "adaptor/boost/string_ref.hpp"
+#include "adaptor/boost/string_view.hpp"
 
 #endif // defined(MSGPACK_USE_BOOST)

include/msgpack/unpack_template.h

@@ -236,6 +236,7 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c
 
             _fixed_trail_again:
                 ++p;
+                // fallthrough
 
             default:
                 if((size_t)(pe - p) < trail) { goto _out; }

include/msgpack/v1/adaptor/array_ref.hpp

@@ -253,20 +253,20 @@ struct object_with_zone<msgpack::type::array_ref<T> > {
         }
         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* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
             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__)
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
                 *p = msgpack::object(*it, o.zone);
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 #pragma GCC diagnostic pop
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
                 ++p;
                 ++it;
             } while(p < pend);
@@ -280,7 +280,7 @@ struct object_with_zone<msgpack::type::array_ref<T[N]> > {
         if (!v.data) { throw msgpack::type_error(); }
         o.type = msgpack::type::ARRAY;
         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* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         msgpack::object* const pend = p + size;
         o.via.array.ptr = p;
         o.via.array.size = size;

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

@@ -15,6 +15,8 @@
 #include "msgpack/adaptor/check_container_size.hpp"
 #include "msgpack/meta.hpp"
 
+#include "msgpack/adaptor/pair.hpp"
+
 #if !defined (MSGPACK_USE_CPP03)
 #include "msgpack/adaptor/cpp11/tuple.hpp"
 #endif // #if !defined (MSGPACK_USE_CPP03)
@@ -34,13 +36,54 @@ MSGPACK_API_VERSION_NAMESPACE(v1) {
 
 namespace adaptor {
 
+namespace detail {
+
+template <typename T>
+struct is_std_pair {
+    static bool const value = false;
+};
+
+template <typename T, typename U>
+struct is_std_pair<std::pair<T, U> > {
+    static bool const value = true;
+};
+
+#if !defined(MSGPACK_USE_CPP03)
+
+template <typename T>
+struct is_std_tuple {
+    static bool const value = false;
+};
+
+template <typename... Args>
+struct is_std_tuple<std::tuple<Args...>> {
+    static bool const value = true;
+};
+
+#endif // !defined(MSGPACK_USE_CPP03)
+
+template <typename T>
+struct is_seq_no_pair_no_tuple {
+    static bool const value =
+        boost::fusion::traits::is_sequence<T>::value
+        &&
+        !is_std_pair<T>::value
+#if !defined (MSGPACK_USE_CPP03)
+        &&
+        !is_std_tuple<T>::value
+#endif // !defined (MSGPACK_USE_CPP03)
+        ;
+};
+
+} // namespace detail
+
 #if !defined (MSGPACK_USE_CPP03)
 
 template <typename T>
 struct as<
     T,
     typename msgpack::enable_if<
-        boost::fusion::traits::is_sequence<T>::value &&
+        detail::is_seq_no_pair_no_tuple<T>::value &&
         boost::mpl::fold<
             T,
             boost::mpl::bool_<true>,
@@ -82,7 +125,7 @@ struct as<
 #endif // !defined (MSGPACK_USE_CPP03)
 
 template <typename T>
-struct convert<T, typename msgpack::enable_if<boost::fusion::traits::is_sequence<T>::value>::type > {
+struct convert<T, typename msgpack::enable_if<detail::is_seq_no_pair_no_tuple<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))) {
@@ -106,7 +149,7 @@ private:
 };
 
 template <typename T>
-struct pack<T, typename msgpack::enable_if<boost::fusion::traits::is_sequence<T>::value>::type > {
+struct pack<T, typename msgpack::enable_if<detail::is_seq_no_pair_no_tuple<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));
@@ -128,11 +171,11 @@ private:
 };
 
 template <typename T>
-struct object_with_zone<T, typename msgpack::enable_if<boost::fusion::traits::is_sequence<T>::value>::type > {
+struct object_with_zone<T, typename msgpack::enable_if<detail::is_seq_no_pair_no_tuple<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.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = size;
         uint32_t count = 0;
         boost::fusion::for_each(v, with_zone_imp(o, count));

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

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

include/msgpack/v1/adaptor/carray.hpp

@@ -101,7 +101,7 @@ struct pack<char[N]> {
         char const* p = v;
         uint32_t size = checked_get_container_size(N);
         char const* p2 = static_cast<char const*>(std::memchr(p, '\0', size));
-        uint32_t adjusted_size = p2 ? p2 - p : size;
+        uint32_t adjusted_size = p2 ? static_cast<uint32_t>(p2 - p) : size;
         o.pack_str(adjusted_size);
         o.pack_str_body(p, adjusted_size);
         return o;
@@ -115,7 +115,7 @@ struct pack<const char[N]> {
         uint32_t size = checked_get_container_size(N);
         char const* p = v;
         char const* p2 = static_cast<char const*>(std::memchr(p, '\0', size));
-        uint32_t adjusted_size = p2 ? p2 - p : size;
+        uint32_t adjusted_size = p2 ? static_cast<uint32_t>(p2 - p) : size;
         o.pack_str(adjusted_size);
         o.pack_str_body(p, adjusted_size);
         return o;
@@ -151,7 +151,7 @@ struct object_with_zone<T[N]> {
     void operator()(msgpack::object::with_zone& o, const T(&v)[N]) const {
         uint32_t size = checked_get_container_size(N);
         o.type = msgpack::type::ARRAY;
-        msgpack::object* ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object) * size));
+        msgpack::object* ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object) * size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.ptr = ptr;
         o.via.array.size = size;
         const T* pv = v;
@@ -167,9 +167,9 @@ struct object_with_zone<char[N]> {
         char const* p = v;
         uint32_t size = checked_get_container_size(N);
         char const* p2 = static_cast<char const*>(std::memchr(p, '\0', size));
-        uint32_t adjusted_size = p2 ? p2 - p : size;
+        uint32_t adjusted_size = p2 ? static_cast<uint32_t>(p2 - p) : size;
         o.type = msgpack::type::STR;
-        char* ptr = static_cast<char*>(o.zone.allocate_align(adjusted_size));
+        char* ptr = static_cast<char*>(o.zone.allocate_align(adjusted_size, MSGPACK_ZONE_ALIGNOF(char)));
         o.via.str.ptr = ptr;
         o.via.str.size = adjusted_size;
         std::memcpy(ptr, p, adjusted_size);
@@ -182,9 +182,9 @@ struct object_with_zone<const char[N]> {
         char const* p = v;
         uint32_t size = checked_get_container_size(N);
         char const* p2 = static_cast<char const*>(std::memchr(p, '\0', size));
-        uint32_t adjusted_size = p2 ? p2 - p : size;
+        uint32_t adjusted_size = p2 ? static_cast<uint32_t>(p2 - p) : size;
         o.type = msgpack::type::STR;
-        char* ptr = static_cast<char*>(o.zone.allocate_align(adjusted_size));
+        char* ptr = static_cast<char*>(o.zone.allocate_align(adjusted_size, MSGPACK_ZONE_ALIGNOF(char)));
         o.via.str.ptr = ptr;
         o.via.str.size = adjusted_size;
         std::memcpy(ptr, p, adjusted_size);
@@ -196,7 +196,7 @@ struct object_with_zone<unsigned char[N]> {
     void operator()(msgpack::object::with_zone& o, const unsigned char(&v)[N]) const {
         uint32_t size = checked_get_container_size(N);
         o.type = msgpack::type::BIN;
-        char* ptr = static_cast<char*>(o.zone.allocate_align(size));
+        char* ptr = static_cast<char*>(o.zone.allocate_align(size, MSGPACK_ZONE_ALIGNOF(char)));
         o.via.bin.ptr = ptr;
         o.via.bin.size = size;
         std::memcpy(ptr, v, size);
@@ -208,7 +208,7 @@ struct object_with_zone<const unsigned char[N]> {
     void operator()(msgpack::object::with_zone& o, const unsigned char(&v)[N]) const {
         uint32_t size = checked_get_container_size(N);
         o.type = msgpack::type::BIN;
-        char* ptr = static_cast<char*>(o.zone.allocate_align(size));
+        char* ptr = static_cast<char*>(o.zone.allocate_align(size, MSGPACK_ZONE_ALIGNOF(char)));
         o.via.bin.ptr = ptr;
         o.via.bin.size = size;
         std::memcpy(ptr, v, size);
@@ -221,7 +221,7 @@ struct object<char[N]> {
         char const* p = v;
         uint32_t size = checked_get_container_size(N);
         char const* p2 = static_cast<char const*>(std::memchr(p, '\0', size));
-        uint32_t adjusted_size = p2 ? p2 - p : size;
+        uint32_t adjusted_size = p2 ? static_cast<uint32_t>(p2 - p) : size;
         o.type = msgpack::type::STR;
         o.via.str.ptr = p;
         o.via.str.size = adjusted_size;
@@ -234,7 +234,7 @@ struct object<const char[N]> {
         char const* p = v;
         uint32_t size = checked_get_container_size(N);
         char const* p2 = static_cast<char const*>(std::memchr(p, '\0', size));
-        uint32_t adjusted_size = p2 ? p2 - p : size;
+        uint32_t adjusted_size = p2 ? static_cast<uint32_t>(p2 - p) : size;
         o.type = msgpack::type::STR;
         o.via.str.ptr = p;
         o.via.str.size = adjusted_size;

include/msgpack/v1/adaptor/char_ptr.hpp

@@ -41,7 +41,7 @@ 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));
+        char* ptr = static_cast<char*>(o.zone.allocate_align(size, MSGPACK_ZONE_ALIGNOF(char)));
         o.via.str.ptr = ptr;
         o.via.str.size = size;
         std::memcpy(ptr, v, size);

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

@@ -119,7 +119,7 @@ struct object_with_zone<std::array<T, N>> {
             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* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
             o.via.array.size = size;
             o.via.array.ptr = p;
             for (auto const& e : v) *p++ = msgpack::object(e, o.zone);

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

@@ -45,6 +45,13 @@ struct convert<std::array<char, N>> {
     }
 };
 
+template <>
+struct convert<std::array<char, 0>> {
+    msgpack::object const& operator()(msgpack::object const& o, std::array<char, 0>&) const {
+        return o;
+    }
+};
+
 template <std::size_t N>
 struct pack<std::array<char, N>> {
     template <typename Stream>
@@ -72,7 +79,7 @@ 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));
+        char* ptr = static_cast<char*>(o.zone.allocate_align(size, MSGPACK_ZONE_ALIGNOF(char)));
         o.via.bin.ptr = ptr;
         o.via.bin.size = size;
         std::memcpy(ptr, v.data(), size);

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

@@ -45,6 +45,13 @@ struct convert<std::array<unsigned char, N>> {
     }
 };
 
+template <>
+struct convert<std::array<unsigned char, 0>> {
+    msgpack::object const& operator()(msgpack::object const& o, std::array<unsigned char, 0>&) const {
+        return o;
+    }
+};
+
 template <std::size_t N>
 struct pack<std::array<unsigned char, N>> {
     template <typename Stream>
@@ -72,7 +79,7 @@ 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));
+        char* ptr = static_cast<char*>(o.zone.allocate_align(size, MSGPACK_ZONE_ALIGNOF(char)));
         o.via.bin.ptr = ptr;
         o.via.bin.size = size;
         std::memcpy(ptr, v.data(), size);

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

@@ -76,7 +76,7 @@ struct object_with_zone<std::forward_list<T, Alloc>> {
             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.zone.allocate_align(sizeof(msgpack::object)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
             o.via.array.ptr = p;
             for(auto const& e : v) *p++ = msgpack::object(e, o.zone);
         }

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

@@ -158,7 +158,7 @@ struct object_with_zone<std::tuple<Args...>> {
         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.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = size;
         StdTupleToObjectWithZone<decltype(v), sizeof...(Args)>::convert(o, v);
     }

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

@@ -81,7 +81,7 @@ struct object_with_zone<std::unordered_map<K, V, Hash, Compare, Alloc>> {
             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* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
             msgpack::object_kv* const pend = p + size;
             o.via.map.ptr  = p;
             o.via.map.size = size;
@@ -155,7 +155,7 @@ struct object_with_zone<std::unordered_multimap<K, V, Hash, Compare, Alloc>> {
             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* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
             msgpack::object_kv* const pend = p + size;
             o.via.map.ptr  = p;
             o.via.map.size = size;

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

@@ -78,7 +78,7 @@ struct object_with_zone<std::unordered_set<Key, Hash, Compare, Alloc>> {
             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* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
             msgpack::object* const pend = p + size;
             o.via.array.ptr = p;
             o.via.array.size = size;
@@ -147,7 +147,7 @@ struct object_with_zone<std::unordered_multiset<Key, Hash, Compare, Alloc>> {
             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* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
             msgpack::object* const pend = p + size;
             o.via.array.ptr = p;
             o.via.array.size = size;

include/msgpack/v1/adaptor/cpp17/optional.hpp

@@ -0,0 +1,90 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2017 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_V1_TYPE_OPTIONAL_HPP
+#define MSGPACK_V1_TYPE_OPTIONAL_HPP
+
+#if __cplusplus >= 201703
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/adaptor/check_container_size.hpp"
+
+#include <optional>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace adaptor {
+
+#if !defined (MSGPACK_USE_CPP03)
+
+template <typename T>
+struct as<std::optional<T>, typename std::enable_if<msgpack::has_as<T>::value>::type> {
+    std::optional<T> operator()(msgpack::object const& o) const {
+        if(o.is_nil()) return std::nullopt;
+        return o.as<T>();
+    }
+};
+
+#endif // !defined (MSGPACK_USE_CPP03)
+
+template <typename T>
+struct convert<std::optional<T> > {
+    msgpack::object const& operator()(msgpack::object const& o, std::optional<T>& v) const {
+        if(o.is_nil()) v = std::nullopt;
+        else {
+            T t;
+            msgpack::adaptor::convert<T>()(o, t);
+            v = t;
+        }
+        return o;
+    }
+};
+
+template <typename T>
+struct pack<std::optional<T> > {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::optional<T>& v) const {
+        if (v) o.pack(*v);
+        else o.pack_nil();
+        return o;
+    }
+};
+
+template <typename T>
+struct object<std::optional<T> > {
+    void operator()(msgpack::object& o, const std::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<std::optional<T> > {
+    void operator()(msgpack::object::with_zone& o, const std::optional<T>& v) const {
+        if (v) msgpack::adaptor::object_with_zone<T>()(o, *v);
+        else o.type = msgpack::type::NIL;
+    }
+};
+
+} // namespace adaptor
+
+/// @cond
+} // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+} // namespace msgpack
+
+#endif // __cplusplus >= 201703
+
+#endif // MSGPACK_V1_TYPE_OPTIONAL_HPP

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

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

include/msgpack/v1/adaptor/deque.hpp

@@ -83,7 +83,7 @@ struct object_with_zone<std::deque<T, Alloc> > {
             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* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
             msgpack::object* const pend = p + size;
             o.via.array.ptr = p;
             o.via.array.size = size;

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

@@ -83,7 +83,7 @@ struct define_map<A0, A1> {
     void msgpack_object(msgpack::object* o, msgpack::zone& z) const
     {
         o->type = msgpack::type::MAP;
-        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*1));
+        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*1, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
         o->via.map.size = 1;
         
         o->via.map.ptr[0].key = msgpack::object(a0, z);
@@ -142,7 +142,7 @@ struct define_map<A0, A1, A2, A3> {
     void msgpack_object(msgpack::object* o, msgpack::zone& z) const
     {
         o->type = msgpack::type::MAP;
-        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*2));
+        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*2, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
         o->via.map.size = 2;
         
         o->via.map.ptr[0].key = msgpack::object(a0, z);
@@ -215,7 +215,7 @@ struct define_map<A0, A1, A2, A3, A4, A5> {
     void msgpack_object(msgpack::object* o, msgpack::zone& z) const
     {
         o->type = msgpack::type::MAP;
-        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*3));
+        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*3, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
         o->via.map.size = 3;
         
         o->via.map.ptr[0].key = msgpack::object(a0, z);
@@ -302,7 +302,7 @@ struct define_map<A0, A1, A2, A3, A4, A5, A6, A7> {
     void msgpack_object(msgpack::object* o, msgpack::zone& z) const
     {
         o->type = msgpack::type::MAP;
-        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*4));
+        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*4, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
         o->via.map.size = 4;
         
         o->via.map.ptr[0].key = msgpack::object(a0, z);
@@ -403,7 +403,7 @@ struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
     void msgpack_object(msgpack::object* o, msgpack::zone& z) const
     {
         o->type = msgpack::type::MAP;
-        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*5));
+        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*5, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
         o->via.map.size = 5;
         
         o->via.map.ptr[0].key = msgpack::object(a0, z);
@@ -518,7 +518,7 @@ struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
     void msgpack_object(msgpack::object* o, msgpack::zone& z) const
     {
         o->type = msgpack::type::MAP;
-        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*6));
+        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*6, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
         o->via.map.size = 6;
         
         o->via.map.ptr[0].key = msgpack::object(a0, z);
@@ -647,7 +647,7 @@ struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
     void msgpack_object(msgpack::object* o, msgpack::zone& z) const
     {
         o->type = msgpack::type::MAP;
-        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*7));
+        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*7, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
         o->via.map.size = 7;
         
         o->via.map.ptr[0].key = msgpack::object(a0, z);
@@ -790,7 +790,7 @@ struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A1
     void msgpack_object(msgpack::object* o, msgpack::zone& z) const
     {
         o->type = msgpack::type::MAP;
-        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*8));
+        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*8, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
         o->via.map.size = 8;
         
         o->via.map.ptr[0].key = msgpack::object(a0, z);
@@ -947,7 +947,7 @@ struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A1
     void msgpack_object(msgpack::object* o, msgpack::zone& z) const
     {
         o->type = msgpack::type::MAP;
-        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*9));
+        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*9, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
         o->via.map.size = 9;
         
         o->via.map.ptr[0].key = msgpack::object(a0, z);
@@ -1118,7 +1118,7 @@ struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A1
     void msgpack_object(msgpack::object* o, msgpack::zone& z) const
     {
         o->type = msgpack::type::MAP;
-        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*10));
+        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*10, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
         o->via.map.size = 10;
         
         o->via.map.ptr[0].key = msgpack::object(a0, z);
@@ -1303,7 +1303,7 @@ struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A1
     void msgpack_object(msgpack::object* o, msgpack::zone& z) const
     {
         o->type = msgpack::type::MAP;
-        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*11));
+        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*11, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
         o->via.map.size = 11;
         
         o->via.map.ptr[0].key = msgpack::object(a0, z);
@@ -1502,7 +1502,7 @@ struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A1
     void msgpack_object(msgpack::object* o, msgpack::zone& z) const
     {
         o->type = msgpack::type::MAP;
-        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*12));
+        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*12, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
         o->via.map.size = 12;
         
         o->via.map.ptr[0].key = msgpack::object(a0, z);
@@ -1715,7 +1715,7 @@ struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A1
     void msgpack_object(msgpack::object* o, msgpack::zone& z) const
     {
         o->type = msgpack::type::MAP;
-        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*13));
+        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*13, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
         o->via.map.size = 13;
         
         o->via.map.ptr[0].key = msgpack::object(a0, z);
@@ -1942,7 +1942,7 @@ struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A1
     void msgpack_object(msgpack::object* o, msgpack::zone& z) const
     {
         o->type = msgpack::type::MAP;
-        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*14));
+        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*14, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
         o->via.map.size = 14;
         
         o->via.map.ptr[0].key = msgpack::object(a0, z);
@@ -2183,7 +2183,7 @@ struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A1
     void msgpack_object(msgpack::object* o, msgpack::zone& z) const
     {
         o->type = msgpack::type::MAP;
-        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*15));
+        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*15, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
         o->via.map.size = 15;
         
         o->via.map.ptr[0].key = msgpack::object(a0, z);
@@ -2438,7 +2438,7 @@ struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A1
     void msgpack_object(msgpack::object* o, msgpack::zone& z) const
     {
         o->type = msgpack::type::MAP;
-        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*16));
+        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*16, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
         o->via.map.size = 16;
         
         o->via.map.ptr[0].key = msgpack::object(a0, z);

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

@@ -13506,7 +13506,7 @@ struct object_with_zone<type::tuple<A0> > {
         msgpack::object::with_zone& o,
         const type::tuple<A0>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*1));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*1, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 1;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
@@ -13519,7 +13519,7 @@ struct object_with_zone<type::tuple<A0, A1> > {
         msgpack::object::with_zone& o,
         const type::tuple<A0, A1>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*2));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*2, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 2;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
@@ -13533,7 +13533,7 @@ struct object_with_zone<type::tuple<A0, A1, A2> > {
         msgpack::object::with_zone& o,
         const type::tuple<A0, A1, A2>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*3));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*3, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 3;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
@@ -13548,7 +13548,7 @@ struct object_with_zone<type::tuple<A0, A1, A2, A3> > {
         msgpack::object::with_zone& o,
         const type::tuple<A0, A1, A2, A3>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*4));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*4, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 4;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
@@ -13564,7 +13564,7 @@ struct object_with_zone<type::tuple<A0, A1, A2, A3, A4> > {
         msgpack::object::with_zone& o,
         const type::tuple<A0, A1, A2, A3, A4>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*5));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*5, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 5;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
@@ -13581,7 +13581,7 @@ struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5> > {
         msgpack::object::with_zone& o,
         const type::tuple<A0, A1, A2, A3, A4, A5>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*6));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*6, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 6;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
@@ -13599,7 +13599,7 @@ struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6> > {
         msgpack::object::with_zone& o,
         const type::tuple<A0, A1, A2, A3, A4, A5, A6>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*7));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*7, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 7;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
@@ -13618,7 +13618,7 @@ struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7> > {
         msgpack::object::with_zone& o,
         const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*8));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*8, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 8;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
@@ -13638,7 +13638,7 @@ struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8> > {
         msgpack::object::with_zone& o,
         const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*9));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*9, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 9;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
@@ -13659,7 +13659,7 @@ struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> > {
         msgpack::object::with_zone& o,
         const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*10));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*10, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 10;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
@@ -13681,7 +13681,7 @@ struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>
         msgpack::object::with_zone& o,
         const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*11));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*11, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 11;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
@@ -13704,7 +13704,7 @@ struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
         msgpack::object::with_zone& o,
         const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*12));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*12, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 12;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
@@ -13728,7 +13728,7 @@ struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
         msgpack::object::with_zone& o,
         const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*13));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*13, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 13;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
@@ -13753,7 +13753,7 @@ struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
         msgpack::object::with_zone& o,
         const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*14));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*14, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 14;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
@@ -13779,7 +13779,7 @@ struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
         msgpack::object::with_zone& o,
         const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*15));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*15, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 15;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
@@ -13806,7 +13806,7 @@ struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
         msgpack::object::with_zone& o,
         const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*16));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*16, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 16;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
@@ -13834,7 +13834,7 @@ struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
         msgpack::object::with_zone& o,
         const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*17));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*17, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 17;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
@@ -13863,7 +13863,7 @@ struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
         msgpack::object::with_zone& o,
         const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*18));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*18, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 18;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
@@ -13893,7 +13893,7 @@ struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
         msgpack::object::with_zone& o,
         const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*19));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*19, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 19;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
@@ -13924,7 +13924,7 @@ struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
         msgpack::object::with_zone& o,
         const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*20));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*20, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 20;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
@@ -13956,7 +13956,7 @@ struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
         msgpack::object::with_zone& o,
         const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*21));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*21, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 21;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
@@ -13989,7 +13989,7 @@ struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
         msgpack::object::with_zone& o,
         const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*22));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*22, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 22;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
@@ -14023,7 +14023,7 @@ struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
         msgpack::object::with_zone& o,
         const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*23));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*23, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 23;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
@@ -14058,7 +14058,7 @@ struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
         msgpack::object::with_zone& o,
         const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*24));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*24, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 24;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
@@ -14094,7 +14094,7 @@ struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
         msgpack::object::with_zone& o,
         const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*25));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*25, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 25;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
@@ -14131,7 +14131,7 @@ struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
         msgpack::object::with_zone& o,
         const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*26));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*26, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 26;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
@@ -14169,7 +14169,7 @@ struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
         msgpack::object::with_zone& o,
         const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*27));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*27, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 27;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
@@ -14208,7 +14208,7 @@ struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
         msgpack::object::with_zone& o,
         const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*28));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*28, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 28;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
@@ -14248,7 +14248,7 @@ struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
         msgpack::object::with_zone& o,
         const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*29));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*29, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 29;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
@@ -14289,7 +14289,7 @@ struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
         msgpack::object::with_zone& o,
         const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*30));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*30, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 30;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
@@ -14331,7 +14331,7 @@ struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
         msgpack::object::with_zone& o,
         const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*31));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*31, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 31;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
@@ -14374,7 +14374,7 @@ struct object_with_zone<type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
         msgpack::object::with_zone& o,
         const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*32));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*32, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = 32;
         
         o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);

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

@@ -77,7 +77,7 @@ struct define_array {
     void msgpack_object(msgpack::object* o, msgpack::zone& z) const
     {
         o->type = msgpack::type::ARRAY;
-        o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*sizeof...(Args)));
+        o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*sizeof...(Args), MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o->via.array.size = sizeof...(Args);
 
         define_array_imp<std::tuple<Args&...>, sizeof...(Args)>::object(o, z, a);

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

@@ -83,7 +83,7 @@ struct define_map {
     {
         static_assert(sizeof...(Args) % 2 == 0, "");
         o->type = msgpack::type::MAP;
-        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*sizeof...(Args)/2));
+        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*sizeof...(Args)/2, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
         o->via.map.size = sizeof...(Args) / 2;
 
         define_map_imp<std::tuple<Args&...>, sizeof...(Args)>::object(o, z, a);

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

@@ -203,7 +203,7 @@ template <typename... Args>
         msgpack::object::with_zone& o,
         msgpack::type::tuple<Args...> const& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*sizeof...(Args)));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*sizeof...(Args), MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = sizeof...(Args);
         MsgpackTupleToObjectWithZone<decltype(v), sizeof...(Args)>::convert(o, v);
     }

include/msgpack/v1/adaptor/ext.hpp

@@ -104,7 +104,7 @@ struct object_with_zone<msgpack::type::ext> {
         // 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));
+        char* ptr = static_cast<char*>(o.zone.allocate_align(size + 1, MSGPACK_ZONE_ALIGNOF(char)));
         o.via.ext.ptr = ptr;
         o.via.ext.size = size;
         ptr[0] = static_cast<char>(v.type());

include/msgpack/v1/adaptor/list.hpp

@@ -81,7 +81,7 @@ struct object_with_zone<std::list<T, Alloc> > {
         }
         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* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
             msgpack::object* const pend = p + size;
             o.via.array.ptr = p;
             o.via.array.size = size;

include/msgpack/v1/adaptor/map.hpp

@@ -109,7 +109,7 @@ struct object_with_zone<type::assoc_vector<K, V, Compare, Alloc> > {
         }
         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* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
             msgpack::object_kv* const pend = p + size;
             o.via.map.ptr  = p;
             o.via.map.size = size;
@@ -195,21 +195,21 @@ struct object_with_zone<std::map<K, V, Compare, Alloc> > {
         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* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
             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 {
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
                 p->key = msgpack::object(it->first, o.zone);
                 p->val = msgpack::object(it->second, o.zone);
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 #pragma GCC diagnostic pop
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
                 ++p;
                 ++it;
             } while(p < pend);
@@ -288,7 +288,7 @@ struct object_with_zone<std::multimap<K, V, Compare, Alloc> > {
         }
         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* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
             msgpack::object_kv* const pend = p + size;
             o.via.map.ptr  = p;
             o.via.map.size = size;

include/msgpack/v1/adaptor/pair.hpp

@@ -64,7 +64,7 @@ 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));
+        msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*2, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.ptr = p;
         o.via.array.size = 2;
         p[0] = msgpack::object(v.first, o.zone);

include/msgpack/v1/adaptor/set.hpp

@@ -87,7 +87,7 @@ struct object_with_zone<std::set<T, Compare, Alloc> > {
         }
         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* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
             msgpack::object* const pend = p + size;
             o.via.array.ptr = p;
             o.via.array.size = size;
@@ -163,7 +163,7 @@ struct object_with_zone<std::multiset<T, Compare, Alloc> > {
             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* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
             msgpack::object* const pend = p + size;
             o.via.array.ptr = p;
             o.via.array.size = size;

include/msgpack/v1/adaptor/string.hpp

@@ -69,7 +69,7 @@ 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));
+        char* ptr = static_cast<char*>(o.zone.allocate_align(size, MSGPACK_ZONE_ALIGNOF(char)));
         o.via.str.ptr = ptr;
         o.via.str.size = size;
         std::memcpy(ptr, v.data(), v.size());

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

@@ -84,7 +84,7 @@ struct object_with_zone<MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc>
             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* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
             msgpack::object_kv* const pend = p + size;
             o.via.map.ptr  = p;
             o.via.map.size = size;
@@ -141,7 +141,7 @@ struct object_with_zone<MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Al
             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* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
             msgpack::object_kv* const pend = p + size;
             o.via.map.ptr  = p;
             o.via.map.size = size;

include/msgpack/v1/adaptor/tr1/unordered_set.hpp

@@ -82,7 +82,7 @@ struct object_with_zone<MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc>
             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* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
             msgpack::object* const pend = p + size;
             o.via.array.ptr = p;
             o.via.array.size = size;
@@ -136,7 +136,7 @@ struct object_with_zone<MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Al
             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* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
             msgpack::object* const pend = p + size;
             o.via.array.ptr = p;
             o.via.array.size = size;

include/msgpack/v1/adaptor/vector.hpp

@@ -89,20 +89,20 @@ struct object_with_zone<std::vector<T, Alloc> > {
         }
         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* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
             msgpack::object* const pend = p + size;
             o.via.array.ptr = p;
             o.via.array.size = size;
             typename std::vector<T, Alloc>::const_iterator it(v.begin());
             do {
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
                 *p = msgpack::object(*it, o.zone);
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 #pragma GCC diagnostic pop
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
                 ++p;
                 ++it;
             } while(p < pend);

include/msgpack/v1/adaptor/vector_bool.hpp

@@ -65,7 +65,7 @@ struct object_with_zone<std::vector<bool, Alloc> > {
             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* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
             msgpack::object* const pend = p + size;
             o.via.array.ptr = p;
             o.via.array.size = size;

include/msgpack/v1/adaptor/vector_char.hpp

@@ -32,27 +32,27 @@ struct convert<std::vector<char, Alloc> > {
         case msgpack::type::BIN:
             v.resize(o.via.bin.size);
             if (o.via.bin.size != 0) {
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
                 std::memcpy(&v.front(), o.via.bin.ptr, o.via.bin.size);
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 #pragma GCC diagnostic pop
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
             }
             break;
         case msgpack::type::STR:
             v.resize(o.via.str.size);
             if (o.via.str.size != 0) {
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
                 std::memcpy(&v.front(), o.via.str.ptr, o.via.str.size);
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 #pragma GCC diagnostic pop
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
             }
             break;
         default:
@@ -96,7 +96,7 @@ struct object_with_zone<std::vector<char, Alloc> > {
         o.type = msgpack::type::BIN;
         o.via.bin.size = size;
         if (size != 0) {
-            char* ptr = static_cast<char*>(o.zone.allocate_align(size));
+            char* ptr = static_cast<char*>(o.zone.allocate_align(size, MSGPACK_ZONE_ALIGNOF(char)));
             o.via.bin.ptr = ptr;
             std::memcpy(ptr, &v.front(), size);
         }

include/msgpack/v1/adaptor/vector_unsigned_char.hpp

@@ -32,27 +32,27 @@ struct convert<std::vector<unsigned char, Alloc> > {
         case msgpack::type::BIN:
             v.resize(o.via.bin.size);
             if (o.via.bin.size != 0) {
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
                 std::memcpy(&v.front(), o.via.bin.ptr, o.via.bin.size);
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 #pragma GCC diagnostic pop
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
             }
             break;
         case msgpack::type::STR:
             v.resize(o.via.str.size);
             if (o.via.str.size != 0) {
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
                 std::memcpy(&v.front(), o.via.str.ptr, o.via.str.size);
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 #pragma GCC diagnostic pop
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
             }
             break;
         default:
@@ -96,7 +96,7 @@ struct object_with_zone<std::vector<unsigned char, Alloc> > {
         o.type = msgpack::type::BIN;
         o.via.bin.size = size;
         if (size != 0) {
-            char* ptr = static_cast<char*>(o.zone.allocate_align(size));
+            char* ptr = static_cast<char*>(o.zone.allocate_align(size, MSGPACK_ZONE_ALIGNOF(char)));
             o.via.bin.ptr = ptr;
             std::memcpy(ptr, &v.front(), size);
         }

include/msgpack/v1/detail/cpp03_zone.hpp

@@ -223,7 +223,9 @@ private:
     template <typename T>
     static void object_delete(void* obj);
 
-    void* allocate_expand(size_t size);
+    static char* get_aligned(char* ptr, size_t align);
+
+    char* allocate_expand(size_t size);
 private:
     zone(const zone&);
     zone& operator=(const zone&);
@@ -233,37 +235,42 @@ inline zone::zone(size_t chunk_size) /* throw() */ :m_chunk_size(chunk_size), m_
 {
 }
 
-inline void* zone::allocate_align(size_t size, size_t align)
+inline char* zone::get_aligned(char* ptr, size_t align)
 {
-    char* aligned =
+    return
         reinterpret_cast<char*>(
             reinterpret_cast<size_t>(
-                (m_chunk_list.m_ptr + (align - 1))) / align * align);
+            (ptr + (align - 1))) / align * align);
+}
+
+inline void* zone::allocate_align(size_t size, size_t align)
+{
+    char* aligned = get_aligned(m_chunk_list.m_ptr, align);
     size_t adjusted_size = size + (aligned - m_chunk_list.m_ptr);
-    if(m_chunk_list.m_free >= adjusted_size) {
+    if (m_chunk_list.m_free < adjusted_size) {
+        size_t enough_size = size + align - 1;
+        char* ptr = allocate_expand(enough_size);
+        aligned = get_aligned(ptr, align);
+        adjusted_size = size + (aligned - m_chunk_list.m_ptr);
+    }
     m_chunk_list.m_free -= adjusted_size;
     m_chunk_list.m_ptr  += adjusted_size;
     return aligned;
-    }
-    return reinterpret_cast<char*>(
-        reinterpret_cast<size_t>(
-            allocate_expand(size + (align - 1))) / align * align);
 }
 
 inline void* zone::allocate_no_align(size_t size)
 {
-    if(m_chunk_list.m_free < size) {
-        return allocate_expand(size);
-    }
-
     char* ptr = m_chunk_list.m_ptr;
+    if(m_chunk_list.m_free < size) {
+        ptr = allocate_expand(size);
+    }
     m_chunk_list.m_free -= size;
     m_chunk_list.m_ptr  += size;
 
     return ptr;
 }
 
-inline void* zone::allocate_expand(size_t size)
+inline char* zone::allocate_expand(size_t size)
 {
     chunk_list* const cl = &m_chunk_list;
 
@@ -285,8 +292,8 @@ inline void* zone::allocate_expand(size_t size)
 
     c->m_next  = cl->m_head;
     cl->m_head = c;
-    cl->m_free = sz - size;
-    cl->m_ptr  = ptr + size;
+    cl->m_free = sz;
+    cl->m_ptr  = ptr;
 
     return ptr;
 }
@@ -345,7 +352,7 @@ inline std::size_t aligned_size(
 template <typename T>
 T* zone::allocate()
 {
-    void* x = allocate_align(sizeof(T));
+    void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
     try {
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
@@ -364,7 +371,7 @@ T* zone::allocate()
 template <typename T, typename A1>
 T* zone::allocate(A1 a1)
 {
-    void* x = allocate_align(sizeof(T));
+    void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
     try {
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
@@ -383,7 +390,7 @@ T* zone::allocate(A1 a1)
 template <typename T, typename A1, typename A2>
 T* zone::allocate(A1 a1, A2 a2)
 {
-    void* x = allocate_align(sizeof(T));
+    void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
     try {
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
@@ -402,7 +409,7 @@ T* zone::allocate(A1 a1, A2 a2)
 template <typename T, typename A1, typename A2, typename A3>
 T* zone::allocate(A1 a1, A2 a2, A3 a3)
 {
-    void* x = allocate_align(sizeof(T));
+    void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
     try {
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
@@ -421,7 +428,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3)
 template <typename T, typename A1, typename A2, typename A3, typename A4>
 T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4)
 {
-    void* x = allocate_align(sizeof(T));
+    void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
     try {
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
@@ -440,7 +447,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4)
 template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5>
 T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
 {
-    void* x = allocate_align(sizeof(T));
+    void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
     try {
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
@@ -459,7 +466,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
 template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
 T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
 {
-    void* x = allocate_align(sizeof(T));
+    void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
     try {
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
@@ -478,7 +485,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
 template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
 T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
 {
-    void* x = allocate_align(sizeof(T));
+    void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
     try {
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
@@ -497,7 +504,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
 template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
 T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
 {
-    void* x = allocate_align(sizeof(T));
+    void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
     try {
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
@@ -516,7 +523,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
 template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
 T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
 {
-    void* x = allocate_align(sizeof(T));
+    void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
     try {
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
@@ -535,7 +542,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
 template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10>
 T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
 {
-    void* x = allocate_align(sizeof(T));
+    void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
     try {
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
@@ -554,7 +561,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,
 template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11>
 T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11)
 {
-    void* x = allocate_align(sizeof(T));
+    void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
     try {
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
@@ -573,7 +580,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,
 template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12>
 T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12)
 {
-    void* x = allocate_align(sizeof(T));
+    void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
     try {
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
@@ -592,7 +599,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,
 template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13>
 T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13)
 {
-    void* x = allocate_align(sizeof(T));
+    void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
     try {
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
@@ -611,7 +618,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,
 template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14>
 T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14)
 {
-    void* x = allocate_align(sizeof(T));
+    void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
     try {
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
@@ -630,7 +637,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,
 template <typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15>
 T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15)
 {
-    void* x = allocate_align(sizeof(T));
+    void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
     try {
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {

include/msgpack/v1/detail/cpp03_zone_decl.hpp

@@ -24,6 +24,14 @@
 #define MSGPACK_ZONE_ALIGN sizeof(void*)
 #endif
 
+#if defined(_MSC_VER)
+#define MSGPACK_ZONE_ALIGNOF(type) __alignof(type)
+#else
+#define MSGPACK_ZONE_ALIGNOF(type) __alignof__(type)
+#endif
+// For a compiler that doesn't support __alignof__:
+// #define MSGPACK_ZONE_ALIGNOF(type) MSGPACK_ZONE_ALIGN
+
 
 namespace msgpack {
 

include/msgpack/v1/detail/cpp11_zone.hpp

@@ -184,7 +184,6 @@ public:
 
     void swap(zone& o);
 
-
     static void* operator new(std::size_t size)
     {
         void* p = ::malloc(size);
@@ -220,44 +219,51 @@ private:
     template <typename T>
     static void object_delete(void* obj);
 
-    void* allocate_expand(size_t size);
+    static char* get_aligned(char* ptr, size_t align);
+
+    char* allocate_expand(size_t size);
 };
 
 inline zone::zone(size_t chunk_size) noexcept:m_chunk_size(chunk_size), m_chunk_list(m_chunk_size)
 {
 }
 
-inline void* zone::allocate_align(size_t size, size_t align)
+inline char* zone::get_aligned(char* ptr, size_t align)
 {
-    char* aligned =
+    return
         reinterpret_cast<char*>(
             reinterpret_cast<size_t>(
-                (m_chunk_list.m_ptr + (align - 1))) / align * align);
+            (ptr + (align - 1))) / align * align);
+}
+
+inline void* zone::allocate_align(size_t size, size_t align)
+{
+    char* aligned = get_aligned(m_chunk_list.m_ptr, align);
     size_t adjusted_size = size + (aligned - m_chunk_list.m_ptr);
-    if(m_chunk_list.m_free >= adjusted_size) {
+    if (m_chunk_list.m_free < adjusted_size) {
+        size_t enough_size = size + align - 1;
+        char* ptr = allocate_expand(enough_size);
+        aligned = get_aligned(ptr, align);
+        adjusted_size = size + (aligned - m_chunk_list.m_ptr);
+    }
     m_chunk_list.m_free -= adjusted_size;
     m_chunk_list.m_ptr  += adjusted_size;
     return aligned;
-    }
-    return reinterpret_cast<char*>(
-        reinterpret_cast<size_t>(
-            allocate_expand(size + (align - 1))) / align * align);
 }
 
 inline void* zone::allocate_no_align(size_t size)
 {
-    if(m_chunk_list.m_free < size) {
-        return allocate_expand(size);
-    }
-
     char* ptr = m_chunk_list.m_ptr;
+    if(m_chunk_list.m_free < size) {
+        ptr = allocate_expand(size);
+    }
     m_chunk_list.m_free -= size;
     m_chunk_list.m_ptr  += size;
 
     return ptr;
 }
 
-inline void* zone::allocate_expand(size_t size)
+inline char* zone::allocate_expand(size_t size)
 {
     chunk_list* const cl = &m_chunk_list;
 
@@ -279,8 +285,8 @@ inline void* zone::allocate_expand(size_t size)
 
     c->m_next  = cl->m_head;
     cl->m_head = c;
-    cl->m_free = sz - size;
-    cl->m_ptr  = ptr + size;
+    cl->m_free = sz;
+    cl->m_ptr  = ptr;
 
     return ptr;
 }
@@ -329,7 +335,7 @@ inline void zone::undo_allocate(size_t size)
 template <typename T, typename... Args>
 T* zone::allocate(Args... args)
 {
-    void* x = allocate_align(sizeof(T));
+    void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
     try {
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {

include/msgpack/v1/detail/cpp11_zone_decl.hpp

@@ -26,6 +26,14 @@
 #define MSGPACK_ZONE_ALIGN sizeof(void*)
 #endif
 
+#if defined(_MSC_VER)
+#define MSGPACK_ZONE_ALIGNOF(type) __alignof(type)
+#else
+#define MSGPACK_ZONE_ALIGNOF(type) __alignof__(type)
+#endif
+// For a compiler that doesn't support __alignof__:
+// #define MSGPACK_ZONE_ALIGNOF(type) MSGPACK_ZONE_ALIGN
+
 namespace msgpack {
 
 /// @cond

include/msgpack/v1/object.hpp

@@ -140,13 +140,17 @@ inline std::size_t aligned_zone_size(msgpack::object const& obj) {
     std::size_t s = 0;
     switch (obj.type) {
     case msgpack::type::ARRAY:
-        s += sizeof(msgpack::object) * obj.via.array.size;
+        s += msgpack::aligned_size(
+            sizeof(msgpack::object) * obj.via.array.size,
+            MSGPACK_ZONE_ALIGNOF(msgpack::object));
         for (uint32_t i = 0; i < obj.via.array.size; ++i) {
             s += msgpack::aligned_zone_size(obj.via.array.ptr[i]);
         }
         break;
     case msgpack::type::MAP:
-        s += sizeof(msgpack::object_kv) * obj.via.map.size;
+        s += msgpack::aligned_size(
+            sizeof(msgpack::object_kv) * obj.via.map.size,
+            MSGPACK_ZONE_ALIGNOF(msgpack::object_kv));
         for (uint32_t i = 0; i < obj.via.map.size; ++i) {
             s += msgpack::aligned_zone_size(obj.via.map.ptr[i].key);
             s += msgpack::aligned_zone_size(obj.via.map.ptr[i].val);
@@ -154,13 +158,14 @@ inline std::size_t aligned_zone_size(msgpack::object const& obj) {
         break;
     case msgpack::type::EXT:
         s += msgpack::aligned_size(
-            detail::add_ext_type_size<sizeof(std::size_t)>(obj.via.ext.size));
+            detail::add_ext_type_size<sizeof(std::size_t)>(obj.via.ext.size),
+            MSGPACK_ZONE_ALIGNOF(char));
         break;
     case msgpack::type::STR:
-        s += msgpack::aligned_size(obj.via.str.size);
+        s += msgpack::aligned_size(obj.via.str.size, MSGPACK_ZONE_ALIGNOF(char));
         break;
     case msgpack::type::BIN:
-        s += msgpack::aligned_size(obj.via.bin.size);
+        s += msgpack::aligned_size(obj.via.bin.size, MSGPACK_ZONE_ALIGNOF(char));
         break;
     default:
         break;
@@ -320,7 +325,7 @@ struct object_with_zone<msgpack::object> {
             return;
 
         case msgpack::type::STR: {
-            char* ptr = static_cast<char*>(o.zone.allocate_align(v.via.str.size));
+            char* ptr = static_cast<char*>(o.zone.allocate_align(v.via.str.size, MSGPACK_ZONE_ALIGNOF(char)));
             o.via.str.ptr = ptr;
             o.via.str.size = v.via.str.size;
             std::memcpy(ptr, v.via.str.ptr, v.via.str.size);
@@ -328,7 +333,7 @@ struct object_with_zone<msgpack::object> {
         }
 
         case msgpack::type::BIN: {
-            char* ptr = static_cast<char*>(o.zone.allocate_align(v.via.bin.size));
+            char* ptr = static_cast<char*>(o.zone.allocate_align(v.via.bin.size, MSGPACK_ZONE_ALIGNOF(char)));
             o.via.bin.ptr = ptr;
             o.via.bin.size = v.via.bin.size;
             std::memcpy(ptr, v.via.bin.ptr, v.via.bin.size);
@@ -336,7 +341,7 @@ struct object_with_zone<msgpack::object> {
         }
 
         case msgpack::type::EXT: {
-            char* ptr = static_cast<char*>(o.zone.allocate_align(v.via.ext.size + 1));
+            char* ptr = static_cast<char*>(o.zone.allocate_align(v.via.ext.size + 1, MSGPACK_ZONE_ALIGNOF(char)));
             o.via.ext.ptr = ptr;
             o.via.ext.size = v.via.ext.size;
             std::memcpy(ptr, v.via.ext.ptr, v.via.ext.size + 1);
@@ -344,7 +349,7 @@ struct object_with_zone<msgpack::object> {
         }
 
         case msgpack::type::ARRAY:
-            o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object) * v.via.array.size));
+            o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object) * v.via.array.size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
             o.via.array.size = v.via.array.size;
             for (msgpack::object
                      * po(o.via.array.ptr),
@@ -357,7 +362,7 @@ struct object_with_zone<msgpack::object> {
             return;
 
         case msgpack::type::MAP:
-            o.via.map.ptr = (msgpack::object_kv*)o.zone.allocate_align(sizeof(msgpack::object_kv) * v.via.map.size);
+            o.via.map.ptr = (msgpack::object_kv*)o.zone.allocate_align(sizeof(msgpack::object_kv) * v.via.map.size, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv));
             o.via.map.size = v.via.map.size;
             for(msgpack::object_kv
                     * po(o.via.map.ptr),

include/msgpack/v1/unpack.hpp

@@ -117,7 +117,7 @@ struct unpack_array {
         if (size / sizeof(msgpack::object) != n) {
             throw msgpack::array_size_overflow("array size overflow");
         }
-        o.via.array.ptr = static_cast<msgpack::object*>(u.zone().allocate_align(size));
+        o.via.array.ptr = static_cast<msgpack::object*>(u.zone().allocate_align(size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
     }
 };
 
@@ -139,7 +139,7 @@ struct unpack_map {
         if (size / sizeof(msgpack::object_kv) != n) {
             throw msgpack::map_size_overflow("map size overflow");
         }
-        o.via.map.ptr = static_cast<msgpack::object_kv*>(u.zone().allocate_align(size));
+        o.via.map.ptr = static_cast<msgpack::object_kv*>(u.zone().allocate_align(size, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
     }
 };
 
@@ -164,7 +164,7 @@ inline void unpack_str(unpack_user& u, const char* p, uint32_t l, msgpack::objec
     }
     else {
         if (l > u.limit().str()) throw msgpack::str_size_overflow("str size overflow");
-        char* tmp = static_cast<char*>(u.zone().allocate_align(l));
+        char* tmp = static_cast<char*>(u.zone().allocate_align(l, MSGPACK_ZONE_ALIGNOF(char)));
         std::memcpy(tmp, p, l);
         o.via.str.ptr = tmp;
     }
@@ -180,7 +180,7 @@ inline void unpack_bin(unpack_user& u, const char* p, uint32_t l, msgpack::objec
     }
     else {
         if (l > u.limit().bin()) throw msgpack::bin_size_overflow("bin size overflow");
-        char* tmp = static_cast<char*>(u.zone().allocate_align(l));
+        char* tmp = static_cast<char*>(u.zone().allocate_align(l, MSGPACK_ZONE_ALIGNOF(char)));
         std::memcpy(tmp, p, l);
         o.via.bin.ptr = tmp;
     }
@@ -196,7 +196,7 @@ inline void unpack_ext(unpack_user& u, const char* p, std::size_t l, msgpack::ob
     }
     else {
         if (l > u.limit().ext()) throw msgpack::ext_size_overflow("ext size overflow");
-        char* tmp = static_cast<char*>(u.zone().allocate_align(l));
+        char* tmp = static_cast<char*>(u.zone().allocate_align(l, MSGPACK_ZONE_ALIGNOF(char)));
         std::memcpy(tmp, p, l);
         o.via.ext.ptr = tmp;
     }

include/msgpack/v1/vrefbuffer.hpp

@@ -1,7 +1,7 @@
 //
 // MessagePack for C++ zero-copy buffer implementation
 //
-// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi
+// Copyright (C) 2008-2017 FURUHASHI Sadayuki and KONDO Takatoshi
 //
 //    Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
@@ -22,7 +22,7 @@
 #endif
 #endif // defined(_MSC_VER)
 
-#ifndef _WIN32
+#if defined(unix) || defined(__unix) || defined(__APPLE__) || defined(__OpenBSD__)
 #include <sys/uio.h>
 #else
 struct iovec {

include/msgpack/v2/create_object_visitor.hpp

@@ -92,9 +92,15 @@ public:
         }
         return true;
     }
-    bool visit_float(double v) {
+    bool visit_float32(float v) {
         msgpack::object* obj = m_stack.back();
-        obj->type = msgpack::type::FLOAT;
+        obj->type = msgpack::type::FLOAT32;
+        obj->via.f64 = v;
+        return true;
+    }
+    bool visit_float64(double v) {
+        msgpack::object* obj = m_stack.back();
+        obj->type = msgpack::type::FLOAT64;
         obj->via.f64 = v;
         return true;
     }
@@ -107,7 +113,7 @@ public:
             set_referenced(true);
         }
         else {
-            char* tmp = static_cast<char*>(zone().allocate_align(size));
+            char* tmp = static_cast<char*>(zone().allocate_align(size, MSGPACK_ZONE_ALIGNOF(char)));
             std::memcpy(tmp, v, size);
             obj->via.str.ptr = tmp;
         }
@@ -123,7 +129,7 @@ public:
             set_referenced(true);
         }
         else {
-            char* tmp = static_cast<char*>(zone().allocate_align(size));
+            char* tmp = static_cast<char*>(zone().allocate_align(size, MSGPACK_ZONE_ALIGNOF(char)));
             std::memcpy(tmp, v, size);
             obj->via.bin.ptr = tmp;
         }
@@ -139,7 +145,7 @@ public:
             set_referenced(true);
         }
         else {
-            char* tmp = static_cast<char*>(zone().allocate_align(size));
+            char* tmp = static_cast<char*>(zone().allocate_align(size, MSGPACK_ZONE_ALIGNOF(char)));
             std::memcpy(tmp, v, size);
             obj->via.ext.ptr = tmp;
         }
@@ -161,7 +167,7 @@ public:
                 throw msgpack::array_size_overflow("array size overflow");
             }
             obj->via.array.ptr =
-                static_cast<msgpack::object*>(m_zone->allocate_align(size));
+                static_cast<msgpack::object*>(m_zone->allocate_align(size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         }
         m_stack.push_back(obj->via.array.ptr);
         return true;
@@ -192,7 +198,7 @@ public:
                 throw msgpack::map_size_overflow("map size overflow");
             }
             obj->via.map.ptr =
-                static_cast<msgpack::object_kv*>(m_zone->allocate_align(size));
+                static_cast<msgpack::object_kv*>(m_zone->allocate_align(size, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
         }
         m_stack.push_back(reinterpret_cast<msgpack::object*>(obj->via.map.ptr));
         return true;

include/msgpack/v2/null_visitor.hpp

@@ -32,7 +32,10 @@ struct null_visitor {
     bool visit_negative_integer(int64_t /*v*/) {
         return true;
     }
-    bool visit_float(double /*v*/) {
+    bool visit_float32(float /*v*/) {
+        return true;
+    }
+    bool visit_float64(double /*v*/) {
         return true;
     }
     bool visit_str(const char* /*v*/, uint32_t /*size*/) {

include/msgpack/v2/parse.hpp

@@ -75,11 +75,15 @@ private:
             }
         }
         else {
-            m_stack.push(sv.type(), static_cast<uint32_t>(size));
             if (!sv(size)) {
                 off = m_current - m_start;
                 return PARSE_STOP_VISITOR;
             }
+            parse_return ret = m_stack.push(holder(), sv.type(), static_cast<uint32_t>(size));
+            if (ret != PARSE_CONTINUE) {
+                off = m_current - m_start;
+                return ret;
+            }
         }
         m_cs = MSGPACK_CS_HEADER;
         return PARSE_CONTINUE;
@@ -92,12 +96,10 @@ private:
             return PARSE_STOP_VISITOR;
         }
         parse_return ret = m_stack.consume(holder());
-        if (ret == PARSE_CONTINUE) {
-            m_cs = MSGPACK_CS_HEADER;
-        }
-        else {
+        if (ret != PARSE_CONTINUE) {
             off = m_current - m_start;
         }
+        m_cs = MSGPACK_CS_HEADER;
         return ret;
     }
 
@@ -145,8 +147,19 @@ private:
         unpack_stack() {
             m_stack.reserve(MSGPACK_EMBED_STACK_SIZE);
         }
-        void push(msgpack_container_type type, uint32_t rest) {
+        parse_return push(VisitorHolder& visitor_holder, msgpack_container_type type, uint32_t rest) {
             m_stack.push_back(stack_elem(type, rest));
+            switch (type) {
+            case MSGPACK_CT_ARRAY_ITEM:
+                return visitor_holder.visitor().start_array_item() ? PARSE_CONTINUE : PARSE_STOP_VISITOR;
+            case MSGPACK_CT_MAP_KEY:
+                return visitor_holder.visitor().start_map_key() ? PARSE_CONTINUE : PARSE_STOP_VISITOR;
+            case MSGPACK_CT_MAP_VALUE:
+                assert(0);
+                return PARSE_STOP_VISITOR;
+            }
+            assert(0);
+            return PARSE_STOP_VISITOR;
         }
         parse_return consume(VisitorHolder& visitor_holder) {
             while (!m_stack.empty()) {
@@ -287,11 +300,9 @@ inline parse_return context<VisitorHolder>::execute(const char* data, std::size_
             } else if(0x90 <= selector && selector <= 0x9f) { // FixArray
                 parse_return ret = start_aggregate<fix_tag>(array_sv(holder()), array_ev(holder()), m_current, off);
                 if (ret != PARSE_CONTINUE) return ret;
-                if (!holder().visitor().start_array_item()) return PARSE_STOP_VISITOR;
             } else if(0x80 <= selector && selector <= 0x8f) { // FixMap
                 parse_return ret = start_aggregate<fix_tag>(map_sv(holder()), map_ev(holder()), m_current, off);
                 if (ret != PARSE_CONTINUE) return ret;
-                if (!holder().visitor().start_map_key()) return PARSE_STOP_VISITOR;
             } else if(selector == 0xc2) { // false
                 bool visret = holder().visitor().visit_boolean(false);
                 parse_return upr = after_visit_proc(visret, off);
@@ -328,7 +339,7 @@ inline parse_return context<VisitorHolder>::execute(const char* data, std::size_
             case MSGPACK_CS_FLOAT: {
                 union { uint32_t i; float f; } mem;
                 load<uint32_t>(mem.i, n);
-                bool visret = holder().visitor().visit_float(mem.f);
+                bool visret = holder().visitor().visit_float32(mem.f);
                 parse_return upr = after_visit_proc(visret, off);
                 if (upr != PARSE_CONTINUE) return upr;
             } break;
@@ -341,7 +352,7 @@ inline parse_return context<VisitorHolder>::execute(const char* data, std::size_
                 // https://github.com/msgpack/msgpack-perl/pull/1
                 mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL);
 #endif
-                bool visret = holder().visitor().visit_float(mem.f);
+                bool visret = holder().visitor().visit_float64(mem.f);
                 parse_return upr = after_visit_proc(visret, off);
                 if (upr != PARSE_CONTINUE) return upr;
             } break;
@@ -459,7 +470,7 @@ inline parse_return context<VisitorHolder>::execute(const char* data, std::size_
                 load<uint8_t>(tmp, n);
                 m_trail = tmp + 1;
                 if(m_trail == 0) {
-                    bool visret = holder().visitor().visit_ext(n, m_trail);
+                    bool visret = holder().visitor().visit_ext(n, static_cast<uint32_t>(m_trail));
                     parse_return upr = after_visit_proc(visret, off);
                     if (upr != PARSE_CONTINUE) return upr;
                 }
@@ -501,7 +512,7 @@ inline parse_return context<VisitorHolder>::execute(const char* data, std::size_
                 load<uint16_t>(tmp, n);
                 m_trail = tmp + 1;
                 if(m_trail == 0) {
-                    bool visret = holder().visitor().visit_ext(n, m_trail);
+                    bool visret = holder().visitor().visit_ext(n, static_cast<uint32_t>(m_trail));
                     parse_return upr = after_visit_proc(visret, off);
                     if (upr != PARSE_CONTINUE) return upr;
                 }
@@ -545,7 +556,7 @@ inline parse_return context<VisitorHolder>::execute(const char* data, std::size_
                 m_trail = tmp;
                 ++m_trail;
                 if(m_trail == 0) {
-                    bool visret = holder().visitor().visit_ext(n, m_trail);
+                    bool visret = holder().visitor().visit_ext(n, static_cast<uint32_t>(m_trail));
                     parse_return upr = after_visit_proc(visret, off);
                     if (upr != PARSE_CONTINUE) return upr;
                 }
@@ -555,7 +566,7 @@ inline parse_return context<VisitorHolder>::execute(const char* data, std::size_
                 }
             } break;
             case MSGPACK_ACS_STR_VALUE: {
-                bool visret = holder().visitor().visit_str(n, m_trail);
+                bool visret = holder().visitor().visit_str(n, static_cast<uint32_t>(m_trail));
                 parse_return upr = after_visit_proc(visret, off);
                 if (upr != PARSE_CONTINUE) return upr;
             } break;
@@ -565,30 +576,26 @@ inline parse_return context<VisitorHolder>::execute(const char* data, std::size_
                 if (upr != PARSE_CONTINUE) return upr;
             } break;
             case MSGPACK_ACS_EXT_VALUE: {
-                bool visret = holder().visitor().visit_ext(n, m_trail);
+                bool visret = holder().visitor().visit_ext(n, static_cast<uint32_t>(m_trail));
                 parse_return upr = after_visit_proc(visret, off);
                 if (upr != PARSE_CONTINUE) return upr;
             } break;
             case MSGPACK_CS_ARRAY_16: {
                 parse_return ret = start_aggregate<uint16_t>(array_sv(holder()), array_ev(holder()), n, off);
                 if (ret != PARSE_CONTINUE) return ret;
-                if (!holder().visitor().start_array_item()) return PARSE_STOP_VISITOR;
 
             } break;
             case MSGPACK_CS_ARRAY_32: {
                 parse_return ret = start_aggregate<uint32_t>(array_sv(holder()), array_ev(holder()), n, off);
                 if (ret != PARSE_CONTINUE) return ret;
-                if (!holder().visitor().start_array_item()) return PARSE_STOP_VISITOR;
             } break;
             case MSGPACK_CS_MAP_16: {
                 parse_return ret = start_aggregate<uint16_t>(map_sv(holder()), map_ev(holder()), n, off);
                 if (ret != PARSE_CONTINUE) return ret;
-                if (!holder().visitor().start_map_key()) return PARSE_STOP_VISITOR;
             } break;
             case MSGPACK_CS_MAP_32: {
                 parse_return ret = start_aggregate<uint32_t>(map_sv(holder()), map_ev(holder()), n, off);
                 if (ret != PARSE_CONTINUE) return ret;
-                if (!holder().visitor().start_map_key()) return PARSE_STOP_VISITOR;
             } break;
             default:
                 off = m_current - m_start;
@@ -839,7 +846,7 @@ template <typename VisitorHolder, typename ReferencedBufferHook>
 inline void parser<VisitorHolder, ReferencedBufferHook>::expand_buffer(std::size_t size)
 {
     if(m_used == m_off && detail::get_count(m_buffer) == 1
-       && static_cast<VisitorHolder&>(*this).visitor().referenced()) {
+       && !static_cast<VisitorHolder&>(*this).visitor().referenced()) {
         // rewind buffer
         m_free += m_used - COUNTER_SIZE;
         m_used = COUNTER_SIZE;

include/msgpack/v2/unpack.hpp

@@ -20,6 +20,7 @@ namespace msgpack {
 MSGPACK_API_VERSION_NAMESPACE(v2) {
 /// @endcond
 
+
 struct zone_push_finalizer {
     zone_push_finalizer(msgpack::zone& z):m_z(&z) {}
     void set_zone(msgpack::zone& z) { m_z = &z; }

include/msgpack/v2/x3_parse.hpp

@@ -298,7 +298,7 @@ const auto mp_object_def =
                 auto& app_specific = x3::get<tag_app_specific>(ctx).get();
                 union { uint32_t i; float f; } mem;
                 mem.i = _attr(ctx);
-                app_specific.vis.visit_float(mem.f);
+                app_specific.vis.visit_float32(mem.f);
             }
         )
     ]
@@ -316,7 +316,7 @@ const auto mp_object_def =
                 // https://github.com/msgpack/msgpack-perl/pull/1
                 mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL);
 #endif
-                app_specific.vis.visit_float(mem.f);
+                app_specific.vis.visit_float64(mem.f);
             }
         )
     ]

include/msgpack/version_master.h

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

include/msgpack/vrefbuffer.h

@@ -13,7 +13,7 @@
 #include "zone.h"
 #include <stdlib.h>
 
-#ifndef _WIN32
+#if defined(unix) || defined(__unix) || defined(__APPLE__) || defined(__OpenBSD__)
 #include <sys/uio.h>
 #else
 struct iovec {

makedist.sh

@@ -34,6 +34,7 @@ tar --append --file=$filename $prefix/COPYING
 tar --append --file=$filename $prefix/README
 tar --append --file=$filename $prefix/msgpack_vc8.sln
 tar --append --file=$filename $prefix/msgpack_vc8.vcproj
+tar --append --file=$filename $prefix/msgpack-config.cmake.in
 
 rm -f $prefix
 

msgpack-config.cmake.in

@@ -0,0 +1,23 @@
+#.rst:
+# msgpack
+# -------
+#
+# The following import targets are created
+#
+# ::
+#
+#   msgpackc-static
+#   msgpackc
+#
+
+@PACKAGE_INIT@
+
+include(CMakeFindDependencyMacro)
+
+if(NOT TARGET msgpackc AND NOT TARGET msgpackc-static)
+  include("${CMAKE_CURRENT_LIST_DIR}/msgpack-targets.cmake")
+
+  if(NOT @MSGPACK_ENABLE_SHARED@)
+    add_library(msgpackc ALIAS msgpackc-static)
+  endif()
+endif()

src/objectc.c

@@ -122,7 +122,7 @@ static void msgpack_object_bin_print(FILE* out, const char *ptr, size_t size)
     for (i = 0; i < size; ++i) {
         if (ptr[i] == '"') {
             fputs("\\\"", out);
-        } else if (isprint(ptr[i])) {
+        } else if (isprint((unsigned char)ptr[i])) {
             fputc(ptr[i], out);
         } else {
             fprintf(out, "\\x%02x", (unsigned char)ptr[i]);
@@ -142,7 +142,7 @@ static int msgpack_object_bin_print_buffer(char *buffer, size_t buffer_size, con
             ret = snprintf(aux_buffer, aux_buffer_size, "\\\"");
             aux_buffer = aux_buffer + ret;
             aux_buffer_size = aux_buffer_size - ret;
-        } else if (isprint(ptr[i])) {
+        } else if (isprint((unsigned char)ptr[i])) {
             if (aux_buffer_size > 0) {
                 memcpy(aux_buffer, ptr + i, 1);
                 aux_buffer = aux_buffer + 1;
@@ -339,7 +339,7 @@ int msgpack_object_print_buffer(char *buffer, size_t buffer_size, msgpack_object
         ret = snprintf(aux_buffer, aux_buffer_size, "\"");
         aux_buffer = aux_buffer + ret;
         aux_buffer_size = aux_buffer_size - ret;
-        ret = snprintf(aux_buffer, aux_buffer_size, "%.*s", o.via.str.size, o.via.str.ptr);
+        ret = snprintf(aux_buffer, aux_buffer_size, "%.*s", (int)o.via.str.size, o.via.str.ptr);
         aux_buffer = aux_buffer + ret;
         aux_buffer_size = aux_buffer_size - ret;
         ret = snprintf(aux_buffer, aux_buffer_size, "\"");

test/CMakeLists.txt

@@ -45,6 +45,7 @@ IF (MSGPACK_BOOST)
         boost_variant.cpp
         boost_optional.cpp
         boost_string_ref.cpp
+        boost_string_view.cpp
     )
 ENDIF ()
 
@@ -65,10 +66,10 @@ IF (MSGPACK_CXX11)
     )
 ENDIF ()
 
-IF (MSGPACK_ENABLE_SHARED)
-    SET (MSGPACK_TEST_LIB msgpackc)
-ELSE ()
-    SET (MSGPACK_TEST_LIB msgpackc-static)
+IF (MSGPACK_CXX17)
+    LIST (APPEND check_PROGRAMS
+        msgpack_cpp17.cpp
+    )
 ENDIF ()
 
 FOREACH (source_file ${check_PROGRAMS})
@@ -78,7 +79,7 @@ FOREACH (source_file ${check_PROGRAMS})
         ${source_file}
     )
     TARGET_LINK_LIBRARIES (${source_file_we}
-        ${MSGPACK_TEST_LIB}
+        msgpackc
         ${GTEST_BOTH_LIBRARIES}
         ${ZLIB_LIBRARIES}
         ${CMAKE_THREAD_LIBS_INIT}
@@ -104,4 +105,8 @@ ADD_EXECUTABLE (
     multi_file
     multi_file1.cpp multi_file2.cpp
 )
+TARGET_INCLUDE_DIRECTORIES (multi_file
+    PRIVATE
+        $<TARGET_PROPERTY:msgpackc,INTERFACE_INCLUDE_DIRECTORIES>
+)
 ADD_TEST (multi_file multi_file)

test/boost_fusion.cpp

@@ -212,4 +212,35 @@ TEST(MSGPACK_BOOST, pack_convert_no_def_con_def_con)
 
 #endif // !defined(MSGPACK_USE_CPP03
 
+#include <boost/fusion/include/std_pair.hpp>
+
+TEST(MSGPACK_BOOST, fusion_pack_unpack_convert_pair)
+{
+    std::stringstream ss;
+    std::pair<bool, int> val1(false, 42);
+    msgpack::pack(ss, val1);
+    msgpack::object_handle oh =
+        msgpack::unpack(ss.str().data(), ss.str().size());
+    std::pair<bool, int>  val2 = oh.get().as<std::pair<bool, int> >();
+    EXPECT_TRUE(val1.first == val2.first);
+    EXPECT_TRUE(val1.second == val2.second);
+}
+
+#if !defined(MSGPACK_USE_CPP03)
+
+#include <boost/fusion/include/std_tuple.hpp>
+
+TEST(MSGPACK_BOOST, fusion_pack_unpack_convert_tuple)
+{
+    std::stringstream ss;
+    std::tuple<bool, int> val1(false, 42);
+    msgpack::pack(ss, val1);
+    msgpack::object_handle oh =
+        msgpack::unpack(ss.str().data(), ss.str().size());
+    std::tuple<bool, int> val2 = oh.get().as<std::tuple<bool, int> >();
+    EXPECT_TRUE(val1 == val2);
+}
+
+#endif // !defined(MSGPACK_USE_CPP03)
+
 #endif // defined(MSGPACK_USE_BOOST)

test/boost_string_view.cpp

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

test/cases.cpp

@@ -20,6 +20,10 @@ static void feed_file(msgpack::unpacker& pac, const char* path)
 
 TEST(cases, format)
 {
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
     msgpack::unpacker pac;
     msgpack::unpacker pac_compact;
 
@@ -34,4 +38,7 @@ TEST(cases, format)
     }
 
     EXPECT_FALSE( pac_compact.next(oh) );
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
+#pragma GCC diagnostic pop
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 }

test/msgpack_c.cpp

@@ -523,7 +523,7 @@ TEST(MSGPACKC, simple_buffer_fixext_1byte_255)
 {
     const size_t size = 255;
     char buf[size];
-    for (size_t i = 0; i != size; ++i) buf[i] = i;
+    for (size_t i = 0; i != size; ++i) buf[i] = (char)i;
 
     msgpack_sbuffer sbuf;
     msgpack_sbuffer_init(&sbuf);
@@ -550,7 +550,7 @@ TEST(MSGPACKC, simple_buffer_fixext_2byte_256)
 {
     const size_t size = 256;
     char buf[size];
-    for (size_t i = 0; i != size; ++i) buf[i] = i;
+    for (size_t i = 0; i != size; ++i) buf[i] = (char)i;
 
     msgpack_sbuffer sbuf;
     msgpack_sbuffer_init(&sbuf);
@@ -577,7 +577,7 @@ TEST(MSGPACKC, simple_buffer_fixext_2byte_65535)
 {
     const size_t size = 65535;
     char buf[size];
-    for (size_t i = 0; i != size; ++i) buf[i] = i;
+    for (size_t i = 0; i != size; ++i) buf[i] = (char)i;
 
     msgpack_sbuffer sbuf;
     msgpack_sbuffer_init(&sbuf);
@@ -604,7 +604,7 @@ TEST(MSGPACKC, simple_buffer_fixext_4byte_65536)
 {
     const size_t size = 65536;
     char buf[size];
-    for (size_t i = 0; i != size; ++i) buf[i] = i;
+    for (size_t i = 0; i != size; ++i) buf[i] = (char)i;
 
     msgpack_sbuffer sbuf;
     msgpack_sbuffer_init(&sbuf);
@@ -776,7 +776,6 @@ TEST(MSGPACKC, simple_buffer_str_fix_l)
     EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
     EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type);
     EXPECT_EQ(str_size, obj.via.str.size);
-    EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size));
 
     msgpack_zone_destroy(&z);
     msgpack_sbuffer_destroy(&sbuf);
@@ -975,7 +974,6 @@ TEST(MSGPACKC, simple_buffer_v4raw_fix_l)
     EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
     EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type);
     EXPECT_EQ(str_size, obj.via.str.size);
-    EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size));
 
     msgpack_zone_destroy(&z);
     msgpack_sbuffer_destroy(&sbuf);

test/msgpack_cpp17.cpp

@@ -0,0 +1,207 @@
+#include <msgpack.hpp>
+
+#include <gtest/gtest.h>
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#if !defined(MSGPACK_USE_CPP03) && __cplusplus >= 201703
+
+// C++17
+
+TEST(MSGPACK_CPP17, optional_pack_convert_nil)
+{
+    std::stringstream ss;
+    std::optional<int> val1;
+    msgpack::pack(ss, val1);
+    msgpack::object_handle oh =
+        msgpack::unpack(ss.str().data(), ss.str().size());
+    std::optional<int> val2 = oh.get().as<std::optional<int> >();
+    EXPECT_TRUE(val1 == val2);
+}
+
+TEST(MSGPACK_CPP17, optional_pack_convert_int)
+{
+    std::stringstream ss;
+    std::optional<int> val1 = 1;
+    msgpack::pack(ss, val1);
+    msgpack::object_handle oh =
+        msgpack::unpack(ss.str().data(), ss.str().size());
+    std::optional<int> val2 = oh.get().as<std::optional<int> >();
+    EXPECT_TRUE(val1 == val2);
+}
+
+TEST(MSGPACK_CPP17, optional_pack_convert_vector)
+{
+    typedef std::optional<std::vector<int> > ovi_t;
+    std::stringstream ss;
+    ovi_t val1;
+    std::vector<int> v;
+    v.push_back(1);
+    v.push_back(2);
+    v.push_back(3);
+    val1 = v;
+    msgpack::pack(ss, val1);
+    msgpack::object_handle oh =
+        msgpack::unpack(ss.str().data(), ss.str().size());
+    ovi_t  val2 = oh.get().as<ovi_t>();
+    EXPECT_TRUE(val1 == val2);
+}
+
+TEST(MSGPACK_CPP17, optional_pack_convert_vector_optional)
+{
+    typedef std::vector<std::optional<int> > voi_t;
+    std::stringstream ss;
+    voi_t val1;
+    val1.resize(3);
+    val1[0] = 1;
+    val1[2] = 3;
+    msgpack::pack(ss, val1);
+    msgpack::object_handle oh =
+        msgpack::unpack(ss.str().data(), ss.str().size());
+    voi_t  val2 = oh.get().as<voi_t>();
+    EXPECT_TRUE(val1 == val2);
+}
+
+TEST(MSGPACK_CPP17, optional_object_nil)
+{
+    std::optional<int> val1;
+    msgpack::object obj(val1);
+    std::optional<int> val2 = obj.as<std::optional<int> >();
+    EXPECT_TRUE(val1 == val2);
+}
+
+TEST(MSGPACK_CPP17, optional_object_int)
+{
+    std::optional<int> val1 = 1;
+    msgpack::object obj(val1);
+    std::optional<int> val2 = obj.as<std::optional<int> >();
+    EXPECT_TRUE(val1 == val2);
+}
+
+// Compile error as expected
+/*
+  TEST(MSGPACK_CPP17, optional_object_vector)
+  {
+  typedef std::optional<std::vector<int> > ovi_t;
+  ovi_t val1;
+  std::vector<int> v;
+  v.push_back(1);
+  v.push_back(2);
+  v.push_back(3);
+  val1 = v;
+  msgpack::object obj(val1);
+  ovi_t  val2 = obj.as<ovi_t>();
+  EXPECT_TRUE(val1 == val2);
+  }
+*/
+
+TEST(MSGPACK_CPP17, optional_object_with_zone_nil)
+{
+    msgpack::zone z;
+    std::optional<int> val1;
+    msgpack::object obj(val1, z);
+    std::optional<int> val2 = obj.as<std::optional<int> >();
+    EXPECT_TRUE(val1 == val2);
+}
+
+TEST(MSGPACK_CPP17, optional_object_with_zone_int)
+{
+    msgpack::zone z;
+    std::optional<int> val1 = 1;
+    msgpack::object obj(val1, z);
+    std::optional<int> val2 = obj.as<std::optional<int> >();
+    EXPECT_TRUE(val1 == val2);
+}
+
+TEST(MSGPACK_CPP17, optional_object_with_zone_vector_optional)
+{
+    typedef std::vector<std::optional<int> > voi_t;
+    msgpack::zone z;
+    voi_t val1;
+    val1.resize(3);
+    val1[0] = 1;
+    val1[2] = 3;
+    msgpack::object obj(val1, z);
+    voi_t  val2 = obj.as<voi_t>();
+    EXPECT_TRUE(val1 == val2);
+}
+
+struct no_def_con {
+    no_def_con() = delete;
+    no_def_con(int i):i(i) {}
+    int i;
+    MSGPACK_DEFINE(i);
+};
+
+inline bool operator==(no_def_con const& lhs, no_def_con const& rhs) {
+    return lhs.i == rhs.i;
+}
+
+inline bool operator!=(no_def_con const& lhs, no_def_con const& rhs) {
+    return !(lhs == rhs);
+}
+
+namespace msgpack {
+MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) {
+namespace adaptor {
+
+template <>
+struct as<no_def_con> {
+    no_def_con operator()(msgpack::object const& o) const {
+        if (o.type != msgpack::type::ARRAY) throw msgpack::type_error();
+        if (o.via.array.size != 1) throw msgpack::type_error();
+        return no_def_con(o.via.array.ptr[0].as<int>());
+    }
+};
+
+} // adaptor
+} // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
+} // msgpack
+
+TEST(MSGPACK_CPP17, optional_pack_convert_no_def_con)
+{
+    std::stringstream ss;
+    std::optional<no_def_con> val1 = no_def_con(1);
+    msgpack::pack(ss, val1);
+    msgpack::object_handle oh =
+        msgpack::unpack(ss.str().data(), ss.str().size());
+    std::optional<no_def_con> val2 = oh.get().as<std::optional<no_def_con>>();
+    EXPECT_TRUE(val1 == val2);
+}
+
+TEST(MSGPACK_CPP17, string_view_pack_convert_string_view)
+{
+    std::stringstream ss;
+    std::string s = "ABC";
+    std::string_view val1(s);
+
+    msgpack::pack(ss, val1);
+
+    msgpack::object_handle oh;
+    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    std::string_view val2 = oh.get().as<std::string_view>();
+    EXPECT_TRUE(val1 == val2);
+}
+
+TEST(MSGPACK_CPP17, string_view_object_strinf_view)
+{
+    std::string s = "ABC";
+    std::string_view val1(s);
+    msgpack::object obj(val1);
+    std::string_view val2 = obj.as<std::string_view>();
+    EXPECT_TRUE(val1 == val2);
+}
+
+TEST(MSGPACK_CPP17, string_view_object_with_zone_string_view)
+{
+    msgpack::zone z;
+    std::string s = "ABC";
+    std::string_view val1(s);
+    msgpack::object obj(val1, z);
+    std::string_view val2 = obj.as<std::string_view>();
+    EXPECT_TRUE(val1 == val2);
+}
+
+#endif // !defined(MSGPACK_USE_CPP03) && __cplusplus >= 201703

test/object.cpp

@@ -181,7 +181,7 @@ TEST(object, cross_zone_copy_ext)
     msgpack::object::with_zone obj1(z1);
 
     obj1.type = msgpack::type::EXT;
-    char* ptr = static_cast<char*>(obj1.zone.allocate_align(2));
+    char* ptr = static_cast<char*>(obj1.zone.allocate_align(2, MSGPACK_ZONE_ALIGNOF(char)));
     ptr[0] = 1;
     ptr[1] = 2;
     obj1.via.ext.ptr = ptr;
@@ -204,7 +204,7 @@ TEST(object, cross_zone_copy_construct_ext)
     msgpack::object::with_zone obj1(z1);
 
     obj1.type = msgpack::type::EXT;
-    char* ptr = static_cast<char*>(obj1.zone.allocate_align(2));
+    char* ptr = static_cast<char*>(obj1.zone.allocate_align(2, MSGPACK_ZONE_ALIGNOF(char)));
     ptr[0] = 1;
     ptr[1] = 2;
     obj1.via.ext.ptr = ptr;

test/object_with_zone.cpp

@@ -751,14 +751,14 @@ TEST(object_with_zone, user_defined_non_virtual)
 
     msgpack::zone z;
     msgpack::object obj(b, z);
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
     bottom br = obj.as<bottom>();
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 #pragma GCC diagnostic pop
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
     EXPECT_EQ(b.b, br.b);
     EXPECT_EQ(b.m1, br.m1);
     EXPECT_EQ(b.m2, br.m2);
@@ -796,14 +796,14 @@ TEST(object_with_zone, user_defined_virtual)
 
     msgpack::zone z;
     msgpack::object obj(b, z);
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
     v_bottom br = obj.as<v_bottom>();
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 #pragma GCC diagnostic pop
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
     EXPECT_EQ(b.b, br.b);
     EXPECT_EQ(b.m1, br.m1);
     EXPECT_EQ(b.m2, br.m2);

test/user_class.cpp

@@ -148,11 +148,11 @@ public:
 
     void msgpack_unpack(msgpack::object o)
     {
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
-        msgpack::type::tuple<bool, msgpack::object> tuple;
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
+        msgpack::type::tuple<bool, msgpack::object> tuple(false, msgpack::object());
         o.convert(tuple);
 
         is_double = tuple.get<0>();
@@ -160,18 +160,18 @@ public:
             tuple.get<1>().convert(value.f);
         else
             tuple.get<1>().convert(value.i);
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 #pragma GCC diagnostic pop
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
     }
 };
 
 TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
 {
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
     {
         // double
         TestUnionMemberClass val1(1.0);
@@ -195,9 +195,9 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
         EXPECT_EQ(val1.value.i, 1);
         EXPECT_EQ(val1.value.i, val2.value.i);
     }
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 #pragma GCC diagnostic pop
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 }
 
 // inheritance
@@ -396,14 +396,14 @@ TEST(MSGPACK_INHERIT, define_map_non_virtual)
     msgpack::pack(sbuf, b);
     msgpack::object_handle oh =
         msgpack::unpack(sbuf.data(), sbuf.size());
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
     dm_bottom br = oh.get().as<dm_bottom>();
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
 #pragma GCC diagnostic pop
-#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
     EXPECT_EQ(b.b, br.b);
     EXPECT_EQ(b.m1, br.m1);
     EXPECT_EQ(b.m2, br.m2);