Merge pull request #823 from redboltz/update_to_3.2.1

Updated the version to 3.2.1.

.travis.yml

@@ -232,6 +232,25 @@ matrix:
             - clang-5.0
       script:
         - CMAKE_CXX_COMPILER="${CXX}" CMAKE_C_COMPILER="${CC}" CMAKE_LIBRARY_PATH="${BASE}" GTEST_ROOT="${BASE}/gtest" BOOST_ROOT="${BASE}/boost" CTEST_OUTPUT_ON_FAILURE=1 MSGPACK_SAN="${SAN}" ci/build_regression.sh
+    - os: linux
+      compiler: gcc
+      env: ACTION="ci/build_cmake_embedded.sh"     ARCH="64"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-multilib
+            - gcc-multilib
+            - gcc-7-multilib
+            - g++-7-multilib
+            - lib32stdc++6-6-dbg
+            - lib32gcc1
+            - libc6-i386
+            - lib32z1-dev
+            - zlib1g-dev
+            - bzip2
+            - libc6-dbg
 
 
 script:

CHANGELOG.md

@@ -1,3 +1,29 @@
+# 2019-12-10 version 3.2.1
+  * Fix snprintf return value checking (#821)
+  * Remove some warnings (#819)
+  * Fix fbuffer result checking (#812)
+  * Fix temporary object handling (#807)
+  * Improve cmake support (#804)
+  * Fix invalid `int main` parameter (#800)
+  * Improve supporting platform (#797, #817)
+  * Fix ZLIB error handling (#795)
+  * Remove unused variable (#793)
+  * Improve integer overflow checking (#792)
+
+# 2019-05-27 version 3.2.0
+
+  * Fix invalid include (#783)
+  * Add timespec support (#781)
+  * Fix unchecked fnprintf on C (#780)
+  * Improve integer overflow checking on C (#776)
+  * Fix warnings on `-Wconversion` (#770, #777, #784)
+  * Fix invalid passed by value on aligned_zone_size_visitor (#764)
+  * Improve windows support (#757, #779)
+  * Fix msgpack::object size caluclation error (#754)
+  * Fix memory error on example code (#753)
+  * Fix redundant memory allocation on C (#747)
+  * Fix msgpack::type::tuple base class conversion (#743)
+
 # 2018-09-09 version 3.1.1
 
   * Add force endian set functionality (#736)

CMakeLists.txt

@@ -181,6 +181,7 @@ ELSE ()
     IF (NOT DEFINED MSGPACK_ENABLE_STATIC)
         SET (MSGPACK_ENABLE_STATIC ON)
     ENDIF ()
+    SET (BUILD_SHARED_LIBS ${MSGPACK_ENABLE_SHARED})
 ENDIF ()
 
 OPTION (MSGPACK_ENABLE_CXX "Enable C++ interface." ON)
@@ -209,8 +210,9 @@ CONFIGURE_FILE (
     @ONLY
 )
 
-IF (MSGPACK_ENABLE_SHARED)
-    ADD_LIBRARY (msgpackc SHARED
+
+IF (MSGPACK_ENABLE_SHARED OR MSGPACK_ENABLE_STATIC)
+    ADD_LIBRARY (msgpackc
         ${msgpackc_SOURCES}
         ${msgpackc_HEADERS}
     )
@@ -238,7 +240,7 @@ IF (MSGPACK_ENABLE_CXX AND ((CMAKE_VERSION VERSION_GREATER 3.0) OR (CMAKE_VERSIO
     )
 ENDIF ()
 
-IF (MSGPACK_ENABLE_STATIC)
+IF (MSGPACK_ENABLE_SHARED AND MSGPACK_ENABLE_STATIC)
     ADD_LIBRARY (msgpackc-static STATIC
         ${msgpackc_SOURCES}
         ${msgpackc_HEADERS}
@@ -253,11 +255,6 @@ IF (MSGPACK_ENABLE_STATIC)
             ${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)
@@ -291,19 +288,19 @@ IF (MSGPACK_BUILD_TESTS)
 ENDIF ()
 
 IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-    IF (MSGPACK_ENABLE_SHARED)
+    IF (MSGPACK_ENABLE_SHARED OR MSGPACK_ENABLE_STATIC)
         SET_PROPERTY (TARGET msgpackc APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra -DPIC")
     ENDIF ()
-    IF (MSGPACK_ENABLE_STATIC)
+    IF (MSGPACK_ENABLE_SHARED AND MSGPACK_ENABLE_STATIC)
        SET_PROPERTY (TARGET msgpackc-static APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra" )
     ENDIF ()
 ENDIF ()
 
 IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-    IF (MSGPACK_ENABLE_SHARED)
+    IF (MSGPACK_ENABLE_SHARED OR MSGPACK_ENABLE_STATIC)
         SET_PROPERTY (TARGET msgpackc APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
     ENDIF ()
-    IF (MSGPACK_ENABLE_STATIC)
+    IF (MSGPACK_ENABLE_SHARED AND MSGPACK_ENABLE_STATIC)
         SET_PROPERTY (TARGET msgpackc-static APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
     ENDIF ()
 ENDIF ()
@@ -337,7 +334,7 @@ IF (MSGPACK_BUILD_EXAMPLES)
     ADD_SUBDIRECTORY (example)
 ENDIF ()
 
-IF (MSGPACK_ENABLE_SHARED)
+IF (MSGPACK_ENABLE_SHARED OR MSGPACK_ENABLE_STATIC)
     SET (MSGPACK_INSTALLTARGETS msgpackc)
 ENDIF ()
 
@@ -345,7 +342,7 @@ IF (MSGPACK_ENABLE_CXX AND ((CMAKE_VERSION VERSION_GREATER 3.0) OR (CMAKE_VERSIO
     LIST (APPEND MSGPACK_INSTALLTARGETS msgpackc-cxx)
 ENDIF ()
 
-IF (MSGPACK_ENABLE_STATIC)
+IF (MSGPACK_ENABLE_SHARED AND MSGPACK_ENABLE_STATIC)
     LIST (APPEND MSGPACK_INSTALLTARGETS msgpackc-static)
 ENDIF ()
 

Files.cmake

@@ -190,6 +190,7 @@ IF (MSGPACK_ENABLE_CXX)
         include/msgpack/adaptor/cpp11/forward_list.hpp
         include/msgpack/adaptor/cpp11/reference_wrapper.hpp
         include/msgpack/adaptor/cpp11/shared_ptr.hpp
+        include/msgpack/adaptor/cpp11/timespec.hpp
         include/msgpack/adaptor/cpp11/tuple.hpp
         include/msgpack/adaptor/cpp11/unique_ptr.hpp
         include/msgpack/adaptor/cpp11/unordered_map.hpp
@@ -231,6 +232,7 @@ IF (MSGPACK_ENABLE_CXX)
         include/msgpack/adaptor/vector_bool.hpp
         include/msgpack/adaptor/vector_char.hpp
         include/msgpack/adaptor/vector_unsigned_char.hpp
+        include/msgpack/adaptor/wstring.hpp
         include/msgpack/cpp_config.hpp
         include/msgpack/cpp_config_decl.hpp
         include/msgpack/create_object_visitor.hpp
@@ -551,6 +553,7 @@ IF (MSGPACK_ENABLE_CXX)
         include/msgpack/v1/adaptor/cpp11/forward_list.hpp
         include/msgpack/v1/adaptor/cpp11/reference_wrapper.hpp
         include/msgpack/v1/adaptor/cpp11/shared_ptr.hpp
+        include/msgpack/v1/adaptor/cpp11/timespec.hpp
         include/msgpack/v1/adaptor/cpp11/tuple.hpp
         include/msgpack/v1/adaptor/cpp11/unique_ptr.hpp
         include/msgpack/v1/adaptor/cpp11/unordered_map.hpp
@@ -605,6 +608,7 @@ IF (MSGPACK_ENABLE_CXX)
         include/msgpack/v1/adaptor/vector_bool.hpp
         include/msgpack/v1/adaptor/vector_char.hpp
         include/msgpack/v1/adaptor/vector_unsigned_char.hpp
+        include/msgpack/v1/adaptor/wstring.hpp
         include/msgpack/v1/cpp_config.hpp
         include/msgpack/v1/cpp_config_decl.hpp
         include/msgpack/v1/detail/cpp03_zone.hpp

QUICKSTART-CPP.md

@@ -59,7 +59,7 @@ $ ./hello
 #include <iostream>
 #include <string>
 
-int main(void) {
+int main() {
         // serializes multiple objects using msgpack::packer.
         msgpack::sbuffer buffer;
 
@@ -98,7 +98,7 @@ int main(void) {
 #include <iostream>
 #include <string>
 
-int main(void) {
+int main() {
         // serializes multiple objects into one message containing an array using msgpack::packer.
         msgpack::sbuffer buffer;
 
@@ -139,7 +139,7 @@ public:
     MSGPACK_DEFINE(m_str, m_vec);
 };
 
-int main(void) {
+int main() {
         std::vector<myclass> vec;
         // add some elements into vec...
 

README.md

@@ -1,7 +1,7 @@
 `msgpack` for C/C++
 ===================
 
-Version 3.1.1 [![Build Status](https://travis-ci.org/msgpack/msgpack-c.svg?branch=master)](https://travis-ci.org/msgpack/msgpack-c) [![Build status](https://ci.appveyor.com/api/projects/status/8kstcgt79qj123mw/branch/master?svg=true)](https://ci.appveyor.com/project/redboltz/msgpack-c/branch/master)
+Version 3.2.1 [![Build Status](https://travis-ci.org/msgpack/msgpack-c.svg?branch=master)](https://travis-ci.org/msgpack/msgpack-c) [![Build status](https://ci.appveyor.com/api/projects/status/8kstcgt79qj123mw/branch/master?svg=true)](https://ci.appveyor.com/project/redboltz/msgpack-c/branch/master)
 
 It's like JSON but smaller and faster.
 
@@ -68,7 +68,7 @@ In C++:
 #include <iostream>
 #include <sstream>
 
-int main(void)
+int main()
 {
     msgpack::type::tuple<int, bool, std::string> src(1, true, "example");
 

appveyor.yml

@@ -1,4 +1,4 @@
-version: 3.1.1.{build}
+version: 3.2.1.{build}
 
 image:
 - Visual Studio 2015

ci/build_cmake.sh

@@ -72,4 +72,39 @@ then
     fi
 fi
 
+if [ "${ARCH}" != "32" ]
+then
+    mkdir install-test
+
+    ret=$?
+    if [ $ret -ne 0 ]
+    then
+        exit $ret
+    fi
+
+    cd install-test
+
+    ret=$?
+    if [ $ret -ne 0 ]
+    then
+        exit $ret
+    fi
+
+    cmake -DCMAKE_PREFIX_PATH=`pwd`/../install/usr/local/lib/cmake ../../example/cmake
+
+    ret=$?
+    if [ $ret -ne 0 ]
+    then
+        exit $ret
+    fi
+
+    make
+
+    ret=$?
+    if [ $ret -ne 0 ]
+    then
+        exit $ret
+    fi
+fi
+
 exit 0

ci/build_cmake_embedded.sh

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

erb/v1/cpp03_msgpack_tuple.hpp.erb

@@ -121,7 +121,7 @@ inline tuple<> make_tuple()
 /// @cond
 <%0.upto(GENERATION_LIMIT) {|i|%>
 template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-inline tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_tuple(typename tuple_type<A0>::transparent_reference a0<%1.upto(i) {|j|%>, typename tuple_type<A<%=j%>>::transparent_reference a<%=j%><%}%>)
+tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_tuple(A0 const& a0<%1.upto(i) {|j|%>, A<%=j%> const& a<%=j%><%}%>)
 {
     return tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>);
 }

erb/v1/cpp03_msgpack_tuple_decl.hpp.erb

@@ -54,7 +54,7 @@ tuple<> make_tuple();
 /// @cond
 <%0.upto(GENERATION_LIMIT) {|i|%>
 template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_tuple(typename tuple_type<A0>::transparent_reference a0<%1.upto(i) {|j|%>, typename tuple_type<A<%=j%>>::transparent_reference a<%=j%><%}%>);
+tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_tuple(A0 const& a0<%1.upto(i) {|j|%>, A<%=j%> const& a<%=j%><%}%>);
 <%}%>
 /// @endcond
 

erb/v1/cpp03_zone.hpp.erb

@@ -55,7 +55,7 @@ class zone {
             ++m_tail;
         }
         void push_expand(void (*func)(void*), void* data) {
-            const size_t nused = m_end - m_array;
+            const size_t nused = static_cast<size_t>(m_end - m_array);
             size_t nnext;
             if(nused == 0) {
                 nnext = (sizeof(finalizer) < 72/2) ?
@@ -201,12 +201,12 @@ inline char* zone::get_aligned(char* ptr, size_t 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);
+    size_t adjusted_size = size + static_cast<size_t>(aligned - m_chunk_list.m_ptr);
     if (m_chunk_list.m_free < adjusted_size) {
         size_t enough_size = size + align - 1;
         char* ptr = allocate_expand(enough_size);
         aligned = get_aligned(ptr, align);
-        adjusted_size = size + (aligned - m_chunk_list.m_ptr);
+        adjusted_size = size + static_cast<size_t>(aligned - m_chunk_list.m_ptr);
     }
     m_chunk_list.m_free -= adjusted_size;
     m_chunk_list.m_ptr  += adjusted_size;

example/boost/asio_send_recv.cpp

@@ -38,8 +38,8 @@ int main() {
                     std::cout << __LINE__ << ":" << e.message() << std::endl;
                     return;
                 }
-                unp.reserve_buffer(window_size);
                 do_async_read_some = [&] {
+                    unp.reserve_buffer(window_size);
                     ss.async_read_some(
                         boost::asio::buffer(unp.buffer(), window_size),
                         [&](boost::system::error_code const& e, std::size_t bytes_transferred) {

example/boost/msgpack_variant_mapbased.cpp

@@ -83,7 +83,8 @@ int main() {
     u.address = "Tokyo";
     msgpack::pack(ss, u);
 
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     msgpack::object const& obj = oh.get();
     std::cout << "Unpacked msgpack object." << std::endl;
     std::cout << obj << std::endl;

example/c/CMakeLists.txt

@@ -1,12 +1,3 @@
-IF (MSGPACK_ENABLE_SHARED)
-    SET (MSGPACK_LIB msgpackc)
-ENDIF ()
-
-IF (MSGPACK_ENABLE_STATIC)
-    SET (MSGPACK_LIB msgpackc-static)
-ENDIF ()
-
-
 LIST (APPEND exec_PROGRAMS
     lib_buffer_unpack.c
     simple_c.c
@@ -22,7 +13,7 @@ FOREACH (source_file ${exec_PROGRAMS})
         ${source_file}
     )
     TARGET_LINK_LIBRARIES (${source_file_we}
-        ${MSGPACK_LIB}
+        msgpackc
     )
     IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
         SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra")

example/cmake/CMakeLists.txt

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

example/cpp03/class_intrusive.cpp

@@ -82,10 +82,11 @@ int main() {
         std::stringstream ss;
         msgpack::pack(ss, my);
 
-        print(ss.str());
+        std::string const& str = ss.str();
+        print(str);
 
         msgpack::object_handle oh =
-            msgpack::unpack(ss.str().data(), ss.str().size());
+            msgpack::unpack(str.data(), str.size());
         msgpack::object obj = oh.get();
         std::cout << obj << std::endl;
         assert(obj.as<my_class>() == my);

example/cpp03/class_intrusive_map.cpp

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

example/cpp03/class_non_intrusive.cpp

@@ -100,10 +100,11 @@ int main() {
         std::stringstream ss;
         msgpack::pack(ss, my);
 
-        print(ss.str());
+        std::string const& str = ss.str();
+        print(str);
 
         msgpack::object_handle oh =
-            msgpack::unpack(ss.str().data(), ss.str().size());
+            msgpack::unpack(str.data(), str.size());
         msgpack::object obj = oh.get();
         std::cout << obj << std::endl;
         assert(obj.as<my_class>() == my);

example/cpp03/map_based_versionup.cpp

@@ -71,7 +71,8 @@ int main() {
 
         print(ss.str());
 
-        msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+        std::string const& str = ss.str();
+        msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
 
         msgpack::object obj = oh.get();
         std::cout << obj << std::endl;

example/cpp03/reuse_zone.cpp

@@ -31,12 +31,13 @@ int main() {
     std::size_t offset = 0;
 
     // msgpack array is constructed on z.
-    msgpack::object obj = msgpack::unpack(z, ss.str().data(), ss.str().size(), offset);
+    std::string const& ps = ss.str();
+    msgpack::object obj = msgpack::unpack(z, ps.data(), ps.size(), offset);
     std::cout << obj << std::endl;
     assert(obj.as<std::vector<int> >() == v);
 
     // msgpack str is constructed on z.
-    std::string const& str = msgpack::unpack(z, ss.str().data(), ss.str().size(), offset).as<std::string>();
+    std::string const& str = msgpack::unpack(z, ps.data(), ps.size(), offset).as<std::string>();
     std::cout << str << std::endl;
     assert(str == s);
 }

example/cpp11/container.cpp

@@ -37,7 +37,8 @@ void tuple() {
     std::stringstream ss;
     msgpack::pack(ss, t);
 
-    auto oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    auto const& str = ss.str();
+    auto oh = msgpack::unpack(str.data(), str.size());
     auto obj = oh.get();
 
     std::cout << obj << std::endl;
@@ -49,7 +50,8 @@ void unordered_map() {
     std::stringstream ss;
     msgpack::pack(ss, m);
 
-    auto oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    auto const& str = ss.str();
+    auto oh = msgpack::unpack(str.data(), str.size());
     msgpack::object obj = oh.get();
 
     std::cout << obj << std::endl;
@@ -61,7 +63,8 @@ void unordered_set() {
     std::stringstream ss;
     msgpack::pack(ss, s);
 
-    auto oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    auto const& str = ss.str();
+    auto oh = msgpack::unpack(str.data(), str.size());
     auto obj = oh.get();
 
     std::cout << obj << std::endl;
@@ -74,7 +77,8 @@ void forward_list() {
     std::stringstream ss;
     msgpack::pack(ss, f);
 
-    auto oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    auto const& str = ss.str();
+    auto oh = msgpack::unpack(str.data(), str.size());
     auto obj = oh.get();
 
     std::cout << obj << std::endl;
@@ -98,7 +102,8 @@ void combi() {
     std::size_t offset = 0;
     std::cout << "offset: " << offset << std::endl;
     {
-        auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
+        auto const& str = ss.str();
+        auto oh = msgpack::unpack(str.data(), str.size(), offset);
         auto obj = oh.get();
 
         std::cout << obj << std::endl;
@@ -106,7 +111,8 @@ void combi() {
     }
     std::cout << "offset: " << offset << std::endl;
     {
-        auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
+        auto const& str = ss.str();
+        auto oh = msgpack::unpack(str.data(), str.size(), offset);
         auto obj = oh.get();
 
         std::cout << obj << std::endl;
@@ -114,7 +120,8 @@ void combi() {
     }
     std::cout << "offset: " << offset << std::endl;
     {
-        auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
+        auto const& str = ss.str();
+        auto oh = msgpack::unpack(str.data(), str.size(), offset);
         auto obj = oh.get();
 
         std::cout << obj << std::endl;
@@ -122,7 +129,8 @@ void combi() {
     }
     std::cout << "offset: " << offset << std::endl;
     {
-        auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
+        auto const& str = ss.str();
+        auto oh = msgpack::unpack(str.data(), str.size(), offset);
         auto obj = oh.get();
 
         std::cout << obj << std::endl;
@@ -130,7 +138,8 @@ void combi() {
     }
     std::cout << "offset: " << offset << std::endl;
     {
-        auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
+        auto const& str = ss.str();
+        auto oh = msgpack::unpack(str.data(), str.size(), offset);
         auto obj = oh.get();
 
         std::cout << obj << std::endl;

include/msgpack/adaptor/cpp11/timespec.hpp

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

include/msgpack/adaptor/wstring.hpp

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

include/msgpack/fbuffer.h

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

include/msgpack/object.h

@@ -97,8 +97,10 @@ typedef struct msgpack_object_kv {
     msgpack_object val;
 } msgpack_object_kv;
 
+#if !defined(_KERNEL_MODE)
 MSGPACK_DLLEXPORT
 void msgpack_object_print(FILE* out, msgpack_object o);
+#endif
 
 MSGPACK_DLLEXPORT
 int msgpack_object_print_buffer(char *buffer, size_t buffer_size, msgpack_object o);

include/msgpack/pack_template.h

@@ -34,6 +34,10 @@
 #error msgpack_pack_append_buffer callback is not defined
 #endif
 
+#if defined(_MSC_VER)
+#   pragma warning(push)
+#   pragma warning(disable : 4204)   /* nonstandard extension used: non-constant aggregate initializer */
+#endif
 
 /*
  * Integer
@@ -834,31 +838,31 @@ msgpack_pack_inline_func(_ext)(msgpack_pack_user x, size_t l, int8_t type)
     case 1: {
         unsigned char buf[2];
         buf[0] = 0xd4;
-        buf[1] = type;
+        buf[1] = (unsigned char)type;
         msgpack_pack_append_buffer(x, buf, 2);
     } break;
     case 2: {
         unsigned char buf[2];
         buf[0] = 0xd5;
-        buf[1] = type;
+        buf[1] = (unsigned char)type;
         msgpack_pack_append_buffer(x, buf, 2);
     } break;
     case 4: {
         unsigned char buf[2];
         buf[0] = 0xd6;
-        buf[1] = type;
+        buf[1] = (unsigned char)type;
         msgpack_pack_append_buffer(x, buf, 2);
     } break;
     case 8: {
         unsigned char buf[2];
         buf[0] = 0xd7;
-        buf[1] = type;
+        buf[1] = (unsigned char)type;
         msgpack_pack_append_buffer(x, buf, 2);
     } break;
     case 16: {
         unsigned char buf[2];
         buf[0] = 0xd8;
-        buf[1] = type;
+        buf[1] = (unsigned char)type;
         msgpack_pack_append_buffer(x, buf, 2);
     } break;
     default:
@@ -866,19 +870,19 @@ msgpack_pack_inline_func(_ext)(msgpack_pack_user x, size_t l, int8_t type)
             unsigned char buf[3];
             buf[0] = 0xc7;
             buf[1] = (unsigned char)l;
-            buf[2] = type;
+            buf[2] = (unsigned char)type;
             msgpack_pack_append_buffer(x, buf, 3);
         } else if(l < 65536) {
             unsigned char buf[4];
             buf[0] = 0xc8;
             _msgpack_store16(&buf[1], l);
-            buf[3] = type;
+            buf[3] = (unsigned char)type;
             msgpack_pack_append_buffer(x, buf, 4);
         } else {
             unsigned char buf[6];
             buf[0] = 0xc9;
             _msgpack_store32(&buf[1], l);
-            buf[5] = type;
+            buf[5] = (unsigned char)type;
             msgpack_pack_append_buffer(x, buf, 6);
         }
         break;
@@ -893,7 +897,7 @@ msgpack_pack_inline_func(_ext_body)(msgpack_pack_user x, const void* b, size_t l
 msgpack_pack_inline_func(_timestamp)(msgpack_pack_user x, const msgpack_timestamp* d)
 {
     if ((((int64_t)d->tv_sec) >> 34) == 0) {
-        uint64_t data64 = ((uint64_t) d->tv_nsec << 34) | d->tv_sec;
+        uint64_t data64 = ((uint64_t) d->tv_nsec << 34) | (uint64_t)d->tv_sec;
         if ((data64 & 0xffffffff00000000L) == 0)   {
             // timestamp 32
             char buf[4];
@@ -935,3 +939,7 @@ msgpack_pack_inline_func(_timestamp)(msgpack_pack_user x, const msgpack_timestam
 #undef msgpack_pack_real_int16
 #undef msgpack_pack_real_int32
 #undef msgpack_pack_real_int64
+
+#if defined(_MSC_VER)
+#   pragma warning(pop)
+#endif

include/msgpack/sysdep.h

@@ -14,7 +14,7 @@
 #include <stddef.h>
 
 #if defined(_MSC_VER) && _MSC_VER <= 1800
-#   define snprintf(buf, len, format,...) _snprintf_s(buf, len, len, format, __VA_ARGS__)
+#   define snprintf(buf, len, format,...) _snprintf_s(buf, len, _TRUNCATE, format, __VA_ARGS__)
 #endif
 
 #if defined(_MSC_VER) && _MSC_VER < 1600
@@ -42,13 +42,22 @@
 #endif
 
 #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 */
+#   if defined(_KERNEL_MODE)
+#       define _msgpack_atomic_counter_header <ntddk.h>
+#   else
+#       define _msgpack_atomic_counter_header <windows.h>
+#       if !defined(WIN32_LEAN_AND_MEAN)
+#           define WIN32_LEAN_AND_MEAN
+#       endif /* WIN32_LEAN_AND_MEAN */
+#   endif
     typedef long _msgpack_atomic_counter_t;
-#   define _msgpack_sync_decr_and_fetch(ptr) InterlockedDecrement(ptr)
-#   define _msgpack_sync_incr_and_fetch(ptr) InterlockedIncrement(ptr)
+#if defined(_AMD64_) || defined(_M_X64) || defined(_M_ARM64)
+#    define _msgpack_sync_decr_and_fetch(ptr) _InterlockedDecrement(ptr)
+#    define _msgpack_sync_incr_and_fetch(ptr) _InterlockedIncrement(ptr)
+#else
+#    define _msgpack_sync_decr_and_fetch(ptr) InterlockedDecrement(ptr)
+#    define _msgpack_sync_incr_and_fetch(ptr) InterlockedIncrement(ptr)
+#endif
 #elif defined(__GNUC__) && ((__GNUC__*10 + __GNUC_MINOR__) < 41)
 
 #   if defined(__cplusplus)
@@ -91,7 +100,7 @@
 #if MSGPACK_ENDIAN_LITTLE_BYTE
 
 #   if defined(unix) || defined(__unix) || defined(__APPLE__) || defined(__OpenBSD__)
-#       define _msgpack_be16(x) ntohs(x)
+#       define _msgpack_be16(x) ntohs((uint16_t)x)
 #   else
 #       if defined(ntohs)
 #           define _msgpack_be16(x) ntohs(x)
@@ -105,7 +114,7 @@
 #   endif
 
 #   if defined(unix) || defined(__unix) || defined(__APPLE__) || defined(__OpenBSD__)
-#       define _msgpack_be32(x) ntohl(x)
+#       define _msgpack_be32(x) ntohl((uint32_t)x)
 #   else
 #       if defined(ntohl)
 #           define _msgpack_be32(x) ntohl(x)
@@ -150,16 +159,16 @@
 
 #define _msgpack_load16(cast, from, to) do {       \
         memcpy((cast*)(to), (from), sizeof(cast)); \
-        *(to) = _msgpack_be16(*(to));              \
+        *(to) = (cast)_msgpack_be16(*(to));      \
     } while (0);
 
 #define _msgpack_load32(cast, from, to) do {       \
         memcpy((cast*)(to), (from), sizeof(cast)); \
-        *(to) = _msgpack_be32(*(to));              \
+        *(to) = (cast)_msgpack_be32(*(to));        \
     } while (0);
 #define _msgpack_load64(cast, from, to) do {       \
         memcpy((cast*)(to), (from), sizeof(cast)); \
-        *(to) = _msgpack_be64(*(to));              \
+        *(to) = (cast)_msgpack_be64(*(to));        \
     } while (0);
 
 #define _msgpack_store16(to, num) \
@@ -180,11 +189,13 @@
 
 
 #if !defined(__cplusplus) && defined(_MSC_VER)
-#  if !defined(FALSE)
-#    define FALSE (0)
-#  endif
-#  if !defined(TRUE)
-#    define TRUE (!FALSE)
+#  if !defined(_KERNEL_MODE)
+#    if !defined(FALSE)
+#      define FALSE (0)
+#    endif
+#    if !defined(TRUE)
+#      define TRUE (!FALSE)
+#    endif
 #  endif
 #  if _MSC_VER >= 1800
 #    include <stdbool.h>

include/msgpack/type.hpp

@@ -21,6 +21,7 @@
 #include "adaptor/vector_bool.hpp"
 #include "adaptor/vector_char.hpp"
 #include "adaptor/vector_unsigned_char.hpp"
+#include "adaptor/wstring.hpp"
 #include "adaptor/msgpack_tuple.hpp"
 #include "adaptor/define.hpp"
 
@@ -38,6 +39,7 @@
 #include "adaptor/cpp11/forward_list.hpp"
 #include "adaptor/cpp11/reference_wrapper.hpp"
 #include "adaptor/cpp11/shared_ptr.hpp"
+#include "adaptor/cpp11/timespec.hpp"
 #include "adaptor/cpp11/tuple.hpp"
 #include "adaptor/cpp11/unique_ptr.hpp"
 #include "adaptor/cpp11/unordered_map.hpp"

include/msgpack/unpack_template.h

@@ -38,6 +38,11 @@
 #endif
 #endif
 
+#if defined(_KERNEL_MODE)
+#undef  assert
+#define assert NT_ASSERT
+#endif
+
 msgpack_unpack_struct_decl(_stack) {
     msgpack_unpack_object obj;
     size_t count;

include/msgpack/v1/adaptor/array_ref.hpp

@@ -10,7 +10,6 @@
 #ifndef MSGPACK_V1_TYPE_ARRAY_REF_HPP
 #define MSGPACK_V1_TYPE_ARRAY_REF_HPP
 
-#include "msgpack/v1/adaptor/array_ref.hpp"
 #include "msgpack/adaptor/check_container_size.hpp"
 #include "msgpack/cpp_config.hpp"
 #include <cstring>

include/msgpack/v1/adaptor/check_container_size.hpp

@@ -53,7 +53,7 @@ inline void check_container_size_for_ext<4>(std::size_t size) {
 
 template <typename T>
 inline uint32_t checked_get_container_size(T size) {
-    detail::check_container_size<sizeof(T)>(size);
+    detail::check_container_size<sizeof(T)>(static_cast<std::size_t>(size));
     return static_cast<uint32_t>(size);
 }
 

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

@@ -122,7 +122,7 @@ struct pack<std::chrono::system_clock::time_point> {
             * std::chrono::system_clock::duration::period::ratio::num
             / std::chrono::system_clock::duration::period::ratio::den;
         if ((sec >> 34) == 0) {
-            uint64_t data64 = (nanosec << 34) | sec;
+            uint64_t data64 = (static_cast<uint64_t>(nanosec) << 34) | static_cast<uint64_t>(sec);
             if ((data64 & 0xffffffff00000000L) == 0) {
                 // timestamp 32
                 o.pack_ext(4, -1);
@@ -170,13 +170,13 @@ struct object_with_zone<std::chrono::system_clock::time_point> {
             * std::chrono::system_clock::duration::period::ratio::num
             / std::chrono::system_clock::duration::period::ratio::den;
         if ((sec >> 34) == 0) {
-            uint64_t data64 = (nanosec << 34) | sec;
+            uint64_t data64 = (static_cast<uint64_t>(nanosec) << 34) | static_cast<uint64_t>(sec);
             if ((data64 & 0xffffffff00000000L) == 0) {
                 // timestamp 32
                 o.type = msgpack::type::EXT;
                 o.via.ext.size = 4;
                 char* p = static_cast<char*>(o.zone.allocate_no_align(o.via.ext.size + 1));
-                p[0] = -1;
+                p[0] = static_cast<char>(-1);
                 uint32_t data32 = static_cast<uint32_t>(data64);
                 _msgpack_store32(&p[1], data32);
                 o.via.ext.ptr = p;
@@ -186,7 +186,7 @@ struct object_with_zone<std::chrono::system_clock::time_point> {
                 o.type = msgpack::type::EXT;
                 o.via.ext.size = 8;
                 char* p = static_cast<char*>(o.zone.allocate_no_align(o.via.ext.size + 1));
-                p[0] = -1;
+                p[0] = static_cast<char>(-1);
                 _msgpack_store64(&p[1], data64);
                 o.via.ext.ptr = p;
             }
@@ -196,7 +196,7 @@ struct object_with_zone<std::chrono::system_clock::time_point> {
             o.type = msgpack::type::EXT;
             o.via.ext.size = 12;
             char* p = static_cast<char*>(o.zone.allocate_no_align(o.via.ext.size + 1));
-            p[0] = -1;
+            p[0] = static_cast<char>(-1);
             _msgpack_store32(&p[1], static_cast<uint32_t>(nanosec));
             _msgpack_store64(&p[1 + 4], sec);
             o.via.ext.ptr = p;

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

@@ -0,0 +1,140 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2018 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_V1_TYPE_CPP11_TIMESPEC_HPP
+#define MSGPACK_V1_TYPE_CPP11_TIMESPEC_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/object.hpp"
+
+#include <ctime>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace adaptor {
+
+template <>
+struct convert<timespec> {
+    msgpack::object const& operator()(msgpack::object const& o, timespec& v) const {
+        if(o.type != msgpack::type::EXT) { throw msgpack::type_error(); }
+        if(o.via.ext.type() != -1) { throw msgpack::type_error(); }
+        switch(o.via.ext.size) {
+        case 4: {
+            uint32_t sec;
+            _msgpack_load32(uint32_t, o.via.ext.data(), &sec);
+            v.tv_sec = static_cast<decltype(v.tv_sec)>(sec);
+            v.tv_nsec = 0;
+        } break;
+        case 8: {
+            uint64_t value;
+            _msgpack_load64(uint64_t, o.via.ext.data(), &value);
+            v.tv_sec = static_cast<decltype(v.tv_sec)>(value & 0x00000003ffffffffLL);
+            v.tv_nsec= static_cast<decltype(v.tv_nsec)>(value >> 34);
+        } break;
+        case 12: {
+            uint32_t nanosec;
+            _msgpack_load32(uint32_t, o.via.ext.data(), &nanosec);
+            int64_t sec;
+            _msgpack_load64(int64_t, o.via.ext.data() + 4, &sec);
+            v.tv_sec = static_cast<decltype(v.tv_sec)>(sec);
+            v.tv_nsec = static_cast<decltype(v.tv_nsec)>(nanosec);
+        } break;
+        default:
+            throw msgpack::type_error();
+        }
+        return o;
+    }
+};
+
+template <>
+struct pack<timespec> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const timespec& v) const {
+        if ((static_cast<uint64_t>(v.tv_sec) >> 34) == 0) {
+            uint64_t data64 = (static_cast<uint64_t>(v.tv_nsec) << 34) | static_cast<uint64_t>(v.tv_sec);
+            if ((data64 & 0xffffffff00000000L) == 0) {
+                // timestamp 32
+                o.pack_ext(4, -1);
+                uint32_t data32 = static_cast<uint32_t>(data64);
+                char buf[4];
+                _msgpack_store32(buf, data32);
+                o.pack_ext_body(buf, 4);
+            }
+            else {
+                // timestamp 64
+                o.pack_ext(8, -1);
+                char buf[8];
+                _msgpack_store64(buf, data64);
+                o.pack_ext_body(buf, 8);
+            }
+        }
+        else {
+            // timestamp 96
+            o.pack_ext(12, -1);
+            char buf[12];
+            _msgpack_store32(&buf[0], static_cast<uint32_t>(v.tv_nsec));
+            _msgpack_store64(&buf[4], v.tv_sec);
+            o.pack_ext_body(buf, 12);
+        }
+        return o;
+    }
+};
+
+template <>
+struct object_with_zone<timespec> {
+    void operator()(msgpack::object::with_zone& o, const timespec& v) const {
+        if ((static_cast<uint64_t>(v.tv_sec) >> 34) == 0) {
+            uint64_t data64 = (static_cast<uint64_t>(v.tv_nsec) << 34) | static_cast<uint64_t>(v.tv_sec);
+            if ((data64 & 0xffffffff00000000L) == 0) {
+                // timestamp 32
+                o.type = msgpack::type::EXT;
+                o.via.ext.size = 4;
+                char* p = static_cast<char*>(o.zone.allocate_no_align(o.via.ext.size + 1));
+                p[0] = static_cast<char>(-1);
+                uint32_t data32 = static_cast<uint32_t>(data64);
+                _msgpack_store32(&p[1], data32);
+                o.via.ext.ptr = p;
+            }
+            else {
+                // timestamp 64
+                o.type = msgpack::type::EXT;
+                o.via.ext.size = 8;
+                char* p = static_cast<char*>(o.zone.allocate_no_align(o.via.ext.size + 1));
+                p[0] = static_cast<char>(-1);
+                _msgpack_store64(&p[1], data64);
+                o.via.ext.ptr = p;
+            }
+        }
+        else {
+            // timestamp 96
+            o.type = msgpack::type::EXT;
+            o.via.ext.size = 12;
+            char* p = static_cast<char*>(o.zone.allocate_no_align(o.via.ext.size + 1));
+            p[0] = static_cast<char>(-1);
+            _msgpack_store32(&p[1], static_cast<uint32_t>(v.tv_nsec));
+            _msgpack_store64(&p[1 + 4], v.tv_sec);
+            o.via.ext.ptr = p;
+        }
+    }
+};
+
+} // namespace adaptor
+
+/// @cond
+} // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+} // namespace msgpack
+
+#endif // MSGPACK_V1_TYPE_CPP11_TIMESPEC_HPP

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

@@ -10413,193 +10413,193 @@ inline tuple<> make_tuple()
 /// @cond
 
 template <typename A0>
-inline tuple<A0> make_tuple(typename tuple_type<A0>::transparent_reference a0)
+tuple<A0> make_tuple(A0 const& a0)
 {
     return tuple<A0>(a0);
 }
 
 template <typename A0, typename A1>
-inline tuple<A0, A1> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1)
+tuple<A0, A1> make_tuple(A0 const& a0, A1 const& a1)
 {
     return tuple<A0, A1>(a0, a1);
 }
 
 template <typename A0, typename A1, typename A2>
-inline tuple<A0, A1, A2> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2)
+tuple<A0, A1, A2> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2)
 {
     return tuple<A0, A1, A2>(a0, a1, a2);
 }
 
 template <typename A0, typename A1, typename A2, typename A3>
-inline tuple<A0, A1, A2, A3> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3)
+tuple<A0, A1, A2, A3> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3)
 {
     return tuple<A0, A1, A2, A3>(a0, a1, a2, a3);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4>
-inline tuple<A0, A1, A2, A3, A4> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4)
+tuple<A0, A1, A2, A3, A4> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4)
 {
     return tuple<A0, A1, A2, A3, A4>(a0, a1, a2, a3, a4);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
-inline tuple<A0, A1, A2, A3, A4, A5> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5)
+tuple<A0, A1, A2, A3, A4, A5> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5)
 {
     return tuple<A0, A1, A2, A3, A4, A5>(a0, a1, a2, a3, a4, a5);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
-inline tuple<A0, A1, A2, A3, A4, A5, A6> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6)
+tuple<A0, A1, A2, A3, A4, A5, A6> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6)
 {
     return tuple<A0, A1, A2, A3, A4, A5, A6>(a0, a1, a2, a3, a4, a5, a6);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
-inline tuple<A0, A1, A2, A3, A4, A5, A6, A7> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7)
+tuple<A0, A1, A2, A3, A4, A5, A6, A7> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7)
 {
     return tuple<A0, A1, A2, A3, A4, A5, A6, A7>(a0, a1, a2, a3, a4, a5, a6, a7);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
-inline tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8)
+tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8)
 {
     return tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>(a0, a1, a2, a3, a4, a5, a6, a7, a8);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
-inline tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9)
+tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9)
 {
     return tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10>
-inline tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10)
+tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10)
 {
     return tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11>
-inline tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11)
+tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11)
 {
     return tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
 }
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12>
-inline tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12)
+tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12)
 {
     return tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
 }
 
 template <typename A0, 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>
-inline tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13)
+tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13)
 {
     return tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
 }
 
 template <typename A0, 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>
-inline tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14)
+tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14)
 {
     return tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
 }
 
 template <typename A0, 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>
-inline tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15)
+tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15)
 {
     return tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
 }
 
 template <typename A0, 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, typename A16>
-inline tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16)
+tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16)
 {
     return tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16);
 }
 
 template <typename A0, 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, typename A16, typename A17>
-inline tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17)
+tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16, A17 const& a17)
 {
     return tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17);
 }
 
 template <typename A0, 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, typename A16, typename A17, typename A18>
-inline tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18)
+tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16, A17 const& a17, A18 const& a18)
 {
     return tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18);
 }
 
 template <typename A0, 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, typename A16, typename A17, typename A18, typename A19>
-inline tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19)
+tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16, A17 const& a17, A18 const& a18, A19 const& a19)
 {
     return tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19);
 }
 
 template <typename A0, 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, typename A16, typename A17, typename A18, typename A19, typename A20>
-inline tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20)
+tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16, A17 const& a17, A18 const& a18, A19 const& a19, A20 const& a20)
 {
     return tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
 }
 
 template <typename A0, 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, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21>
-inline tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21)
+tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16, A17 const& a17, A18 const& a18, A19 const& a19, A20 const& a20, A21 const& a21)
 {
     return tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21);
 }
 
 template <typename A0, 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, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22>
-inline tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21, typename tuple_type<A22>::transparent_reference a22)
+tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16, A17 const& a17, A18 const& a18, A19 const& a19, A20 const& a20, A21 const& a21, A22 const& a22)
 {
     return tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22);
 }
 
 template <typename A0, 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, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23>
-inline 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> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21, typename tuple_type<A22>::transparent_reference a22, typename tuple_type<A23>::transparent_reference a23)
+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> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16, A17 const& a17, A18 const& a18, A19 const& a19, A20 const& a20, A21 const& a21, A22 const& a22, A23 const& a23)
 {
     return 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>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23);
 }
 
 template <typename A0, 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, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24>
-inline 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> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21, typename tuple_type<A22>::transparent_reference a22, typename tuple_type<A23>::transparent_reference a23, typename tuple_type<A24>::transparent_reference a24)
+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> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16, A17 const& a17, A18 const& a18, A19 const& a19, A20 const& a20, A21 const& a21, A22 const& a22, A23 const& a23, A24 const& a24)
 {
     return 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>(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);
 }
 
 template <typename A0, 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, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25>
-inline 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> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21, typename tuple_type<A22>::transparent_reference a22, typename tuple_type<A23>::transparent_reference a23, typename tuple_type<A24>::transparent_reference a24, typename tuple_type<A25>::transparent_reference a25)
+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> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16, A17 const& a17, A18 const& a18, A19 const& a19, A20 const& a20, A21 const& a21, A22 const& a22, A23 const& a23, A24 const& a24, A25 const& a25)
 {
     return 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>(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);
 }
 
 template <typename A0, 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, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26>
-inline 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> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21, typename tuple_type<A22>::transparent_reference a22, typename tuple_type<A23>::transparent_reference a23, typename tuple_type<A24>::transparent_reference a24, typename tuple_type<A25>::transparent_reference a25, typename tuple_type<A26>::transparent_reference a26)
+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> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16, A17 const& a17, A18 const& a18, A19 const& a19, A20 const& a20, A21 const& a21, A22 const& a22, A23 const& a23, A24 const& a24, A25 const& a25, A26 const& a26)
 {
     return 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>(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);
 }
 
 template <typename A0, 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, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27>
-inline 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> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21, typename tuple_type<A22>::transparent_reference a22, typename tuple_type<A23>::transparent_reference a23, typename tuple_type<A24>::transparent_reference a24, typename tuple_type<A25>::transparent_reference a25, typename tuple_type<A26>::transparent_reference a26, typename tuple_type<A27>::transparent_reference a27)
+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> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16, A17 const& a17, A18 const& a18, A19 const& a19, A20 const& a20, A21 const& a21, A22 const& a22, A23 const& a23, A24 const& a24, A25 const& a25, A26 const& a26, A27 const& a27)
 {
     return 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>(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);
 }
 
 template <typename A0, 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, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28>
-inline 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> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21, typename tuple_type<A22>::transparent_reference a22, typename tuple_type<A23>::transparent_reference a23, typename tuple_type<A24>::transparent_reference a24, typename tuple_type<A25>::transparent_reference a25, typename tuple_type<A26>::transparent_reference a26, typename tuple_type<A27>::transparent_reference a27, typename tuple_type<A28>::transparent_reference a28)
+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> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16, A17 const& a17, A18 const& a18, A19 const& a19, A20 const& a20, A21 const& a21, A22 const& a22, A23 const& a23, A24 const& a24, A25 const& a25, A26 const& a26, A27 const& a27, A28 const& a28)
 {
     return 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>(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);
 }
 
 template <typename A0, 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, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29>
-inline 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> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21, typename tuple_type<A22>::transparent_reference a22, typename tuple_type<A23>::transparent_reference a23, typename tuple_type<A24>::transparent_reference a24, typename tuple_type<A25>::transparent_reference a25, typename tuple_type<A26>::transparent_reference a26, typename tuple_type<A27>::transparent_reference a27, typename tuple_type<A28>::transparent_reference a28, typename tuple_type<A29>::transparent_reference a29)
+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> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16, A17 const& a17, A18 const& a18, A19 const& a19, A20 const& a20, A21 const& a21, A22 const& a22, A23 const& a23, A24 const& a24, A25 const& a25, A26 const& a26, A27 const& a27, A28 const& a28, A29 const& a29)
 {
     return 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>(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);
 }
 
 template <typename A0, 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, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30>
-inline 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> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21, typename tuple_type<A22>::transparent_reference a22, typename tuple_type<A23>::transparent_reference a23, typename tuple_type<A24>::transparent_reference a24, typename tuple_type<A25>::transparent_reference a25, typename tuple_type<A26>::transparent_reference a26, typename tuple_type<A27>::transparent_reference a27, typename tuple_type<A28>::transparent_reference a28, typename tuple_type<A29>::transparent_reference a29, typename tuple_type<A30>::transparent_reference a30)
+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> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16, A17 const& a17, A18 const& a18, A19 const& a19, A20 const& a20, A21 const& a21, A22 const& a22, A23 const& a23, A24 const& a24, A25 const& a25, A26 const& a26, A27 const& a27, A28 const& a28, A29 const& a29, A30 const& a30)
 {
     return 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>(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);
 }
 
 template <typename A0, 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, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31>
-inline 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> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21, typename tuple_type<A22>::transparent_reference a22, typename tuple_type<A23>::transparent_reference a23, typename tuple_type<A24>::transparent_reference a24, typename tuple_type<A25>::transparent_reference a25, typename tuple_type<A26>::transparent_reference a26, typename tuple_type<A27>::transparent_reference a27, typename tuple_type<A28>::transparent_reference a28, typename tuple_type<A29>::transparent_reference a29, typename tuple_type<A30>::transparent_reference a30, typename tuple_type<A31>::transparent_reference a31)
+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> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16, A17 const& a17, A18 const& a18, A19 const& a19, A20 const& a20, A21 const& a21, A22 const& a22, A23 const& a23, A24 const& a24, A25 const& a25, A26 const& a26, A27 const& a27, A28 const& a28, A29 const& a29, A30 const& a30, A31 const& a31)
 {
     return 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>(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);
 }

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

@@ -209,100 +209,100 @@ tuple<> make_tuple();
 /// @cond
 
 template <typename A0>
-tuple<A0> make_tuple(typename tuple_type<A0>::transparent_reference a0);
+tuple<A0> make_tuple(A0 const& a0);
 
 template <typename A0, typename A1>
-tuple<A0, A1> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1);
+tuple<A0, A1> make_tuple(A0 const& a0, A1 const& a1);
 
 template <typename A0, typename A1, typename A2>
-tuple<A0, A1, A2> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2);
+tuple<A0, A1, A2> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2);
 
 template <typename A0, typename A1, typename A2, typename A3>
-tuple<A0, A1, A2, A3> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3);
+tuple<A0, A1, A2, A3> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3);
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4>
-tuple<A0, A1, A2, A3, A4> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4);
+tuple<A0, A1, A2, A3, A4> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4);
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
-tuple<A0, A1, A2, A3, A4, A5> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5);
+tuple<A0, A1, A2, A3, A4, A5> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5);
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
-tuple<A0, A1, A2, A3, A4, A5, A6> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6);
+tuple<A0, A1, A2, A3, A4, A5, A6> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6);
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
-tuple<A0, A1, A2, A3, A4, A5, A6, A7> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7);
+tuple<A0, A1, A2, A3, A4, A5, A6, A7> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7);
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
-tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8);
+tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8);
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
-tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9);
+tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9);
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10>
-tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10);
+tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10);
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11>
-tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11);
+tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11);
 
 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12>
-tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12);
+tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12);
 
 template <typename A0, 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>
-tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13);
+tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13);
 
 template <typename A0, 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>
-tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14);
+tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14);
 
 template <typename A0, 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>
-tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15);
+tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15);
 
 template <typename A0, 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, typename A16>
-tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16);
+tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16);
 
 template <typename A0, 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, typename A16, typename A17>
-tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17);
+tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16, A17 const& a17);
 
 template <typename A0, 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, typename A16, typename A17, typename A18>
-tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18);
+tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16, A17 const& a17, A18 const& a18);
 
 template <typename A0, 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, typename A16, typename A17, typename A18, typename A19>
-tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19);
+tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16, A17 const& a17, A18 const& a18, A19 const& a19);
 
 template <typename A0, 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, typename A16, typename A17, typename A18, typename A19, typename A20>
-tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20);
+tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16, A17 const& a17, A18 const& a18, A19 const& a19, A20 const& a20);
 
 template <typename A0, 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, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21>
-tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21);
+tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16, A17 const& a17, A18 const& a18, A19 const& a19, A20 const& a20, A21 const& a21);
 
 template <typename A0, 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, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22>
-tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21, typename tuple_type<A22>::transparent_reference a22);
+tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16, A17 const& a17, A18 const& a18, A19 const& a19, A20 const& a20, A21 const& a21, A22 const& a22);
 
 template <typename A0, 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, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23>
-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> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21, typename tuple_type<A22>::transparent_reference a22, typename tuple_type<A23>::transparent_reference a23);
+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> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16, A17 const& a17, A18 const& a18, A19 const& a19, A20 const& a20, A21 const& a21, A22 const& a22, A23 const& a23);
 
 template <typename A0, 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, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24>
-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> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21, typename tuple_type<A22>::transparent_reference a22, typename tuple_type<A23>::transparent_reference a23, typename tuple_type<A24>::transparent_reference a24);
+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> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16, A17 const& a17, A18 const& a18, A19 const& a19, A20 const& a20, A21 const& a21, A22 const& a22, A23 const& a23, A24 const& a24);
 
 template <typename A0, 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, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25>
-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> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21, typename tuple_type<A22>::transparent_reference a22, typename tuple_type<A23>::transparent_reference a23, typename tuple_type<A24>::transparent_reference a24, typename tuple_type<A25>::transparent_reference a25);
+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> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16, A17 const& a17, A18 const& a18, A19 const& a19, A20 const& a20, A21 const& a21, A22 const& a22, A23 const& a23, A24 const& a24, A25 const& a25);
 
 template <typename A0, 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, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26>
-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> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21, typename tuple_type<A22>::transparent_reference a22, typename tuple_type<A23>::transparent_reference a23, typename tuple_type<A24>::transparent_reference a24, typename tuple_type<A25>::transparent_reference a25, typename tuple_type<A26>::transparent_reference a26);
+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> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16, A17 const& a17, A18 const& a18, A19 const& a19, A20 const& a20, A21 const& a21, A22 const& a22, A23 const& a23, A24 const& a24, A25 const& a25, A26 const& a26);
 
 template <typename A0, 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, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27>
-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> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21, typename tuple_type<A22>::transparent_reference a22, typename tuple_type<A23>::transparent_reference a23, typename tuple_type<A24>::transparent_reference a24, typename tuple_type<A25>::transparent_reference a25, typename tuple_type<A26>::transparent_reference a26, typename tuple_type<A27>::transparent_reference a27);
+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> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16, A17 const& a17, A18 const& a18, A19 const& a19, A20 const& a20, A21 const& a21, A22 const& a22, A23 const& a23, A24 const& a24, A25 const& a25, A26 const& a26, A27 const& a27);
 
 template <typename A0, 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, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28>
-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> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21, typename tuple_type<A22>::transparent_reference a22, typename tuple_type<A23>::transparent_reference a23, typename tuple_type<A24>::transparent_reference a24, typename tuple_type<A25>::transparent_reference a25, typename tuple_type<A26>::transparent_reference a26, typename tuple_type<A27>::transparent_reference a27, typename tuple_type<A28>::transparent_reference a28);
+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> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16, A17 const& a17, A18 const& a18, A19 const& a19, A20 const& a20, A21 const& a21, A22 const& a22, A23 const& a23, A24 const& a24, A25 const& a25, A26 const& a26, A27 const& a27, A28 const& a28);
 
 template <typename A0, 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, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29>
-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> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21, typename tuple_type<A22>::transparent_reference a22, typename tuple_type<A23>::transparent_reference a23, typename tuple_type<A24>::transparent_reference a24, typename tuple_type<A25>::transparent_reference a25, typename tuple_type<A26>::transparent_reference a26, typename tuple_type<A27>::transparent_reference a27, typename tuple_type<A28>::transparent_reference a28, typename tuple_type<A29>::transparent_reference a29);
+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> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16, A17 const& a17, A18 const& a18, A19 const& a19, A20 const& a20, A21 const& a21, A22 const& a22, A23 const& a23, A24 const& a24, A25 const& a25, A26 const& a26, A27 const& a27, A28 const& a28, A29 const& a29);
 
 template <typename A0, 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, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30>
-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> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21, typename tuple_type<A22>::transparent_reference a22, typename tuple_type<A23>::transparent_reference a23, typename tuple_type<A24>::transparent_reference a24, typename tuple_type<A25>::transparent_reference a25, typename tuple_type<A26>::transparent_reference a26, typename tuple_type<A27>::transparent_reference a27, typename tuple_type<A28>::transparent_reference a28, typename tuple_type<A29>::transparent_reference a29, typename tuple_type<A30>::transparent_reference a30);
+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> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16, A17 const& a17, A18 const& a18, A19 const& a19, A20 const& a20, A21 const& a21, A22 const& a22, A23 const& a23, A24 const& a24, A25 const& a25, A26 const& a26, A27 const& a27, A28 const& a28, A29 const& a29, A30 const& a30);
 
 template <typename A0, 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, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31>
-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> make_tuple(typename tuple_type<A0>::transparent_reference a0, typename tuple_type<A1>::transparent_reference a1, typename tuple_type<A2>::transparent_reference a2, typename tuple_type<A3>::transparent_reference a3, typename tuple_type<A4>::transparent_reference a4, typename tuple_type<A5>::transparent_reference a5, typename tuple_type<A6>::transparent_reference a6, typename tuple_type<A7>::transparent_reference a7, typename tuple_type<A8>::transparent_reference a8, typename tuple_type<A9>::transparent_reference a9, typename tuple_type<A10>::transparent_reference a10, typename tuple_type<A11>::transparent_reference a11, typename tuple_type<A12>::transparent_reference a12, typename tuple_type<A13>::transparent_reference a13, typename tuple_type<A14>::transparent_reference a14, typename tuple_type<A15>::transparent_reference a15, typename tuple_type<A16>::transparent_reference a16, typename tuple_type<A17>::transparent_reference a17, typename tuple_type<A18>::transparent_reference a18, typename tuple_type<A19>::transparent_reference a19, typename tuple_type<A20>::transparent_reference a20, typename tuple_type<A21>::transparent_reference a21, typename tuple_type<A22>::transparent_reference a22, typename tuple_type<A23>::transparent_reference a23, typename tuple_type<A24>::transparent_reference a24, typename tuple_type<A25>::transparent_reference a25, typename tuple_type<A26>::transparent_reference a26, typename tuple_type<A27>::transparent_reference a27, typename tuple_type<A28>::transparent_reference a28, typename tuple_type<A29>::transparent_reference a29, typename tuple_type<A30>::transparent_reference a30, typename tuple_type<A31>::transparent_reference a31);
+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> make_tuple(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11, A12 const& a12, A13 const& a13, A14 const& a14, A15 const& a15, A16 const& a16, A17 const& a17, A18 const& a18, A19 const& a19, A20 const& a20, A21 const& a21, A22 const& a22, A23 const& a23, A24 const& a24, A25 const& a25, A26 const& a26, A27 const& a27, A28 const& a28, A29 const& a29, A30 const& a30, A31 const& a31);
 
 /// @endcond
 

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

@@ -53,7 +53,7 @@ struct MsgpackTuplePacker {
         msgpack::packer<Stream>& o,
         const Tuple& v) {
         MsgpackTuplePacker<Stream, Tuple, N-1>::pack(o, v);
-        o.pack(type::get<N-1>(v));
+        o.pack(v.template get<N-1>());
     }
 };
 
@@ -62,7 +62,7 @@ struct MsgpackTuplePacker<Stream, Tuple, 1> {
     static void pack (
         msgpack::packer<Stream>& o,
         const Tuple& v) {
-        o.pack(type::get<0>(v));
+        o.pack(v.template get<0>());
     }
 };
 
@@ -122,7 +122,7 @@ struct MsgpackTupleConverter {
         Tuple& v) {
         MsgpackTupleConverter<Tuple, N-1>::convert(o, v);
         if (o.via.array.size >= N)
-            o.via.array.ptr[N-1].convert<typename std::remove_reference<decltype(type::get<N-1>(v))>::type>(type::get<N-1>(v));
+            o.via.array.ptr[N-1].convert<typename std::remove_reference<decltype(v.template get<N-1>())>::type>(v.template get<N-1>());
     }
 };
 
@@ -131,7 +131,7 @@ struct MsgpackTupleConverter<Tuple, 1> {
     static void convert (
         msgpack::object const& o,
         Tuple& v) {
-        o.via.array.ptr[0].convert<typename std::remove_reference<decltype(type::get<0>(v))>::type>(type::get<0>(v));
+        o.via.array.ptr[0].convert<typename std::remove_reference<decltype(v.template get<0>())>::type>(v.template get<0>());
     }
 };
 
@@ -174,7 +174,7 @@ struct MsgpackTupleToObjectWithZone {
         msgpack::object::with_zone& o,
         const Tuple& v) {
         MsgpackTupleToObjectWithZone<Tuple, N-1>::convert(o, v);
-        o.via.array.ptr[N-1] = msgpack::object(type::get<N-1>(v), o.zone);
+        o.via.array.ptr[N-1] = msgpack::object(v.template get<N-1>(), o.zone);
     }
 };
 
@@ -183,7 +183,7 @@ struct MsgpackTupleToObjectWithZone<Tuple, 1> {
     static void convert (
         msgpack::object::with_zone& o,
         const Tuple& v) {
-        o.via.array.ptr[0] = msgpack::object(type::get<0>(v), o.zone);
+        o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone);
     }
 };
 

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

@@ -31,7 +31,7 @@ namespace type {
     using std::ignore;
     using std::swap;
 
-    template< class... Types >
+    template <class... Types>
     class tuple : public std::tuple<Types...> {
     public:
         using base = std::tuple<Types...>;
@@ -61,17 +61,17 @@ namespace type {
             return *this;
         }
 
-        template< std::size_t I>
-        typename tuple_element<I, base >::type&
-        get() & { return std::get<I>(*this); }
+        template<std::size_t I>
+        typename tuple_element<I, base>::type&
+        get() & noexcept { return std::get<I>(static_cast<base&>(*this)); }
 
-        template< std::size_t I>
-        typename tuple_element<I, base >::type const&
-        get() const& { return std::get<I>(*this); }
+        template<std::size_t I>
+        typename tuple_element<I, base>::type const&
+        get() const& noexcept { return std::get<I>(static_cast<base const&>(*this)); }
 
-        template< std::size_t I>
-        typename tuple_element<I, base >::type&&
-        get() && { return std::get<I>(*this); }
+        template<std::size_t I>
+        typename tuple_element<I, base>::type&&
+        get() && noexcept { return std::get<I>(static_cast<base&&>(*this)); }
 
         std::size_t size() const { return sizeof...(Types); }
     };

include/msgpack/v1/adaptor/ext.hpp

@@ -178,7 +178,7 @@ inline ext::ext(ext_ref const& x) {
     // size limit has already been checked at ext_ref's constructor
     m_data.reserve(x.size() + 1);
 
-    m_data.push_back(x.type());
+    m_data.push_back(static_cast<char>(x.type()));
     m_data.insert(m_data.end(), x.data(), x.data() + x.size());
 }
 

include/msgpack/v1/adaptor/fixint.hpp

@@ -22,6 +22,7 @@ namespace type {
 
 template <typename T>
 struct fix_int {
+    typedef T value_type;
     fix_int() : value(0) { }
     fix_int(T value) : value(value) { }
 
@@ -152,7 +153,7 @@ struct object<type::fix_int8> {
         }
         else {
             o.type = msgpack::type::POSITIVE_INTEGER;
-            o.via.u64 = v.get();
+            o.via.u64 = static_cast<uint64_t>(v.get());
         }
     }
 };
@@ -166,7 +167,7 @@ struct object<type::fix_int16> {
         }
         else {
             o.type = msgpack::type::POSITIVE_INTEGER;
-            o.via.u64 = v.get();
+            o.via.u64 = static_cast<uint64_t>(v.get());
         }
     }
 };
@@ -180,7 +181,7 @@ struct object<type::fix_int32> {
         }
         else {
             o.type = msgpack::type::POSITIVE_INTEGER;
-            o.via.u64 = v.get();
+            o.via.u64 = static_cast<uint64_t>(v.get());
         }
     }
 };
@@ -194,7 +195,7 @@ struct object<type::fix_int64> {
         }
         else {
             o.type = msgpack::type::POSITIVE_INTEGER;
-            o.via.u64 = v.get();
+            o.via.u64 = static_cast<uint64_t>(v.get());
         }
     }
 };

include/msgpack/v1/adaptor/int.hpp

@@ -64,31 +64,32 @@ inline T convert_integer(msgpack::object const& o)
 }
 
 template <>
-struct object_char_sign<true> {
+struct object_sign<true> {
     template <typename T>
-    static typename msgpack::enable_if<msgpack::is_same<T, char>::value>::type
-    make(msgpack::object& o, T v) {
+    static void make(msgpack::object& o, T v) {
         if (v < 0) {
             o.type = msgpack::type::NEGATIVE_INTEGER;
             o.via.i64 = v;
         }
         else {
             o.type = msgpack::type::POSITIVE_INTEGER;
-            o.via.u64 = v;
+            o.via.u64 = static_cast<uint64_t>(v);
         }
     }
 };
 
 template <>
-struct object_char_sign<false> {
-    static void make(msgpack::object& o, char v) {
+struct object_sign<false> {
+    template <typename T>
+    static void make(msgpack::object& o, T v) {
         o.type = msgpack::type::POSITIVE_INTEGER;
         o.via.u64 = v;
     }
 };
 
-inline void object_char(msgpack::object& o, char v) {
-    return object_char_sign<is_signed<char>::value>::make(o, v);
+template <typename T>
+inline void object_char(msgpack::object& o, T v) {
+    return object_sign<is_signed<T>::value>::make(o, v);
 }
 
 }  // namespace detail
@@ -102,6 +103,12 @@ struct convert<char> {
     { v = type::detail::convert_integer<char>(o); return o; }
 };
 
+template <>
+struct convert<wchar_t> {
+    msgpack::object const& operator()(msgpack::object const& o, wchar_t& v) const
+    { v = type::detail::convert_integer<wchar_t>(o); return o; }
+};
+
 template <>
 struct convert<signed char> {
     msgpack::object const& operator()(msgpack::object const& o, signed char& v) const
@@ -171,6 +178,13 @@ struct pack<char> {
     { o.pack_char(v); return o; }
 };
 
+template <>
+struct pack<wchar_t> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, wchar_t v) const
+    { o.pack_wchar(v); return o; }
+};
+
 template <>
 struct pack<signed char> {
     template <typename Stream>
@@ -249,6 +263,12 @@ struct object<char> {
     { type::detail::object_char(o, v); }
 };
 
+template <>
+struct object<wchar_t> {
+    void operator()(msgpack::object& o, wchar_t v) const
+    { type::detail::object_char(o, v); }
+};
+
 template <>
 struct object<signed char> {
     void operator()(msgpack::object& o, signed char v) const {
@@ -258,7 +278,7 @@ struct object<signed char> {
         }
         else {
             o.type = msgpack::type::POSITIVE_INTEGER;
-            o.via.u64 = v;
+            o.via.u64 = static_cast<uint64_t>(v);
         }
     }
 };
@@ -272,7 +292,7 @@ struct object<signed short> {
         }
         else {
             o.type = msgpack::type::POSITIVE_INTEGER;
-            o.via.u64 = v;
+            o.via.u64 = static_cast<uint64_t>(v);
         }
     }
 };
@@ -286,7 +306,7 @@ struct object<signed int> {
         }
         else {
             o.type = msgpack::type::POSITIVE_INTEGER;
-            o.via.u64 = v;
+            o.via.u64 = static_cast<uint64_t>(v);
         }
     }
 };
@@ -300,7 +320,7 @@ struct object<signed long> {
         }
         else {
             o.type = msgpack::type::POSITIVE_INTEGER;
-            o.via.u64 = v;
+            o.via.u64 = static_cast<uint64_t>(v);
         }
     }
 };
@@ -314,7 +334,7 @@ struct object<signed long long> {
         }
         else{
             o.type = msgpack::type::POSITIVE_INTEGER;
-            o.via.u64 = v;
+            o.via.u64 = static_cast<uint64_t>(v);
         }
     }
 };
@@ -367,6 +387,13 @@ struct object_with_zone<char> {
     }
 };
 
+template <>
+struct object_with_zone<wchar_t> {
+    void operator()(msgpack::object::with_zone& o, wchar_t v) const {
+        static_cast<msgpack::object&>(o) << v;
+    }
+};
+
 template <>
 struct object_with_zone<signed char> {
     void operator()(msgpack::object::with_zone& o, signed char v) const {

include/msgpack/v1/adaptor/int_decl.hpp

@@ -33,9 +33,10 @@ template <typename T>
 T convert_integer(msgpack::object const& o);
 
 template <bool Signed>
-struct object_char_sign;
+struct object_sign;
 
-void object_char(msgpack::object& o, char v);
+template <typename T>
+void object_char(msgpack::object& o, T v);
 
 }  // namespace detail
 }  // namespace type

include/msgpack/v1/adaptor/wstring.hpp

@@ -0,0 +1,121 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2018 KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_V1_TYPE_WSTRING_HPP
+#define MSGPACK_V1_TYPE_WSTRING_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/adaptor/check_container_size.hpp"
+
+#include <vector>
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace adaptor {
+
+#if !defined(MSGPACK_USE_CPP03)
+
+template <>
+struct as<std::wstring> {
+    std::wstring operator()(const msgpack::object& o) const {
+        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+        std::wstring v;
+        v.reserve(o.via.array.size);
+        if (o.via.array.size > 0) {
+            msgpack::object* p = o.via.array.ptr;
+            msgpack::object* const pend = o.via.array.ptr + o.via.array.size;
+            do {
+                v.push_back(p->as<wchar_t>());
+                ++p;
+            } while (p < pend);
+        }
+        return v;
+    }
+};
+
+#endif // !defined(MSGPACK_USE_CPP03)
+
+template <>
+struct convert<std::wstring> {
+    msgpack::object const& operator()(msgpack::object const& o, std::wstring& v) const {
+        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+        v.resize(o.via.array.size);
+        if (o.via.array.size > 0) {
+            msgpack::object* p = o.via.array.ptr;
+            msgpack::object* const pend = o.via.array.ptr + o.via.array.size;
+            std::wstring::iterator it = v.begin();
+            do {
+                p->convert(*it);
+                ++p;
+                ++it;
+            } while(p < pend);
+        }
+        return o;
+    }
+};
+
+template <>
+struct pack<std::wstring> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::wstring& v) const {
+        uint32_t size = checked_get_container_size(v.size());
+        o.pack_array(size);
+        for (std::wstring::const_iterator it(v.begin()), it_end(v.end());
+            it != it_end; ++it) {
+            o.pack(*it);
+        }
+        return o;
+    }
+};
+
+template <>
+struct object_with_zone<std::wstring> {
+    void operator()(msgpack::object::with_zone& o, const std::wstring& v) const {
+        o.type = msgpack::type::ARRAY;
+        if (v.empty()) {
+            o.via.array.ptr = MSGPACK_NULLPTR;
+            o.via.array.size = 0;
+        }
+        else {
+            uint32_t size = checked_get_container_size(v.size());
+            msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
+            msgpack::object* const pend = p + size;
+            o.via.array.ptr = p;
+            o.via.array.size = size;
+            std::wstring::const_iterator it(v.begin());
+            do {
+#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__)
+                *p = msgpack::object(*it, o.zone);
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
+#pragma GCC diagnostic pop
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
+                ++p;
+                ++it;
+            } while(p < pend);
+        }
+    }
+};
+
+} // namespace adaptor
+
+/// @cond
+} // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+} // namespace msgpack
+
+#endif // MSGPACK_V1_TYPE_WSTRING_HPP

include/msgpack/v1/detail/cpp03_zone.hpp

@@ -55,7 +55,7 @@ class zone {
             ++m_tail;
         }
         void push_expand(void (*func)(void*), void* data) {
-            const size_t nused = m_end - m_array;
+            const size_t nused = static_cast<size_t>(m_end - m_array);
             size_t nnext;
             if(nused == 0) {
                 nnext = (sizeof(finalizer) < 72/2) ?
@@ -246,12 +246,12 @@ inline char* zone::get_aligned(char* ptr, size_t 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);
+    size_t adjusted_size = size + static_cast<size_t>(aligned - m_chunk_list.m_ptr);
     if (m_chunk_list.m_free < adjusted_size) {
         size_t enough_size = size + align - 1;
         char* ptr = allocate_expand(enough_size);
         aligned = get_aligned(ptr, align);
-        adjusted_size = size + (aligned - m_chunk_list.m_ptr);
+        adjusted_size = size + static_cast<size_t>(aligned - m_chunk_list.m_ptr);
     }
     m_chunk_list.m_free -= adjusted_size;
     m_chunk_list.m_ptr  += adjusted_size;

include/msgpack/v1/detail/cpp11_zone.hpp

@@ -61,7 +61,7 @@ private:
             ++m_tail;
         }
         void push_expand(void (*func)(void*), void* data) {
-            const size_t nused = m_end - m_array;
+            const size_t nused = static_cast<size_t>(m_end - m_array);
             size_t nnext;
             if(nused == 0) {
                 nnext = (sizeof(finalizer) < 72/2) ?
@@ -239,12 +239,12 @@ inline char* zone::get_aligned(char* ptr, size_t 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);
+    size_t adjusted_size = size + static_cast<size_t>(aligned - m_chunk_list.m_ptr);
     if (m_chunk_list.m_free < adjusted_size) {
         size_t enough_size = size + align - 1;
         char* ptr = allocate_expand(enough_size);
         aligned = get_aligned(ptr, align);
-        adjusted_size = size + (aligned - m_chunk_list.m_ptr);
+        adjusted_size = size + static_cast<size_t>(aligned - m_chunk_list.m_ptr);
     }
     m_chunk_list.m_free -= adjusted_size;
     m_chunk_list.m_ptr  += adjusted_size;

include/msgpack/v1/object.hpp

@@ -352,8 +352,8 @@ struct object_pack_visitor {
         return true;
     }
     bool visit_ext(const char* v, uint32_t size) {
-        m_packer.pack_ext(size, *v);
-        m_packer.pack_ext_body(v, size);
+        m_packer.pack_ext(size - 1, static_cast<int8_t>(*v));
+        m_packer.pack_ext_body(v + 1, size - 1);
         return true;
     }
     bool start_array(uint32_t num_elements) {
@@ -467,7 +467,7 @@ struct object_stringize_visitor {
         return true;
     }
     bool visit_bin(const char* v, uint32_t size) {
-        (m_os << '"').write(v, size) << '"';
+        (m_os << '"').write(v, static_cast<std::streamsize>(size)) << '"';
         return true;
     }
     bool visit_ext(const char* /*v*/, uint32_t /*size*/) {
@@ -527,7 +527,7 @@ private:
 };
 
 struct aligned_zone_size_visitor {
-    explicit aligned_zone_size_visitor(std::size_t s)
+    explicit aligned_zone_size_visitor(std::size_t& s)
         :m_size(s) {}
     bool visit_nil() {
         return true;
@@ -596,7 +596,7 @@ struct aligned_zone_size_visitor {
         return true;
     }
 private:
-    std::size_t m_size;
+    std::size_t& m_size;
 };
 
 inline std::size_t aligned_zone_size(msgpack::object const& obj) {
@@ -938,7 +938,7 @@ struct object_equal_visitor {
     }
     bool visit_ext(const char* v, uint32_t size) {
         if (m_ptr->type != msgpack::type::EXT ||
-            m_ptr->via.ext.size != size ||
+            m_ptr->via.ext.size != size - 1 ||
             std::memcmp(m_ptr->via.ext.ptr, v, size) != 0) {
             m_result = false;
             return false;

include/msgpack/v1/object_fwd.hpp

@@ -40,7 +40,7 @@ struct object_bin {
 };
 
 struct object_ext {
-    int8_t type() const { return ptr[0]; }
+    int8_t type() const { return static_cast<int8_t>(ptr[0]); }
     const char* data() const { return &ptr[1]; }
     uint32_t size;
     const char* ptr;

include/msgpack/v1/pack.hpp

@@ -16,6 +16,7 @@
 #include <limits>
 #include <cstring>
 #include <climits>
+#include <ostream>
 
 namespace msgpack {
 
@@ -271,6 +272,20 @@ public:
      */
     packer<Stream>& pack_char(char d);
 
+    /// Packing wchar_t
+    /**
+     * The byte size of the packed data depends on `d`.
+     * If `d` is zero or positive, the packed type is positive fixnum, or uint*,
+     * else the packed type is negative fixnum, or int*
+     * The minimum byte size expression is used.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-int
+     *
+     * @param d a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_wchar(wchar_t d);
+
     /// Packing signed char
     /**
      * The byte size of the packed data depends on `d`.
@@ -604,7 +619,15 @@ private:
     void pack_imp_int64(T d);
 
     void append_buffer(const char* buf, size_t len)
-        { m_stream.write(buf, len); }
+    {
+        append_buffer(&Stream::write, buf, len);
+    }
+
+    template <typename Ret, typename Cls, typename SizeType>
+    void append_buffer(Ret (Cls::*)(const char*, SizeType), const char* buf, size_t len)
+    {
+        m_stream.write(buf, static_cast<SizeType>(len));
+    }
 
 private:
     Stream& m_stream;
@@ -781,7 +804,7 @@ template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_fix_int16(int16_t d)
 {
     char buf[3];
-    buf[0] = static_cast<char>(0xd1u); _msgpack_store16(&buf[1], d);
+    buf[0] = static_cast<char>(0xd1u); _msgpack_store16(&buf[1], (uint16_t)d);
     append_buffer(buf, 3);
     return *this;
 }
@@ -790,7 +813,7 @@ template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_fix_int32(int32_t d)
 {
     char buf[5];
-    buf[0] = static_cast<char>(0xd2u); _msgpack_store32(&buf[1], d);
+    buf[0] = static_cast<char>(0xd2u); _msgpack_store32(&buf[1], (uint32_t)d);
     append_buffer(buf, 5);
     return *this;
 }
@@ -820,6 +843,18 @@ inline packer<Stream>& packer<Stream>::pack_char(char d)
     return *this;
 }
 
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_wchar(wchar_t d)
+{
+    if (d < 0) {
+        pack_imp_int64(static_cast<int64_t>(d));
+    }
+    else {
+        pack_imp_uint64(static_cast<uint64_t>(d));
+    }
+    return *this;
+}
+
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_signed_char(signed char d)
 {
@@ -1202,7 +1237,7 @@ inline packer<Stream>& packer<Stream>::pack_str(uint32_t l)
         append_buffer(&buf, 1);
     } else if(l < 256) {
         char buf[2];
-        buf[0] = static_cast<char>(0xd9u); buf[1] = static_cast<uint8_t>(l);
+        buf[0] = static_cast<char>(0xd9u); buf[1] = static_cast<char>(l);
         append_buffer(buf, 2);
     } else if(l < 65536) {
         char buf[3];
@@ -1256,7 +1291,7 @@ inline packer<Stream>& packer<Stream>::pack_bin(uint32_t l)
 {
     if(l < 256) {
         char buf[2];
-        buf[0] = static_cast<char>(0xc4u); buf[1] = static_cast<uint8_t>(l);
+        buf[0] = static_cast<char>(0xc4u); buf[1] = static_cast<char>(l);
         append_buffer(buf, 2);
     } else if(l < 65536) {
         char buf[3];

include/msgpack/v1/unpack.hpp

@@ -78,19 +78,19 @@ inline void unpack_uint64(uint64_t d, msgpack::object& o)
 { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; }
 
 inline void unpack_int8(int8_t d, msgpack::object& o)
-{ if(d >= 0) { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; }
+{ if(d >= 0) { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = static_cast<uint64_t>(d); }
         else { o.type = msgpack::type::NEGATIVE_INTEGER; o.via.i64 = d; } }
 
 inline void unpack_int16(int16_t d, msgpack::object& o)
-{ if(d >= 0) { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; }
+{ if(d >= 0) { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = static_cast<uint64_t>(d); }
         else { o.type = msgpack::type::NEGATIVE_INTEGER; o.via.i64 = d; } }
 
 inline void unpack_int32(int32_t d, msgpack::object& o)
-{ if(d >= 0) { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; }
+{ if(d >= 0) { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = static_cast<uint64_t>(d); }
         else { o.type = msgpack::type::NEGATIVE_INTEGER; o.via.i64 = d; } }
 
 inline void unpack_int64(int64_t d, msgpack::object& o)
-{ if(d >= 0) { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; }
+{ if(d >= 0) { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = static_cast<uint64_t>(d); }
         else { o.type = msgpack::type::NEGATIVE_INTEGER; o.via.i64 = d; } }
 
 inline void unpack_float(float d, msgpack::object& o)
@@ -113,10 +113,13 @@ struct unpack_array {
         if (n > u.limit().array()) throw msgpack::array_size_overflow("array size overflow");
         o.type = msgpack::type::ARRAY;
         o.via.array.size = 0;
-        size_t size = n*sizeof(msgpack::object);
-        if (size / sizeof(msgpack::object) != n) {
+
+#if SIZE_MAX == UINT_MAX
+        if (n > SIZE_MAX/sizeof(msgpack::object))
             throw msgpack::array_size_overflow("array size overflow");
-        }
+#endif // SIZE_MAX == UINT_MAX
+
+        size_t size = n*sizeof(msgpack::object);
         o.via.array.ptr = static_cast<msgpack::object*>(u.zone().allocate_align(size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
     }
 };
@@ -125,6 +128,7 @@ inline void unpack_array_item(msgpack::object& c, msgpack::object const& o)
 {
 #if defined(__GNUC__) && !defined(__clang__)
     std::memcpy(&c.via.array.ptr[c.via.array.size++], &o, sizeof(msgpack::object));
+
 #else  /* __GNUC__ && !__clang__ */
     c.via.array.ptr[c.via.array.size++] = o;
 #endif /* __GNUC__ && !__clang__ */
@@ -135,10 +139,13 @@ struct unpack_map {
         if (n > u.limit().map()) throw msgpack::map_size_overflow("map size overflow");
         o.type = msgpack::type::MAP;
         o.via.map.size = 0;
-        size_t size = n*sizeof(msgpack::object_kv);
-        if (size / sizeof(msgpack::object_kv) != n) {
+
+#if SIZE_MAX == UINT_MAX
+        if (n > SIZE_MAX/sizeof(msgpack::object_kv))
             throw msgpack::map_size_overflow("map size overflow");
-        }
+#endif // SIZE_MAX == UINT_MAX
+
+        size_t size = n*sizeof(msgpack::object_kv);
         o.via.map.ptr = static_cast<msgpack::object_kv*>(u.zone().allocate_align(size, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
     }
 };
@@ -418,10 +425,10 @@ private:
             m_stack[0].set_obj(obj);
             ++m_current;
             /*printf("-- finish --\n"); */
-            off = m_current - m_start;
+            off = static_cast<std::size_t>(m_current - m_start);
         }
         else if (ret < 0) {
-            off = m_current - m_start;
+            off = static_cast<std::size_t>(m_current - m_start);
         }
         else {
             m_cs = MSGPACK_CS_HEADER;
@@ -461,7 +468,7 @@ inline int context::execute(const char* data, std::size_t len, std::size_t& off)
     msgpack::object obj;
 
     if(m_current == pe) {
-        off = m_current - m_start;
+        off = static_cast<std::size_t>(m_current - m_start);
         return 0;
     }
     bool fixed_trail_again = false;
@@ -544,7 +551,7 @@ inline int context::execute(const char* data, std::size_t len, std::size_t& off)
                 int ret = push_proc(obj, off);
                 if (ret != 0) return ret;
             } else {
-                off = m_current - m_start;
+                off = static_cast<std::size_t>(m_current - m_start);
                 return -1;
             }
             // end MSGPACK_CS_HEADER
@@ -555,7 +562,7 @@ inline int context::execute(const char* data, std::size_t len, std::size_t& off)
                 fixed_trail_again = false;
             }
             if(static_cast<std::size_t>(pe - m_current) < m_trail) {
-                off = m_current - m_start;
+                off = static_cast<std::size_t>(m_current - m_start);
                 return 0;
             }
             n = m_current;
@@ -830,13 +837,13 @@ inline int context::execute(const char* data, std::size_t len, std::size_t& off)
                 if (ret != 0) return ret;
             } break;
             default:
-                off = m_current - m_start;
+                off = static_cast<std::size_t>(m_current - m_start);
                 return -1;
             }
         }
     } while(m_current != pe);
 
-    off = m_current - m_start;
+    off = static_cast<std::size_t>(m_current - m_start);
     return 0;
 }
 

include/msgpack/v1/vrefbuffer.hpp

@@ -117,7 +117,7 @@ public:
     void append_ref(const char* buf, size_t len)
     {
         if(m_tail == m_end) {
-            const size_t nused = m_tail - m_array;
+            const size_t nused = static_cast<size_t>(m_tail - m_array);
             const size_t nnext = nused * 2;
 
             iovec* nvec = static_cast<iovec*>(::realloc(
@@ -145,11 +145,11 @@ public:
             if(sz < len) {
                 sz = len;
             }
-             
+
             if(sizeof(chunk) + sz < sz){
                 throw std::bad_alloc();
             }
-            
+
             chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + sz));
             if(!c) {
                 throw std::bad_alloc();
@@ -184,7 +184,7 @@ public:
 
     size_t vector_size() const
     {
-        return m_tail - m_array;
+        return static_cast<size_t>(m_tail - m_array);
     }
 
     void migrate(vrefbuffer* to)
@@ -202,11 +202,11 @@ public:
 
         empty->next = MSGPACK_NULLPTR;
 
-        const size_t nused = m_tail - m_array;
+        const size_t nused = static_cast<size_t>(m_tail - m_array);
         if(to->m_tail + nused < m_end) {
-            const size_t tosize = to->m_tail - to->m_array;
+            const size_t tosize = static_cast<size_t>(to->m_tail - to->m_array);
             const size_t reqsize = nused + tosize;
-            size_t nnext = (to->m_end - to->m_array) * 2;
+            size_t nnext = static_cast<size_t>(to->m_end - to->m_array) * 2;
             while(nnext < reqsize) {
                 size_t tmp_nnext = nnext * 2;
                 if (tmp_nnext <= nnext) {

include/msgpack/v1/zbuffer.hpp

@@ -47,7 +47,7 @@ public:
     void write(const char* buf, size_t len)
     {
         m_stream.next_in = reinterpret_cast<Bytef*>(const_cast<char*>(buf));
-        m_stream.avail_in = len;
+        m_stream.avail_in = static_cast<uInt>(len);
 
         while(m_stream.avail_in > 0) {
             if(m_stream.avail_out < MSGPACK_ZBUFFER_RESERVE_SIZE) {
@@ -69,6 +69,7 @@ public:
             case Z_STREAM_END:
                 return m_data;
             case Z_OK:
+            case Z_BUF_ERROR:
                 if(!expand()) {
                     throw std::bad_alloc();
                 }
@@ -91,7 +92,7 @@ public:
 
     size_t size() const
     {
-        return reinterpret_cast<char*>(m_stream.next_out) - m_data;
+        return static_cast<size_t>(reinterpret_cast<char*>(m_stream.next_out) - m_data);
     }
 
     void reset()
@@ -104,7 +105,7 @@ public:
 
     void reset_buffer()
     {
-        m_stream.avail_out += reinterpret_cast<char*>(m_stream.next_out) - m_data;
+        m_stream.avail_out += static_cast<uInt>(reinterpret_cast<char*>(m_stream.next_out) - m_data);
         m_stream.next_out = reinterpret_cast<Bytef*>(m_data);
     }
 
@@ -120,7 +121,7 @@ public:
 private:
     bool expand()
     {
-        size_t used = reinterpret_cast<char*>(m_stream.next_out) - m_data;
+        size_t used = static_cast<size_t>(reinterpret_cast<char*>(m_stream.next_out) - m_data);
         size_t csize = used + m_stream.avail_out;
         size_t nsize = (csize == 0) ? m_init_size : csize * 2;
 
@@ -131,7 +132,7 @@ private:
 
         m_data = tmp;
         m_stream.next_out  = reinterpret_cast<Bytef*>(tmp + used);
-        m_stream.avail_out = nsize - used;
+        m_stream.avail_out = static_cast<uInt>(nsize - used);
 
         return true;
     }

include/msgpack/v2/adaptor/int_decl.hpp

@@ -30,7 +30,7 @@ struct is_signed;
 
 
 template <bool Signed>
-struct object_char_sign;
+struct object_sign;
 
 //using v1::type::detail::convert_integer_sign;
 

include/msgpack/v2/create_object_visitor.hpp

@@ -85,7 +85,7 @@ public:
         msgpack::object* obj = m_stack.back();
         if(v >= 0) {
             obj->type = msgpack::type::POSITIVE_INTEGER;
-            obj->via.u64 = v;
+            obj->via.u64 = static_cast<uint64_t>(v);
         }
         else {
             obj->type = msgpack::type::NEGATIVE_INTEGER;
@@ -163,10 +163,13 @@ public:
             obj->via.array.ptr = MSGPACK_NULLPTR;
         }
         else {
-            size_t size = num_elements*sizeof(msgpack::object);
-            if (size / sizeof(msgpack::object) != num_elements) {
+
+#if SIZE_MAX == UINT_MAX
+            if (num_elements > SIZE_MAX/sizeof(msgpack::object))
                 throw msgpack::array_size_overflow("array size overflow");
-            }
+#endif // SIZE_MAX == UINT_MAX
+
+            size_t size = num_elements*sizeof(msgpack::object);
             obj->via.array.ptr =
                 static_cast<msgpack::object*>(m_zone->allocate_align(size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         }
@@ -194,10 +197,12 @@ public:
             obj->via.map.ptr = MSGPACK_NULLPTR;
         }
         else {
-            size_t size = num_kv_pairs*sizeof(msgpack::object_kv);
-            if (size / sizeof(msgpack::object_kv) != num_kv_pairs) {
+
+#if SIZE_MAX == UINT_MAX
+            if (num_kv_pairs > SIZE_MAX/sizeof(msgpack::object_kv))
                 throw msgpack::map_size_overflow("map size overflow");
-            }
+#endif // SIZE_MAX == UINT_MAX
+            size_t size = num_kv_pairs*sizeof(msgpack::object_kv);
             obj->via.map.ptr =
                 static_cast<msgpack::object_kv*>(m_zone->allocate_align(size, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
         }

include/msgpack/v2/parse.hpp

@@ -71,27 +71,27 @@ private:
         ++m_current;
         if (size == 0) {
             if (!sv(size)) {
-                off = m_current - m_start;
+                off = static_cast<std::size_t>(m_current - m_start);
                 return PARSE_STOP_VISITOR;
             }
             if (!ev()) {
-                off = m_current - m_start;
+                off = static_cast<std::size_t>(m_current - m_start);
                 return PARSE_STOP_VISITOR;
             }
             parse_return ret = m_stack.consume(holder());
             if (ret != PARSE_CONTINUE) {
-                off = m_current - m_start;
+                off = static_cast<std::size_t>(m_current - m_start);
                 return ret;
             }
         }
         else {
             if (!sv(size)) {
-                off = m_current - m_start;
+                off = static_cast<std::size_t>(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;
+                off = static_cast<std::size_t>(m_current - m_start);
                 return ret;
             }
         }
@@ -102,12 +102,12 @@ private:
     parse_return after_visit_proc(bool visit_result, std::size_t& off) {
         ++m_current;
         if (!visit_result) {
-            off = m_current - m_start;
+            off = static_cast<std::size_t>(m_current - m_start);
             return PARSE_STOP_VISITOR;
         }
         parse_return ret = m_stack.consume(holder());
         if (ret != PARSE_CONTINUE) {
-            off = m_current - m_start;
+            off = static_cast<std::size_t>(m_current - m_start);
         }
         m_cs = MSGPACK_CS_HEADER;
         return ret;
@@ -241,10 +241,8 @@ inline parse_return context<VisitorHolder>::execute(const char* data, std::size_
     const char* const pe = data + len;
     const char* n = MSGPACK_NULLPTR;
 
-    msgpack::object obj;
-
     if(m_current == pe) {
-        off = m_current - m_start;
+        off = static_cast<std::size_t>(m_current - m_start);
         return PARSE_CONTINUE;
     }
     bool fixed_trail_again = false;
@@ -326,7 +324,7 @@ inline parse_return context<VisitorHolder>::execute(const char* data, std::size_
                 parse_return upr = after_visit_proc(visret, off);
                 if (upr != PARSE_CONTINUE) return upr;
             } else {
-                off = m_current - m_start;
+                off = static_cast<std::size_t>(m_current - m_start);
                 holder().visitor().parse_error(off - 1, off);
                 return PARSE_PARSE_ERROR;
             }
@@ -338,7 +336,7 @@ inline parse_return context<VisitorHolder>::execute(const char* data, std::size_
                 fixed_trail_again = false;
             }
             if(static_cast<std::size_t>(pe - m_current) < m_trail) {
-                off = m_current - m_start;
+                off = static_cast<std::size_t>(m_current - m_start);
                 return PARSE_CONTINUE;
             }
             n = m_current;
@@ -608,14 +606,14 @@ inline parse_return context<VisitorHolder>::execute(const char* data, std::size_
                 if (ret != PARSE_CONTINUE) return ret;
             } break;
             default:
-                off = m_current - m_start;
-                holder().visitor().parse_error(n - m_start - 1, n - m_start);
+                off = static_cast<std::size_t>(m_current - m_start);
+                holder().visitor().parse_error(static_cast<std::size_t>(n - m_start - 1), static_cast<std::size_t>(n - m_start));
                 return PARSE_PARSE_ERROR;
             }
         }
     } while(m_current != pe);
 
-    off = m_current - m_start;
+    off = static_cast<std::size_t>(m_current - m_start);
     return PARSE_CONTINUE;
 }
 

include/msgpack/v2/x3_parse.hpp

@@ -22,6 +22,7 @@
 #if __GNUC__ >= 4
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wconversion"
 #endif // __GNUC__ >= 4
 
 #include <boost/config/warning_disable.hpp>
@@ -202,7 +203,7 @@ const auto mp_object_def =
         (
             [](auto& ctx){
                 auto& app_specific = x3::get<tag_app_specific>(ctx).get();
-                std::int8_t val = _attr(ctx);
+                std::int8_t val = static_cast<std::int8_t>(_attr(ctx));
                 app_specific.vis.visit_negative_integer(val);
             }
         )
@@ -253,7 +254,7 @@ const auto mp_object_def =
         (
             [](auto& ctx){
                 auto& app_specific = x3::get<tag_app_specific>(ctx).get();
-                std::int8_t val = _attr(ctx);
+                std::int8_t val = static_cast<std::int8_t>(_attr(ctx));
                 app_specific.vis.visit_negative_integer(val);
             }
         )
@@ -264,7 +265,7 @@ const auto mp_object_def =
         (
             [](auto& ctx){
                 auto& app_specific = x3::get<tag_app_specific>(ctx).get();
-                std::int16_t val = _attr(ctx);
+                std::int16_t val = static_cast<std::int16_t>(_attr(ctx));
                 app_specific.vis.visit_negative_integer(val);
             }
         )
@@ -275,7 +276,7 @@ const auto mp_object_def =
         (
             [](auto& ctx){
                 auto& app_specific = x3::get<tag_app_specific>(ctx).get();
-                std::int32_t val = _attr(ctx);
+                std::int32_t val = static_cast<std::int32_t>(_attr(ctx));
                 app_specific.vis.visit_negative_integer(val);
             }
         )
@@ -286,7 +287,7 @@ const auto mp_object_def =
         (
             [](auto& ctx){
                 auto& app_specific = x3::get<tag_app_specific>(ctx).get();
-                std::int64_t val = _attr(ctx);
+                std::int64_t val = static_cast<std::int64_t>(_attr(ctx));
                 app_specific.vis.visit_negative_integer(val);
             }
         )
@@ -339,7 +340,7 @@ const auto mp_object_def =
             [](auto& ctx){
                 auto& app_specific = x3::get<tag_app_specific>(ctx).get();
                 auto const& str = _attr(ctx);
-                std::size_t size = std::distance(str.begin(), str.end());
+                auto size = static_cast<uint32_t>(std::distance(str.begin(), str.end()));
                 app_specific.vis.visit_str(size ? &str.front() : nullptr, size);
             }
         )
@@ -363,7 +364,7 @@ const auto mp_object_def =
             [](auto& ctx){
                 auto& app_specific = x3::get<tag_app_specific>(ctx).get();
                 auto const& str = _attr(ctx);
-                std::size_t size = std::distance(str.begin(), str.end());
+                auto size = static_cast<uint32_t>(std::distance(str.begin(), str.end()));
                 app_specific.vis.visit_str(size ? &str.front() : nullptr, size);
             }
         )
@@ -387,7 +388,7 @@ const auto mp_object_def =
             [](auto& ctx){
                 auto& app_specific = x3::get<tag_app_specific>(ctx).get();
                 auto const& str = _attr(ctx);
-                std::size_t size = std::distance(str.begin(), str.end());
+                auto size = static_cast<uint32_t>(std::distance(str.begin(), str.end()));
                 app_specific.vis.visit_str(size ? &str.front() : nullptr, size);
             }
         )
@@ -411,7 +412,7 @@ const auto mp_object_def =
             [](auto& ctx){
                 auto& app_specific = x3::get<tag_app_specific>(ctx).get();
                 auto const& str = _attr(ctx);
-                std::size_t size = std::distance(str.begin(), str.end());
+                auto size = static_cast<uint32_t>(std::distance(str.begin(), str.end()));
                 app_specific.vis.visit_str(size ? &str.front() : nullptr, size);
             }
         )
@@ -435,7 +436,7 @@ const auto mp_object_def =
             [](auto& ctx){
                 auto& app_specific = x3::get<tag_app_specific>(ctx).get();
                 auto const& bin = _attr(ctx);
-                std::size_t size = std::distance(bin.begin(), bin.end());
+                auto size = static_cast<uint32_t>(std::distance(bin.begin(), bin.end()));
                 app_specific.vis.visit_bin(size ? &bin.front() : nullptr, size);
             }
         )
@@ -459,7 +460,7 @@ const auto mp_object_def =
             [](auto& ctx){
                 auto& app_specific = x3::get<tag_app_specific>(ctx).get();
                 auto const& bin = _attr(ctx);
-                std::size_t size = std::distance(bin.begin(), bin.end());
+                auto size = static_cast<uint32_t>(std::distance(bin.begin(), bin.end()));
                 app_specific.vis.visit_bin(size ? &bin.front() : nullptr, size);
             }
         )
@@ -483,7 +484,7 @@ const auto mp_object_def =
             [](auto& ctx){
                 auto& app_specific = x3::get<tag_app_specific>(ctx).get();
                 auto const& bin = _attr(ctx);
-                std::size_t size = std::distance(bin.begin(), bin.end());
+                auto size = static_cast<uint32_t>(std::distance(bin.begin(), bin.end()));
                 app_specific.vis.visit_bin(size ? &bin.front() : nullptr, size);
             }
         )
@@ -494,7 +495,7 @@ const auto mp_object_def =
         (
             [](auto& ctx){
                 auto& app_specific = x3::get<tag_app_specific>(ctx).get();
-                std::size_t size = _attr(ctx) & 0b00001111;
+                uint32_t size = _attr(ctx) & 0b00001111;
                 app_specific.index_sizes.emplace_back(size, index_size::type_t::array);
                 app_specific.vis.start_array(size);
             }
@@ -508,7 +509,7 @@ const auto mp_object_def =
         (
             [](auto& ctx){
                 auto& app_specific = x3::get<tag_app_specific>(ctx).get();
-                std::size_t size = _attr(ctx);
+                uint32_t size = _attr(ctx);
                 app_specific.index_sizes.emplace_back(size, index_size::type_t::array);
                 app_specific.vis.start_array(size);
             }
@@ -522,7 +523,7 @@ const auto mp_object_def =
         (
             [](auto& ctx){
                 auto& app_specific = x3::get<tag_app_specific>(ctx).get();
-                std::size_t size = _attr(ctx);
+                uint32_t size = _attr(ctx);
                 app_specific.index_sizes.emplace_back(size, index_size::type_t::array);
                 app_specific.vis.start_array(size);
             }
@@ -536,7 +537,7 @@ const auto mp_object_def =
         (
             [](auto& ctx){
                 auto& app_specific = x3::get<tag_app_specific>(ctx).get();
-                std::size_t size = _attr(ctx) & 0b00001111;
+                uint32_t size = _attr(ctx) & 0b00001111;
                 app_specific.index_sizes.emplace_back(size, index_size::type_t::map);
                 app_specific.vis.start_map(size);
             }
@@ -550,7 +551,7 @@ const auto mp_object_def =
         (
             [](auto& ctx){
                 auto& app_specific = x3::get<tag_app_specific>(ctx).get();
-                std::size_t size = _attr(ctx);
+                uint32_t size = _attr(ctx);
                 app_specific.index_sizes.emplace_back(size, index_size::type_t::map);
                 app_specific.vis.start_map(size);
             }
@@ -564,7 +565,7 @@ const auto mp_object_def =
         (
             [](auto& ctx){
                 auto& app_specific = x3::get<tag_app_specific>(ctx).get();
-                std::size_t size = _attr(ctx);
+                uint32_t size = _attr(ctx);
                 app_specific.index_sizes.emplace_back(size, index_size::type_t::map);
                 app_specific.vis.start_map(size);
             }
@@ -591,7 +592,7 @@ const auto mp_object_def =
             [](auto& ctx){
                 auto& app_specific = x3::get<tag_app_specific>(ctx).get();
                 auto const& ext = _attr(ctx);
-                std::size_t size = std::distance(ext.begin(), ext.end());
+                auto size = static_cast<uint32_t>(std::distance(ext.begin(), ext.end()));
                 app_specific.vis.visit_ext(size ? &ext.front() : nullptr, size);
             }
         )
@@ -615,7 +616,7 @@ const auto mp_object_def =
             [](auto& ctx){
                 auto& app_specific = x3::get<tag_app_specific>(ctx).get();
                 auto const& ext = _attr(ctx);
-                std::size_t size = std::distance(ext.begin(), ext.end());
+                auto size = static_cast<uint32_t>(std::distance(ext.begin(), ext.end()));
                 app_specific.vis.visit_ext(size ? &ext.front() : nullptr, size);
             }
         )
@@ -639,7 +640,7 @@ const auto mp_object_def =
             [](auto& ctx){
                 auto& app_specific = x3::get<tag_app_specific>(ctx).get();
                 auto const& ext = _attr(ctx);
-                std::size_t size = std::distance(ext.begin(), ext.end());
+                auto size = static_cast<uint32_t>(std::distance(ext.begin(), ext.end()));
                 app_specific.vis.visit_ext(size ? &ext.front() : nullptr, size);
             }
         )
@@ -663,7 +664,7 @@ const auto mp_object_def =
             [](auto& ctx){
                 auto& app_specific = x3::get<tag_app_specific>(ctx).get();
                 auto const& ext = _attr(ctx);
-                std::size_t size = std::distance(ext.begin(), ext.end());
+                auto size = static_cast<uint32_t>(std::distance(ext.begin(), ext.end()));
                 app_specific.vis.visit_ext(size ? &ext.front() : nullptr, size);
             }
         )
@@ -687,7 +688,7 @@ const auto mp_object_def =
             [](auto& ctx){
                 auto& app_specific = x3::get<tag_app_specific>(ctx).get();
                 auto const& ext = _attr(ctx);
-                std::size_t size = std::distance(ext.begin(), ext.end());
+                auto size = static_cast<uint32_t>(std::distance(ext.begin(), ext.end()));
                 app_specific.vis.visit_ext(size ? &ext.front() : nullptr, size);
             }
         )
@@ -711,7 +712,7 @@ const auto mp_object_def =
             [](auto& ctx){
                 auto& app_specific = x3::get<tag_app_specific>(ctx).get();
                 auto const& ext = _attr(ctx);
-                std::size_t size = std::distance(ext.begin(), ext.end());
+                auto size = static_cast<uint32_t>(std::distance(ext.begin(), ext.end()));
                 app_specific.vis.visit_ext(size ? &ext.front() : nullptr, size);
             }
         )
@@ -735,7 +736,7 @@ const auto mp_object_def =
             [](auto& ctx){
                 auto& app_specific = x3::get<tag_app_specific>(ctx).get();
                 auto const& ext = _attr(ctx);
-                std::size_t size = std::distance(ext.begin(), ext.end());
+                auto size = static_cast<uint32_t>(std::distance(ext.begin(), ext.end()));
                 app_specific.vis.visit_ext(size ? &ext.front() : nullptr, size);
             }
         )
@@ -759,7 +760,7 @@ const auto mp_object_def =
             [](auto& ctx){
                 auto& app_specific = x3::get<tag_app_specific>(ctx).get();
                 auto const& ext = _attr(ctx);
-                std::size_t size = std::distance(ext.begin(), ext.end());
+                auto size = static_cast<uint32_t>(std::distance(ext.begin(), ext.end()));
                 app_specific.vis.visit_ext(size ? &ext.front() : nullptr, size);
             }
         )
@@ -771,6 +772,7 @@ const auto array_item_def =
             [](auto& ctx){
                 auto& app_specific = x3::get<tag_app_specific>(ctx).get();
                 app_specific.vis.start_array_item();
+
                 _pass(ctx) = true;
             }
         )

include/msgpack/v3/adaptor/int_decl.hpp

@@ -30,7 +30,7 @@ struct is_signed;
 
 
 template <bool Signed>
-struct object_char_sign;
+struct object_sign;
 
 //using v2::type::detail::convert_integer_sign;
 

include/msgpack/v3/parse.hpp

@@ -63,29 +63,29 @@ private:
         load<T>(size, load_pos);
         if (size == 0) {
             if (!sv(size)) {
-                off = m_current - m_start;
+                off = static_cast<std::size_t>(m_current - m_start);
                 return PARSE_STOP_VISITOR;
             }
             if (!ev()) {
-                off = m_current - m_start;
+                off = static_cast<std::size_t>(m_current - m_start);
                 return PARSE_STOP_VISITOR;
             }
             parse_return ret = m_stack.consume(holder(), m_current);
             ++m_current;
             if (ret != PARSE_CONTINUE) {
-                off = m_current - m_start;
+                off = static_cast<std::size_t>(m_current - m_start);
                 return ret;
             }
         }
         else {
             if (!sv(size)) {
-                off = m_current - m_start;
+                off = static_cast<std::size_t>(m_current - m_start);
                 return PARSE_STOP_VISITOR;
             }
             parse_return ret = m_stack.push(holder(), sv.type(), static_cast<uint32_t>(size));
             ++m_current;
             if (ret != PARSE_CONTINUE) {
-                off = m_current - m_start;
+                off = static_cast<std::size_t>(m_current - m_start);
                 return ret;
             }
         }
@@ -95,13 +95,13 @@ private:
 
     parse_return after_visit_proc(bool visit_result, std::size_t& off) {
         if (!visit_result) {
-            off = m_current - m_start;
+            off = static_cast<std::size_t>(m_current - m_start);
             return PARSE_STOP_VISITOR;
         }
         parse_return ret = m_stack.consume(holder(), m_current);
         ++m_current;
         if (ret != PARSE_CONTINUE) {
-            off = m_current - m_start;
+            off = static_cast<std::size_t>(m_current - m_start);
         }
         m_cs = MSGPACK_CS_HEADER;
         return ret;
@@ -250,10 +250,8 @@ inline parse_return context<VisitorHolder>::execute(const char* data, std::size_
     const char* const pe = data + len;
     const char* n = MSGPACK_NULLPTR;
 
-    msgpack::object obj;
-
     if(m_current == pe) {
-        off = m_current - m_start;
+        off = static_cast<std::size_t>(m_current - m_start);
         return PARSE_CONTINUE;
     }
     bool fixed_trail_again = false;
@@ -335,7 +333,7 @@ inline parse_return context<VisitorHolder>::execute(const char* data, std::size_
                 parse_return upr = after_visit_proc(visret, off);
                 if (upr != PARSE_CONTINUE) return upr;
             } else {
-                off = m_current - m_start;
+                off = static_cast<std::size_t>(m_current - m_start);
                 holder().visitor().parse_error(off - 1, off);
                 return PARSE_PARSE_ERROR;
             }
@@ -347,7 +345,7 @@ inline parse_return context<VisitorHolder>::execute(const char* data, std::size_
                 fixed_trail_again = false;
             }
             if(static_cast<std::size_t>(pe - m_current) < m_trail) {
-                off = m_current - m_start;
+                off = static_cast<std::size_t>(m_current - m_start);
                 return PARSE_CONTINUE;
             }
             n = m_current;
@@ -617,14 +615,14 @@ inline parse_return context<VisitorHolder>::execute(const char* data, std::size_
                 if (ret != PARSE_CONTINUE) return ret;
             } break;
             default:
-                off = m_current - m_start;
-                holder().visitor().parse_error(n - m_start - 1, n - m_start);
+                off = static_cast<std::size_t>(m_current - m_start);
+                holder().visitor().parse_error(static_cast<std::size_t>(n - m_start - 1), static_cast<std::size_t>(n - m_start));
                 return PARSE_PARSE_ERROR;
             }
         }
     } while(m_current != pe);
 
-    off = m_current - m_start;
+    off = static_cast<std::size_t>(m_current - m_start);
     return PARSE_CONTINUE;
 }
 

include/msgpack/version_master.h

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

include/msgpack/vrefbuffer.h

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

include/msgpack/zbuffer.h

@@ -100,8 +100,9 @@ static inline void msgpack_zbuffer_free(msgpack_zbuffer* zbuf)
 
 static inline bool msgpack_zbuffer_expand(msgpack_zbuffer* zbuf)
 {
-    size_t used = (char*)zbuf->stream.next_out - zbuf->data;
+    size_t used = static_cast<size_t>(reinterpret_cast<char*>(zbuf->stream.next_out) - zbuf->data);
     size_t csize = used + zbuf->stream.avail_out;
+
     size_t nsize = (csize == 0) ? zbuf->init_size : csize * 2;
 
     char* tmp = (char*)realloc(zbuf->data, nsize);
@@ -111,7 +112,7 @@ static inline bool msgpack_zbuffer_expand(msgpack_zbuffer* zbuf)
 
     zbuf->data = tmp;
     zbuf->stream.next_out  = (Bytef*)(tmp + used);
-    zbuf->stream.avail_out = nsize - used;
+    zbuf->stream.avail_out = static_cast<uInt>(nsize - used);
 
     return true;
 }
@@ -121,7 +122,7 @@ static inline int msgpack_zbuffer_write(void* data, const char* buf, size_t len)
     msgpack_zbuffer* zbuf = (msgpack_zbuffer*)data;
 
     zbuf->stream.next_in = (Bytef*)buf;
-    zbuf->stream.avail_in = len;
+    zbuf->stream.avail_in = static_cast<uInt>(len);
 
     while(zbuf->stream.avail_in > 0) {
         if(zbuf->stream.avail_out < MSGPACK_ZBUFFER_RESERVE_SIZE) {
@@ -145,6 +146,7 @@ static inline char* msgpack_zbuffer_flush(msgpack_zbuffer* zbuf)
         case Z_STREAM_END:
             return zbuf->data;
         case Z_OK:
+        case Z_BUF_ERROR:
             if(!msgpack_zbuffer_expand(zbuf)) {
                 return NULL;
             }
@@ -162,12 +164,12 @@ static inline const char* msgpack_zbuffer_data(const msgpack_zbuffer* zbuf)
 
 static inline size_t msgpack_zbuffer_size(const msgpack_zbuffer* zbuf)
 {
-    return (char*)zbuf->stream.next_out - zbuf->data;
+    return static_cast<size_t>(reinterpret_cast<char*>(zbuf->stream.next_out) - zbuf->data);
 }
 
 static inline void msgpack_zbuffer_reset_buffer(msgpack_zbuffer* zbuf)
 {
-    zbuf->stream.avail_out += (char*)zbuf->stream.next_out - zbuf->data;
+    zbuf->stream.avail_out += (uInt)((char*)zbuf->stream.next_out - zbuf->data);
     zbuf->stream.next_out = (Bytef*)zbuf->data;
 }
 
@@ -197,4 +199,3 @@ static inline char* msgpack_zbuffer_release_buffer(msgpack_zbuffer* zbuf)
 #endif
 
 #endif /* msgpack/zbuffer.h */
-

include/msgpack/zone.h

@@ -111,7 +111,7 @@ static inline void* msgpack_zone_malloc(msgpack_zone* zone, size_t size)
                 zone->chunk_list.ptr + (MSGPACK_ZONE_ALIGN - 1)
             ) / MSGPACK_ZONE_ALIGN * MSGPACK_ZONE_ALIGN
         );
-    size_t adjusted_size = size + (aligned - zone->chunk_list.ptr);
+    size_t adjusted_size = size + (size_t)(aligned - zone->chunk_list.ptr);
     if(zone->chunk_list.free >= adjusted_size) {
         zone->chunk_list.free -= adjusted_size;
         zone->chunk_list.ptr  += adjusted_size;

msgpack-config.cmake.in

@@ -6,8 +6,9 @@
 #
 # ::
 #
-#   msgpackc-static
 #   msgpackc
+#   msgpackc-cxx
+#   msgpackc-static (optional)
 #
 
 @PACKAGE_INIT@
@@ -16,8 +17,4 @@ 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

@@ -7,9 +7,15 @@
  *    (See accompanying file LICENSE_1_0.txt or copy at
  *    http://www.boost.org/LICENSE_1_0.txt)
  */
+#if defined(_KERNEL_MODE)
+#  undef  _NO_CRT_STDIO_INLINE
+#  define _NO_CRT_STDIO_INLINE
+#endif
+
 #include "msgpack/object.h"
 #include "msgpack/pack.h"
 #include <ctype.h>
+
 #include <stdio.h>
 #include <string.h>
 
@@ -25,6 +31,10 @@
 #include <inttypes.h>
 #endif
 
+#if defined(_KERNEL_MODE)
+#  undef  snprintf
+#  define snprintf _snprintf
+#endif
 
 int msgpack_pack_object(msgpack_packer* pk, msgpack_object d)
 {
@@ -115,6 +125,7 @@ int msgpack_pack_object(msgpack_packer* pk, msgpack_object d)
     }
 }
 
+#if !defined(_KERNEL_MODE)
 
 static void msgpack_object_bin_print(FILE* out, const char *ptr, size_t size)
 {
@@ -130,35 +141,6 @@ static void msgpack_object_bin_print(FILE* out, const char *ptr, size_t size)
     }
 }
 
-static int msgpack_object_bin_print_buffer(char *buffer, size_t buffer_size, const char *ptr, size_t size)
-{
-    size_t i;
-    char *aux_buffer = buffer;
-    size_t aux_buffer_size = buffer_size;
-    int ret;
-
-    for (i = 0; i < size; ++i) {
-        if (ptr[i] == '"') {
-            ret = snprintf(aux_buffer, aux_buffer_size, "\\\"");
-            aux_buffer = aux_buffer + ret;
-            aux_buffer_size = aux_buffer_size - ret;
-        } else if (isprint((unsigned char)ptr[i])) {
-            if (aux_buffer_size > 0) {
-                memcpy(aux_buffer, ptr + i, 1);
-                aux_buffer = aux_buffer + 1;
-                aux_buffer_size = aux_buffer_size - 1;
-            }
-        } else {
-            ret = snprintf(aux_buffer, aux_buffer_size, "\\x%02x", (unsigned char)ptr[i]);
-            aux_buffer = aux_buffer + ret;
-            aux_buffer_size = aux_buffer_size - ret;
-        }
-    }
-
-    return buffer_size - aux_buffer_size;
-}
-
-
 void msgpack_object_print(FILE* out, msgpack_object o)
 {
     switch(o.type) {
@@ -270,6 +252,38 @@ void msgpack_object_print(FILE* out, msgpack_object o)
     }
 }
 
+#endif
+
+#define MSGPACK_CHECKED_CALL(ret, func, aux_buffer, aux_buffer_size, ...) \
+    ret = func(aux_buffer, aux_buffer_size, __VA_ARGS__);                 \
+    if (ret <= 0 || ret >= (int)aux_buffer_size) return 0;                \
+    aux_buffer = aux_buffer + ret;                                        \
+    aux_buffer_size = aux_buffer_size - ret                               \
+
+static int msgpack_object_bin_print_buffer(char *buffer, size_t buffer_size, const char *ptr, size_t size)
+{
+    size_t i;
+    char *aux_buffer = buffer;
+    size_t aux_buffer_size = buffer_size;
+    int ret;
+
+    for (i = 0; i < size; ++i) {
+        if (ptr[i] == '"') {
+            MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\\\"");
+        } else if (isprint((unsigned char)ptr[i])) {
+            if (aux_buffer_size > 0) {
+                memcpy(aux_buffer, ptr + i, 1);
+                aux_buffer = aux_buffer + 1;
+                aux_buffer_size = aux_buffer_size - 1;
+            }
+        } else {
+            MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\\x%02x", (unsigned char)ptr[i]);
+        }
+    }
+
+    return (int)(buffer_size - aux_buffer_size);
+}
+
 int msgpack_object_print_buffer(char *buffer, size_t buffer_size, msgpack_object o)
 {
     char *aux_buffer = buffer;
@@ -277,197 +291,118 @@ int msgpack_object_print_buffer(char *buffer, size_t buffer_size, msgpack_object
     int ret;
     switch(o.type) {
     case MSGPACK_OBJECT_NIL:
-        ret = snprintf(aux_buffer, aux_buffer_size, "nil");
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "nil");
         break;
 
     case MSGPACK_OBJECT_BOOLEAN:
-        ret = snprintf(aux_buffer, aux_buffer_size, (o.via.boolean ? "true" : "false"));
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, (o.via.boolean ? "true" : "false"));
         break;
 
     case MSGPACK_OBJECT_POSITIVE_INTEGER:
 #if defined(PRIu64)
-        ret = snprintf(aux_buffer, aux_buffer_size, "%" PRIu64, o.via.u64);
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%" PRIu64, o.via.u64);
 #else
         if (o.via.u64 > ULONG_MAX) {
-            ret = snprintf(aux_buffer, aux_buffer_size, "over 4294967295");
-            aux_buffer = aux_buffer + ret;
-            aux_buffer_size = aux_buffer_size - ret;
+            MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "over 4294967295");
         } else {
-            ret = snprintf(aux_buffer, aux_buffer_size, "%lu", (unsigned long)o.via.u64);
-            aux_buffer = aux_buffer + ret;
-            aux_buffer_size = aux_buffer_size - ret;
+            MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%lu", (unsigned long)o.via.u64);
         }
 #endif
         break;
 
     case MSGPACK_OBJECT_NEGATIVE_INTEGER:
 #if defined(PRIi64)
-        ret = snprintf(aux_buffer, aux_buffer_size, "%" PRIi64, o.via.i64);
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%" PRIi64, o.via.i64);
 #else
         if (o.via.i64 > LONG_MAX) {
-            ret = snprintf(aux_buffer, aux_buffer_size, "over +2147483647");
-            aux_buffer = aux_buffer + ret;
-            aux_buffer_size = aux_buffer_size - ret;
+            MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "over +2147483647");
         } else if (o.via.i64 < LONG_MIN) {
-            ret = snprintf(aux_buffer, aux_buffer_size, "under -2147483648");
-            aux_buffer = aux_buffer + ret;
-            aux_buffer_size = aux_buffer_size - ret;
+            MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "under -2147483648");
         } else {
-            ret = snprintf(aux_buffer, aux_buffer_size, "%ld", (signed long)o.via.i64);
-            aux_buffer = aux_buffer + ret;
-            aux_buffer_size = aux_buffer_size - ret;
+            MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%ld", (signed long)o.via.i64);
         }
 #endif
         break;
 
     case MSGPACK_OBJECT_FLOAT32:
     case MSGPACK_OBJECT_FLOAT64:
-        ret = snprintf(aux_buffer, aux_buffer_size, "%f", o.via.f64);
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%f", o.via.f64);
         break;
 
     case MSGPACK_OBJECT_STR:
-        ret = snprintf(aux_buffer, aux_buffer_size, "\"");
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
-        ret = snprintf(aux_buffer, aux_buffer_size, "%.*s", (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, "\"");
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\"");
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%.*s", (int)o.via.str.size, o.via.str.ptr);
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\"");
         break;
 
     case MSGPACK_OBJECT_BIN:
-        ret = snprintf(aux_buffer, aux_buffer_size, "\"");
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
-
-        ret = msgpack_object_bin_print_buffer(aux_buffer, aux_buffer_size, o.via.bin.ptr, o.via.bin.size);
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
-
-        ret = snprintf(aux_buffer, aux_buffer_size, "\"");
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\"");
+        MSGPACK_CHECKED_CALL(ret, msgpack_object_bin_print_buffer, aux_buffer, aux_buffer_size, o.via.bin.ptr, o.via.bin.size);
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\"");
         break;
 
     case MSGPACK_OBJECT_EXT:
 #if defined(PRIi8)
-        ret = snprintf(aux_buffer, aux_buffer_size, "(ext: %" PRIi8 ")", o.via.ext.type);
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "(ext: %" PRIi8 ")", o.via.ext.type);
 #else
-        ret = snprintf(aux_buffer, aux_buffer_size, "(ext: %d)", (int)o.via.ext.type);
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "(ext: %d)", (int)o.via.ext.type);
 #endif
-        ret = snprintf(aux_buffer, aux_buffer_size, "\"");
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
-
-        ret = msgpack_object_bin_print_buffer(aux_buffer, aux_buffer_size, o.via.ext.ptr, o.via.ext.size);
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
-
-        ret = snprintf(aux_buffer, aux_buffer_size, "\"");
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\"");
+        MSGPACK_CHECKED_CALL(ret, msgpack_object_bin_print_buffer, aux_buffer, aux_buffer_size, o.via.ext.ptr, o.via.ext.size);
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\"");
         break;
 
     case MSGPACK_OBJECT_ARRAY:
-        ret = snprintf(aux_buffer, aux_buffer_size, "[");
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "[");
         if(o.via.array.size != 0) {
             msgpack_object* p = o.via.array.ptr;
             msgpack_object* const pend = o.via.array.ptr + o.via.array.size;
-            ret = msgpack_object_print_buffer(aux_buffer, aux_buffer_size, *p);
-            aux_buffer = aux_buffer + ret;
-            aux_buffer_size = aux_buffer_size - ret;
+            MSGPACK_CHECKED_CALL(ret, msgpack_object_print_buffer, aux_buffer, aux_buffer_size, *p);
             ++p;
             for(; p < pend; ++p) {
-                ret = snprintf(aux_buffer, aux_buffer_size, ", ");
-                aux_buffer = aux_buffer + ret;
-                aux_buffer_size = aux_buffer_size - ret;
-                ret = msgpack_object_print_buffer(aux_buffer, aux_buffer_size, *p);
-                aux_buffer = aux_buffer + ret;
-                aux_buffer_size = aux_buffer_size - ret;
+                MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, ", ");
+                MSGPACK_CHECKED_CALL(ret, msgpack_object_print_buffer, aux_buffer, aux_buffer_size, *p);
             }
         }
-        ret = snprintf(aux_buffer, aux_buffer_size, "]");
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "]");
         break;
 
     case MSGPACK_OBJECT_MAP:
-        ret = snprintf(aux_buffer, aux_buffer_size, "{");
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "{");
         if(o.via.map.size != 0) {
             msgpack_object_kv* p = o.via.map.ptr;
             msgpack_object_kv* const pend = o.via.map.ptr + o.via.map.size;
-            ret = msgpack_object_print_buffer(aux_buffer, aux_buffer_size, p->key);
-            aux_buffer = aux_buffer + ret;
-            aux_buffer_size = aux_buffer_size - ret;
-            ret = snprintf(aux_buffer, aux_buffer_size, "=>");
-            aux_buffer = aux_buffer + ret;
-            aux_buffer_size = aux_buffer_size - ret;
-            ret = msgpack_object_print_buffer(aux_buffer, aux_buffer_size, p->val);
-            aux_buffer = aux_buffer + ret;
-            aux_buffer_size = aux_buffer_size - ret;
+            MSGPACK_CHECKED_CALL(ret, msgpack_object_print_buffer, aux_buffer, aux_buffer_size, p->key);
+            MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "=>");
+            MSGPACK_CHECKED_CALL(ret, msgpack_object_print_buffer, aux_buffer, aux_buffer_size, p->val);
             ++p;
             for(; p < pend; ++p) {
-                ret = snprintf(aux_buffer, aux_buffer_size, ", ");
-                aux_buffer = aux_buffer + ret;
-                aux_buffer_size = aux_buffer_size - ret;
-                ret = msgpack_object_print_buffer(aux_buffer, aux_buffer_size, p->key);
-                aux_buffer = aux_buffer + ret;
-                aux_buffer_size = aux_buffer_size - ret;
-                ret = snprintf(aux_buffer, aux_buffer_size, "=>");
-                aux_buffer = aux_buffer + ret;
-                aux_buffer_size = aux_buffer_size - ret;
-                ret = msgpack_object_print_buffer(aux_buffer, aux_buffer_size, p->val);
-                aux_buffer = aux_buffer + ret;
-                aux_buffer_size = aux_buffer_size - ret;
+                MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, ", ");
+                MSGPACK_CHECKED_CALL(ret, msgpack_object_print_buffer, aux_buffer, aux_buffer_size, p->key);
+                MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "=>");
+                MSGPACK_CHECKED_CALL(ret, msgpack_object_print_buffer, aux_buffer, aux_buffer_size, p->val);
             }
         }
-        ret = snprintf(aux_buffer, aux_buffer_size, "}");
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "}");
         break;
 
     default:
     // FIXME
 #if defined(PRIu64)
-        ret = snprintf(aux_buffer, aux_buffer_size, "#<UNKNOWN %i %" PRIu64 ">", o.type, o.via.u64);
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "#<UNKNOWN %i %" PRIu64 ">", o.type, o.via.u64);
 #else
         if (o.via.u64 > ULONG_MAX) {
-            ret = snprintf(aux_buffer, aux_buffer_size, "#<UNKNOWN %i over 4294967295>", o.type);
-            aux_buffer = aux_buffer + ret;
-            aux_buffer_size = aux_buffer_size - ret;
+            MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "#<UNKNOWN %i over 4294967295>", o.type);
         } else {
-            ret = snprintf(aux_buffer, aux_buffer_size, "#<UNKNOWN %i %lu>", o.type, (unsigned long)o.via.u64);
-            aux_buffer = aux_buffer + ret;
-            aux_buffer_size = aux_buffer_size - ret;
+            MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "#<UNKNOWN %i %lu>", o.type, (unsigned long)o.via.u64);
         }
 #endif
     }
 
-    return buffer_size - aux_buffer_size;
+    return (int)(buffer_size - aux_buffer_size);
 }
 
+#undef MSGPACK_CHECKED_CALL
 
 bool msgpack_object_equal(const msgpack_object x, const msgpack_object y)
 {

src/unpack.c

@@ -18,7 +18,7 @@
 
 
 typedef struct {
-    msgpack_zone* z;
+    msgpack_zone** z;
     bool referenced;
 } unpack_user;
 
@@ -189,15 +189,30 @@ static inline int template_callback_false(unpack_user* u, msgpack_object* o)
 
 static inline int template_callback_array(unpack_user* u, unsigned int n, msgpack_object* o)
 {
-    unsigned int size;
+    size_t size;
+    // Let's leverage the fact that sizeof(msgpack_object) is a compile time constant
+    // to check for int overflows.
+    // Note - while n is constrained to 32-bit, the product of n * sizeof(msgpack_object)
+    // might not be constrained to 4GB on 64-bit systems
+#if SIZE_MAX == UINT_MAX
+    if (n > SIZE_MAX/sizeof(msgpack_object))
+        return MSGPACK_UNPACK_NOMEM_ERROR;
+#endif
+
     o->type = MSGPACK_OBJECT_ARRAY;
     o->via.array.size = 0;
-    size = n*sizeof(msgpack_object);
-    if (size / sizeof(msgpack_object) != n) {
-        // integer overflow
-        return MSGPACK_UNPACK_NOMEM_ERROR;
+
+    size = n * sizeof(msgpack_object);
+
+    if (*u->z == NULL) {
+        *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
+        if(*u->z == NULL) {
+            return MSGPACK_UNPACK_NOMEM_ERROR;
+        }
     }
-    o->via.array.ptr = (msgpack_object*)msgpack_zone_malloc(u->z, size);
+
+    // Unsure whether size = 0 should be an error, and if so, what to return
+    o->via.array.ptr = (msgpack_object*)msgpack_zone_malloc(*u->z, size);
     if(o->via.array.ptr == NULL) { return MSGPACK_UNPACK_NOMEM_ERROR; }
     return 0;
 }
@@ -216,15 +231,32 @@ static inline int template_callback_array_item(unpack_user* u, msgpack_object* c
 
 static inline int template_callback_map(unpack_user* u, unsigned int n, msgpack_object* o)
 {
-    unsigned int size;
+    size_t size;
+    // Let's leverage the fact that sizeof(msgpack_object_kv) is a compile time constant
+    // to check for int overflows
+    // Note - while n is constrained to 32-bit, the product of n * sizeof(msgpack_object)
+    // might not be constrained to 4GB on 64-bit systems
+
+    // Note - this will always be false on 64-bit systems
+#if SIZE_MAX == UINT_MAX
+    if (n > SIZE_MAX/sizeof(msgpack_object_kv))
+        return MSGPACK_UNPACK_NOMEM_ERROR;
+#endif
+
     o->type = MSGPACK_OBJECT_MAP;
     o->via.map.size = 0;
-    size = n*sizeof(msgpack_object_kv);
-    if (size / sizeof(msgpack_object_kv) != n) {
-        // integer overflow
-        return MSGPACK_UNPACK_NOMEM_ERROR;
+
+    size = n * sizeof(msgpack_object_kv);
+
+    if (*u->z == NULL) {
+        *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
+        if(*u->z == NULL) {
+            return MSGPACK_UNPACK_NOMEM_ERROR;
+        }
     }
-    o->via.map.ptr = (msgpack_object_kv*)msgpack_zone_malloc(u->z, size);
+
+    // Should size = 0 be an error? If so, what error to return?
+    o->via.map.ptr = (msgpack_object_kv*)msgpack_zone_malloc(*u->z, size);
     if(o->via.map.ptr == NULL) { return MSGPACK_UNPACK_NOMEM_ERROR; }
     return 0;
 }
@@ -245,8 +277,13 @@ static inline int template_callback_map_item(unpack_user* u, msgpack_object* c,
 
 static inline int template_callback_str(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o)
 {
-    MSGPACK_UNUSED(u);
     MSGPACK_UNUSED(b);
+    if (*u->z == NULL) {
+        *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
+        if(*u->z == NULL) {
+            return MSGPACK_UNPACK_NOMEM_ERROR;
+        }
+    }
     o->type = MSGPACK_OBJECT_STR;
     o->via.str.ptr = p;
     o->via.str.size = l;
@@ -256,8 +293,13 @@ static inline int template_callback_str(unpack_user* u, const char* b, const cha
 
 static inline int template_callback_bin(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o)
 {
-    MSGPACK_UNUSED(u);
     MSGPACK_UNUSED(b);
+    if (*u->z == NULL) {
+        *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
+        if(*u->z == NULL) {
+            return MSGPACK_UNPACK_NOMEM_ERROR;
+        }
+    }
     o->type = MSGPACK_OBJECT_BIN;
     o->via.bin.ptr = p;
     o->via.bin.size = l;
@@ -267,11 +309,16 @@ static inline int template_callback_bin(unpack_user* u, const char* b, const cha
 
 static inline int template_callback_ext(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o)
 {
+    MSGPACK_UNUSED(b);
     if (l == 0) {
         return MSGPACK_UNPACK_PARSE_ERROR;
     }
-    MSGPACK_UNUSED(u);
-    MSGPACK_UNUSED(b);
+    if (*u->z == NULL) {
+        *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
+        if(*u->z == NULL) {
+            return MSGPACK_UNPACK_NOMEM_ERROR;
+        }
+    }
     o->type = MSGPACK_OBJECT_EXT;
     o->via.ext.type = *p;
     o->via.ext.ptr = p + 1;
@@ -317,7 +364,6 @@ bool msgpack_unpacker_init(msgpack_unpacker* mpac, size_t initial_buffer_size)
 {
     char* buffer;
     void* ctx;
-    msgpack_zone* z;
 
     if(initial_buffer_size < COUNTER_SIZE) {
         initial_buffer_size = COUNTER_SIZE;
@@ -334,26 +380,19 @@ bool msgpack_unpacker_init(msgpack_unpacker* mpac, size_t initial_buffer_size)
         return false;
     }
 
-    z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
-    if(z == NULL) {
-        free(ctx);
-        free(buffer);
-        return false;
-    }
-
     mpac->buffer = buffer;
     mpac->used = COUNTER_SIZE;
     mpac->free = initial_buffer_size - mpac->used;
     mpac->off = COUNTER_SIZE;
     mpac->parsed = 0;
     mpac->initial_buffer_size = initial_buffer_size;
-    mpac->z = z;
+    mpac->z = NULL;
     mpac->ctx = ctx;
 
     init_count(mpac->buffer);
 
     template_init(CTX_CAST(mpac->ctx));
-    CTX_CAST(mpac->ctx)->user.z = mpac->z;
+    CTX_CAST(mpac->ctx)->user.z = &mpac->z;
     CTX_CAST(mpac->ctx)->user.referenced = false;
 
     return true;
@@ -480,21 +519,15 @@ msgpack_object msgpack_unpacker_data(msgpack_unpacker* mpac)
 
 msgpack_zone* msgpack_unpacker_release_zone(msgpack_unpacker* mpac)
 {
-    msgpack_zone* r;
-    msgpack_zone* old;
+    msgpack_zone* old = mpac->z;
 
+    if (old == NULL) return NULL;
     if(!msgpack_unpacker_flush_zone(mpac)) {
         return NULL;
     }
 
-    r = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
-    if(r == NULL) {
-        return NULL;
-    }
-
-    old = mpac->z;
-    mpac->z = r;
-    CTX_CAST(mpac->ctx)->user.z = mpac->z;
+    mpac->z = NULL;
+    CTX_CAST(mpac->ctx)->user.z = &mpac->z;
 
     return old;
 }
@@ -596,7 +629,7 @@ msgpack_unpack(const char* data, size_t len, size_t* off,
         template_context ctx;
         template_init(&ctx);
 
-        ctx.user.z = result_zone;
+        ctx.user.z = &result_zone;
         ctx.user.referenced = false;
 
         e = template_execute(&ctx, data, len, &noff);
@@ -633,19 +666,12 @@ msgpack_unpack_next(msgpack_unpacked* result,
         return MSGPACK_UNPACK_CONTINUE;
     }
 
-    if (!result->zone) {
-        result->zone = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
-    }
-
-    if (!result->zone) {
-        return MSGPACK_UNPACK_NOMEM_ERROR;
-    }
-    else {
+    {
         int e;
         template_context ctx;
         template_init(&ctx);
 
-        ctx.user.z = result->zone;
+        ctx.user.z = &result->zone;
         ctx.user.referenced = false;
 
         e = template_execute(&ctx, data, len, &noff);

test/CMakeLists.txt

@@ -89,7 +89,7 @@ FOREACH (source_file ${check_PROGRAMS})
     )
     ADD_TEST (${source_file_we} ${source_file_we})
     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")
+        SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra -Wconversion")
     ENDIF ()
     IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
         SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")

test/array_ref.cpp

@@ -3,8 +3,13 @@
 #include <string>
 #include <sstream>
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -20,8 +25,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_char)
     std::stringstream ss;
     msgpack::pack(ss, ar1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
     std::vector<char> v2;
     msgpack::type::array_ref<std::vector<char> > ar2(v2);
@@ -42,8 +48,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_char_const)
     std::stringstream ss;
     msgpack::pack(ss, ar1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
     std::vector<char> v2;
     msgpack::type::array_ref<std::vector<char> > ar2(v2);
@@ -62,8 +69,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_unsigned_char)
     std::stringstream ss;
     msgpack::pack(ss, ar1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
     std::vector<unsigned char> v2;
     msgpack::type::array_ref<std::vector<unsigned char> > ar2(v2);
@@ -84,8 +92,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_unsigned_char_const)
     std::stringstream ss;
     msgpack::pack(ss, ar1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
     std::vector<unsigned char> v2;
     msgpack::type::array_ref<std::vector<unsigned char> > ar2(v2);
@@ -179,8 +188,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_char)
     std::stringstream ss;
     msgpack::pack(ss, ar1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
     std::array<char, 3> v2;
     msgpack::type::array_ref<std::array<char, 3> > ar2(v2);
@@ -198,8 +208,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_char_const)
     std::stringstream ss;
     msgpack::pack(ss, ar1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
     std::array<char, 3> v2;
     msgpack::type::array_ref<std::array<char, 3> > ar2(v2);
@@ -215,8 +226,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_unsigned_char)
     std::stringstream ss;
     msgpack::pack(ss, ar1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
     std::array<unsigned char, 3> v2;
     msgpack::type::array_ref<std::array<unsigned char, 3> > ar2(v2);
@@ -234,8 +246,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_unsigned_char_const)
     std::stringstream ss;
     msgpack::pack(ss, ar1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
     std::array<unsigned char, 3> v2;
     msgpack::type::array_ref<std::array<unsigned char, 3> > ar2(v2);

test/boost_fusion.cpp

@@ -3,8 +3,13 @@
 #include <iterator>
 #include <cmath>
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -30,8 +35,9 @@ TEST(MSGPACK_BOOST, fusion_pack_unpack_convert)
     val1.f1 = 42;
     val1.f2 = 123.45;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     mystruct val2 = oh.get().as<mystruct>();
     EXPECT_TRUE(val1.f1 == val2.f1);
     EXPECT_TRUE(fabs(val2.f2 - val1.f2) <= kEPS);
@@ -151,8 +157,9 @@ TEST(MSGPACK_BOOST, pack_convert_no_def_con)
     std::stringstream ss;
     mystruct_no_def_con val1(no_def_con1(1), no_def_con2(2), no_def_con1(3));
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     mystruct_no_def_con val2 = oh.get().as<mystruct_no_def_con>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -202,8 +209,9 @@ TEST(MSGPACK_BOOST, pack_convert_no_def_con_def_con)
     std::stringstream ss;
     mystruct_no_def_con_def_con val1(no_def_con1(1), no_def_con2(2), 3);
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     mystruct_no_def_con_def_con val2 = oh.get().as<mystruct_no_def_con_def_con>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -219,8 +227,9 @@ TEST(MSGPACK_BOOST, fusion_pack_unpack_convert_pair)
     std::stringstream ss;
     std::pair<bool, int> val1(false, 42);
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), 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);
@@ -235,8 +244,9 @@ TEST(MSGPACK_BOOST, fusion_pack_unpack_convert_tuple)
     std::stringstream ss;
     std::tuple<bool, int> val1(false, 42);
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::tuple<bool, int> val2 = oh.get().as<std::tuple<bool, int> >();
     EXPECT_TRUE(val1 == val2);
 }

test/boost_optional.cpp

@@ -1,8 +1,15 @@
 #include <msgpack.hpp>
 #include <sstream>
 #include <iterator>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -14,8 +21,9 @@ TEST(MSGPACK_BOOST, pack_convert_nil)
     std::stringstream ss;
     boost::optional<int> val1;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     boost::optional<int> val2 = oh.get().as<boost::optional<int> >();
     EXPECT_TRUE(val1 == val2);
 }
@@ -25,8 +33,9 @@ TEST(MSGPACK_BOOST, pack_convert_int)
     std::stringstream ss;
     boost::optional<int> val1 = 1;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     boost::optional<int> val2 = oh.get().as<boost::optional<int> >();
     EXPECT_TRUE(val1 == val2);
 }
@@ -42,8 +51,9 @@ TEST(MSGPACK_BOOST, pack_convert_vector)
     v.push_back(3);
     val1 = v;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     ovi_t  val2 = oh.get().as<ovi_t>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -57,8 +67,9 @@ TEST(MSGPACK_BOOST, pack_convert_vector_optional)
     val1[0] = 1;
     val1[2] = 3;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     voi_t  val2 = oh.get().as<voi_t>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -164,8 +175,9 @@ TEST(MSGPACK_BOOST, pack_convert_no_def_con)
     std::stringstream ss;
     boost::optional<no_def_con> val1 = no_def_con(1);
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     boost::optional<no_def_con> val2 = oh.get().as<boost::optional<no_def_con>>();
     EXPECT_TRUE(val1 == val2);
 }

test/boost_string_ref.cpp

@@ -1,8 +1,15 @@
 #include <msgpack.hpp>
 #include <sstream>
 #include <iterator>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -19,7 +26,8 @@ TEST(MSGPACK_BOOST, pack_convert_string_ref)
     msgpack::pack(ss, val1);
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::unpack(oh, str.data(), str.size());
     boost::string_ref val2 = oh.get().as<boost::string_ref>();
     EXPECT_TRUE(val1 == val2);
 }

test/boost_string_view.cpp

@@ -1,8 +1,14 @@
 #include <msgpack.hpp>
 #include <sstream>
 #include <iterator>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -19,7 +25,8 @@ TEST(MSGPACK_BOOST, pack_convert_string_view)
     msgpack::pack(ss, val1);
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::unpack(oh, str.data(), str.size());
     boost::string_view val2 = oh.get().as<boost::string_view>();
     EXPECT_TRUE(val1 == val2);
 }

test/boost_variant.cpp

@@ -2,8 +2,14 @@
 #include <msgpack.hpp>
 #include <sstream>
 #include <iterator>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -21,8 +27,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_nil)
     EXPECT_TRUE(val1.is_nil());
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_nil());
     EXPECT_NO_THROW(boost::get<msgpack::type::nil_t>(val2));
@@ -59,8 +66,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_nil_default)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_nil());
     EXPECT_NO_THROW(boost::get<msgpack::type::nil_t>(val2));
@@ -98,8 +106,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_bool)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_bool());
     EXPECT_TRUE(val2.as_bool());
@@ -151,8 +160,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_positive_integer)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_uint64_t());
     EXPECT_EQ(val2.as_uint64_t(), 123U);
@@ -198,8 +208,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_negative_integer)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_int64_t());
     EXPECT_EQ(val2.as_int64_t(), -123);
@@ -245,8 +256,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_float)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_double());
     EXPECT_TRUE(fabs(12.34 - val2.as_double()) <= kEPS);
@@ -292,8 +304,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_str)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_string());
     EXPECT_EQ(val2.as_string(), "ABC");
@@ -354,8 +367,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_bin)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_vector_char());
     EXPECT_EQ(val2.as_vector_char(), v);
@@ -393,10 +407,10 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_raw_ref)
     v.push_back('a');
     v.push_back('b');
     v.push_back('c');
-    msgpack::type::raw_ref rr(&v.front(), v.size());
+    msgpack::type::raw_ref rr(&v.front(), static_cast<uint32_t>(v.size()));
     msgpack::type::variant val1 = rr;
     EXPECT_TRUE(val1.is_raw_ref());
-    EXPECT_EQ(val1.as_raw_ref(), msgpack::type::raw_ref(&v.front(), v.size()));
+    EXPECT_EQ(val1.as_raw_ref(), msgpack::type::raw_ref(&v.front(), static_cast<uint32_t>(v.size())));
     msgpack::object obj(val1, z);
     msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
     // Converted as std::vector<char>.
@@ -418,15 +432,16 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ext)
     v.push_back('a');
     v.push_back('b');
     v.push_back('c');
-    msgpack::type::ext e(42, v.data(), v.size());
+    msgpack::type::ext e(42, v.data(), static_cast<uint32_t>(v.size()));
     msgpack::type::variant val1(e);
     EXPECT_TRUE(val1.is_ext());
     EXPECT_EQ(val1.as_ext(), e);
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_ext());
     EXPECT_EQ(val2.as_ext(), e);
@@ -443,7 +458,7 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_ext)
     v.push_back('a');
     v.push_back('b');
     v.push_back('c');
-    msgpack::type::ext e(42, v.data(), v.size());
+    msgpack::type::ext e(42, v.data(), static_cast<uint32_t>(v.size()));
     msgpack::type::variant val1(e);
     EXPECT_TRUE(val1.is_ext());
     EXPECT_EQ(val1.as_ext(), e);
@@ -463,7 +478,7 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_ext_ref)
     v.push_back('a');
     v.push_back('b');
     v.push_back('c');
-    msgpack::type::ext_ref e(v.data(), v.size());
+    msgpack::type::ext_ref e(v.data(), static_cast<uint32_t>(v.size()));
     msgpack::type::variant val1(e);
     EXPECT_TRUE(val1.is_ext_ref());
     EXPECT_EQ(val1.as_ext_ref(), e);
@@ -492,8 +507,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_array)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_vector());
     EXPECT_EQ(val2.as_vector(), v);
@@ -534,8 +550,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_map)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_multimap());
     EXPECT_EQ(val2.as_multimap(), v);
@@ -578,8 +595,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_str)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant_ref val2 = oh.get().as<msgpack::type::variant_ref>();
     EXPECT_TRUE(val2.is_boost_string_ref());
     EXPECT_EQ(val2.as_boost_string_ref(), sr);
@@ -616,15 +634,16 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_bin)
     v.push_back('a');
     v.push_back('b');
     v.push_back('c');
-    msgpack::type::raw_ref rr(v.data(), v.size());
+    msgpack::type::raw_ref rr(v.data(), static_cast<uint32_t>(v.size()));
     msgpack::type::variant_ref val1 = rr;
     EXPECT_TRUE(val1.is_raw_ref());
     EXPECT_EQ(val1.as_raw_ref(), rr);
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant_ref val2 = oh.get().as<msgpack::type::variant_ref>();
     EXPECT_TRUE(val2.is_raw_ref());
     EXPECT_EQ(val2.as_raw_ref(), rr);
@@ -641,7 +660,7 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_ref_bin)
     v.push_back('a');
     v.push_back('b');
     v.push_back('c');
-    msgpack::type::raw_ref rr(v.data(), v.size());
+    msgpack::type::raw_ref rr(v.data(), static_cast<uint32_t>(v.size()));
     msgpack::type::variant_ref val1 = rr;
     EXPECT_TRUE(val1.is_raw_ref());
     EXPECT_EQ(val1.as_raw_ref(), rr);
@@ -663,15 +682,16 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_ext)
     v.push_back('a');
     v.push_back('b');
     v.push_back('c');
-    msgpack::type::ext_ref er(v.data(), v.size());
+    msgpack::type::ext_ref er(v.data(), static_cast<uint32_t>(v.size()));
     msgpack::type::variant_ref val1(er);
     EXPECT_TRUE(val1.is_ext_ref());
     EXPECT_EQ(val1.as_ext_ref(), er);
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant_ref val2 = oh.get().as<msgpack::type::variant_ref>();
     EXPECT_NO_THROW(boost::get<msgpack::type::ext_ref>(val2));
     EXPECT_TRUE(val2.is_ext_ref());
@@ -688,7 +708,7 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_ref_ext)
     v.push_back('a');
     v.push_back('b');
     v.push_back('c');
-    msgpack::type::ext_ref er(v.data(), v.size());
+    msgpack::type::ext_ref er(v.data(), static_cast<uint32_t>(v.size()));
     msgpack::type::variant_ref val1(er);
     EXPECT_TRUE(val1.is_ext_ref());
     EXPECT_EQ(val1.as_ext_ref(), er);
@@ -720,8 +740,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_array)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant_ref val2 = oh.get().as<msgpack::type::variant_ref>();
     EXPECT_TRUE(val2.is_vector());
     EXPECT_EQ(val2.as_vector(), v);
@@ -773,8 +794,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_map)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant_ref val2 = oh.get().as<msgpack::type::variant_ref>();
     EXPECT_TRUE(val2.is_multimap());
     EXPECT_EQ(val2.as_multimap(), v);

test/buffer.cpp

@@ -3,7 +3,14 @@
 #include <msgpack/fbuffer.h>
 #include <msgpack/zbuffer.hpp>
 #include <msgpack/zbuffer.h>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
+
+#pragma GCC diagnostic pop
+
 #include <string.h>
 
 TEST(buffer, sbuffer)

test/carray.cpp

@@ -1,5 +1,12 @@
 #include <msgpack.hpp>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
+
+#pragma GCC diagnostic pop
+
 #include <sstream>
 
 TEST(carray, pack_unpack_int)
@@ -8,7 +15,8 @@ TEST(carray, pack_unpack_int)
     int v1[] = { 0, 1 };
 
     msgpack::pack(ss, v1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
 
     int v2[2];
@@ -37,7 +45,8 @@ TEST(carray, pack_unpack_const_int)
     const int v1[] = { 0, 1 };
 
     msgpack::pack(ss, v1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
 
     int v2[2];
@@ -66,7 +75,8 @@ TEST(carray, pack_unpack_string)
     std::string v1[] = { "ABC", "DEFG" };
 
     msgpack::pack(ss, v1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
 
     std::string v2[2];
@@ -95,7 +105,8 @@ TEST(carray, pack_unpack_char)
     char v1[] = { 0, 1 };
 
     msgpack::pack(ss, msgpack::type::make_array_ref(v1));
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
 
     char v2[2];
@@ -111,7 +122,8 @@ TEST(carray, pack_unpack_char_as_str)
     char v1[2] = { 1, '\0' };
 
     msgpack::pack(ss, v1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::STR);
     EXPECT_EQ(oh.get().via.str.size, static_cast<size_t>(1));
 
@@ -157,7 +169,8 @@ TEST(carray, pack_unpack_unsigned_char)
     unsigned char v1[] = { 0, 1 };
 
     msgpack::pack(ss, msgpack::type::make_array_ref(v1));
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
 
     unsigned char v2[2];
@@ -173,7 +186,8 @@ TEST(carray, pack_unpack_unsigned_char_as_bin)
     unsigned char v1[] = { 0, 1 };
 
     msgpack::pack(ss, v1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::BIN);
     EXPECT_EQ(oh.get().via.bin.size, static_cast<size_t>(2));
 
@@ -219,7 +233,8 @@ TEST(carray, pack_unpack_signed_char)
     signed char v1[] = { 0, 1 };
 
     msgpack::pack(ss, v1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
 
     signed char v2[2];

test/cases.cpp

@@ -1,13 +1,19 @@
 #include <msgpack.hpp>
 #include <fstream>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 static void feed_file(msgpack::unpacker& pac, const char* path)
 {
     std::ifstream fin(path);
     while(true) {
         pac.reserve_buffer(32*1024);
-        fin.read(pac.buffer(), pac.buffer_capacity());
+        fin.read(pac.buffer(), static_cast<std::streamsize>(pac.buffer_capacity()));
         if(fin.bad()) {
             throw std::runtime_error("read failed");
         }

test/convert.cpp

@@ -1,6 +1,12 @@
 #include <msgpack.hpp>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 class enum_member {
 public:
     enum_member() : flag(A) { }

test/fixint.cpp

@@ -1,6 +1,12 @@
 #include <msgpack.hpp>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 template <typename T>
 void check_size(size_t size) {
     T v(0);
@@ -25,7 +31,7 @@ TEST(fixint, size)
 
 template <typename T>
 void check_convert() {
-    T v1(-11);
+    T v1(typename T::value_type(-11));
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, v1);
 

test/fixint_c.cpp

@@ -1,6 +1,12 @@
 #include <msgpack.h>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 TEST(fixint, size)
 {
     msgpack_sbuffer* sbuf = msgpack_sbuffer_new();
@@ -29,4 +35,3 @@ TEST(fixint, size)
     msgpack_sbuffer_free(sbuf);
     msgpack_packer_free(pk);
 }
-

test/fuzz_unpack_pack_fuzzer_cpp11.cpp

@@ -1,5 +1,10 @@
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 #include "../fuzz/unpack_pack_fuzzer.cpp"
 
 TEST(FUZZ_UNPACK_PACK_FUZZER, works)

test/iterator_cpp11.cpp

@@ -1,6 +1,12 @@
 #include <msgpack.hpp>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -21,7 +27,7 @@ TEST(iterator, vector)
     vec_type vec;
     vec.reserve(VECTOR_SIZE);
     for (unsigned int i = 0; i < VECTOR_SIZE; i++) {
-        vec.push_back(rand());
+        vec.push_back(static_cast<unsigned int>(rand()));
     }
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, vec);
@@ -47,7 +53,7 @@ TEST(iterator, map)
     using map_type = map<unsigned int, unsigned int>;
     map_type map;
     for (unsigned int i = 0; i < MAP_SIZE; i++) {
-        map[rand()] = rand();
+        map[static_cast<unsigned int>(rand())] = static_cast<unsigned int>(rand());
     }
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, map);

test/json.cpp

@@ -1,8 +1,14 @@
 #include <msgpack.hpp>
 #include <fstream>
 #include <sstream>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 TEST(json, basic_elements)
 {
     typedef std::map<std::string, int> map_s_i;

test/limit.cpp

@@ -1,5 +1,12 @@
 #include <msgpack.hpp>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
+
+#pragma GCC diagnostic pop
+
 #include <sstream>
 
 TEST(limit, unpack_array_no_over)

test/msgpack_basic.cpp

@@ -9,8 +9,13 @@
 #include <list>
 #include <limits>
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 #if defined(_MSC_VER) || defined(__MINGW32__)
 #define msgpack_rand() ((double)rand() / RAND_MAX)
 #else  // _MSC_VER || __MINGW32__
@@ -36,7 +41,7 @@ const double kEPS = 1e-10;
         v.push_back(numeric_limits<test_type>::min());      \
         v.push_back(numeric_limits<test_type>::max());      \
         for (unsigned int i = 0; i < kLoop; i++)            \
-            v.push_back(rand());                            \
+            v.push_back(static_cast<test_type>(rand()));    \
         for (unsigned int i = 0; i < v.size() ; i++) {      \
             msgpack::sbuffer sbuf;                          \
             test_type val1 = v[i];                          \
@@ -209,7 +214,7 @@ TYPED_TEST_P(IntegerToFloatingPointTest, simple_buffer)
     vector<integer_type> v;
     v.push_back(0);
     v.push_back(1);
-    if (numeric_limits<integer_type>::is_signed) v.push_back(-1);
+    if (numeric_limits<integer_type>::is_signed) v.push_back(static_cast<integer_type>(-1));
     else v.push_back(2);
     for (unsigned int i = 0; i < kLoop; i++) {
         v.push_back(rand() % 0x7FFFFF);
@@ -221,7 +226,7 @@ TYPED_TEST_P(IntegerToFloatingPointTest, simple_buffer)
         msgpack::object_handle oh =
             msgpack::unpack(sbuf.data(), sbuf.size());
         float_type val2 = oh.get().as<float_type>();
-        EXPECT_TRUE(fabs(val2 - val1) <= kEPS);
+        EXPECT_TRUE(fabs(val2 - static_cast<float_type>(val1)) <= kEPS);
     }
 }
 
@@ -331,6 +336,16 @@ TEST(MSGPACK, simple_buffer_fixext1)
     EXPECT_EQ(1ul, oh.get().via.ext.size);
     EXPECT_EQ(1, oh.get().via.ext.type());
     EXPECT_EQ(2, oh.get().via.ext.data()[0]);
+
+    msgpack::sbuffer sbuf2;
+    msgpack::pack(sbuf2, oh.get());
+    msgpack::object_handle oh2 =
+        msgpack::unpack(sbuf2.data(), sbuf2.size());
+    EXPECT_EQ(1ul, oh2.get().via.ext.size);
+    EXPECT_EQ(1, oh2.get().via.ext.type());
+    EXPECT_EQ(2, oh2.get().via.ext.data()[0]);
+
+    EXPECT_EQ(oh.get(), oh2.get());
 }
 
 TEST(MSGPACK, simple_buffer_fixext2)
@@ -347,6 +362,17 @@ TEST(MSGPACK, simple_buffer_fixext2)
     EXPECT_EQ(0, oh.get().via.ext.type());
     EXPECT_TRUE(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
+
+    msgpack::sbuffer sbuf2;
+    msgpack::pack(sbuf2, oh.get());
+    msgpack::object_handle oh2 =
+        msgpack::unpack(sbuf2.data(), sbuf2.size());
+    EXPECT_EQ(2ul, oh2.get().via.ext.size);
+    EXPECT_EQ(0, oh2.get().via.ext.type());
+    EXPECT_TRUE(
+        std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
+
+    EXPECT_EQ(oh.get(), oh2.get());
 }
 
 TEST(MSGPACK, simple_buffer_fixext4)
@@ -363,6 +389,17 @@ TEST(MSGPACK, simple_buffer_fixext4)
     EXPECT_EQ(1, oh.get().via.ext.type());
     EXPECT_TRUE(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
+
+    msgpack::sbuffer sbuf2;
+    msgpack::pack(sbuf2, oh.get());
+    msgpack::object_handle oh2 =
+        msgpack::unpack(sbuf2.data(), sbuf2.size());
+    EXPECT_EQ(4ul, oh2.get().via.ext.size);
+    EXPECT_EQ(1, oh2.get().via.ext.type());
+    EXPECT_TRUE(
+        std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
+
+    EXPECT_EQ(oh.get(), oh2.get());
 }
 
 TEST(MSGPACK, simple_buffer_fixext8)
@@ -379,6 +416,17 @@ TEST(MSGPACK, simple_buffer_fixext8)
     EXPECT_EQ(1, oh.get().via.ext.type());
     EXPECT_TRUE(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
+
+    msgpack::sbuffer sbuf2;
+    msgpack::pack(sbuf2, oh.get());
+    msgpack::object_handle oh2 =
+        msgpack::unpack(sbuf2.data(), sbuf2.size());
+    EXPECT_EQ(8ul, oh2.get().via.ext.size);
+    EXPECT_EQ(1, oh2.get().via.ext.type());
+    EXPECT_TRUE(
+        std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
+
+    EXPECT_EQ(oh.get(), oh2.get());
 }
 
 TEST(MSGPACK, simple_buffer_fixext16)
@@ -395,6 +443,17 @@ TEST(MSGPACK, simple_buffer_fixext16)
     EXPECT_EQ(1, oh.get().via.ext.type());
     EXPECT_TRUE(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
+
+    msgpack::sbuffer sbuf2;
+    msgpack::pack(sbuf2, oh.get());
+    msgpack::object_handle oh2 =
+        msgpack::unpack(sbuf2.data(), sbuf2.size());
+    EXPECT_EQ(16ul, oh2.get().via.ext.size);
+    EXPECT_EQ(1, oh2.get().via.ext.type());
+    EXPECT_TRUE(
+        std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
+
+    EXPECT_EQ(oh.get(), oh2.get());
 }
 
 TEST(MSGPACK, simple_buffer_fixext_1byte_0)
@@ -426,6 +485,17 @@ TEST(MSGPACK, simple_buffer_fixext_1byte_255)
     EXPECT_EQ(77, oh.get().via.ext.type());
     EXPECT_TRUE(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
+
+    msgpack::sbuffer sbuf2;
+    msgpack::pack(sbuf2, oh.get());
+    msgpack::object_handle oh2 =
+        msgpack::unpack(sbuf2.data(), sbuf2.size());
+    EXPECT_EQ(size, oh2.get().via.ext.size);
+    EXPECT_EQ(77, oh2.get().via.ext.type());
+    EXPECT_TRUE(
+        std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
+
+    EXPECT_EQ(oh.get(), oh2.get());
 }
 
 TEST(MSGPACK, simple_buffer_fixext_2byte_256)
@@ -444,6 +514,17 @@ TEST(MSGPACK, simple_buffer_fixext_2byte_256)
     EXPECT_EQ(77, oh.get().via.ext.type());
     EXPECT_TRUE(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
+
+    msgpack::sbuffer sbuf2;
+    msgpack::pack(sbuf2, oh.get());
+    msgpack::object_handle oh2 =
+        msgpack::unpack(sbuf2.data(), sbuf2.size());
+    EXPECT_EQ(size, oh2.get().via.ext.size);
+    EXPECT_EQ(77, oh2.get().via.ext.type());
+    EXPECT_TRUE(
+        std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
+
+    EXPECT_EQ(oh.get(), oh2.get());
 }
 
 TEST(MSGPACK, simple_buffer_fixext_2byte_65535)
@@ -462,6 +543,17 @@ TEST(MSGPACK, simple_buffer_fixext_2byte_65535)
     EXPECT_EQ(77, oh.get().via.ext.type());
     EXPECT_TRUE(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
+
+    msgpack::sbuffer sbuf2;
+    msgpack::pack(sbuf2, oh.get());
+    msgpack::object_handle oh2 =
+        msgpack::unpack(sbuf2.data(), sbuf2.size());
+    EXPECT_EQ(size, oh2.get().via.ext.size);
+    EXPECT_EQ(77, oh2.get().via.ext.type());
+    EXPECT_TRUE(
+        std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
+
+    EXPECT_EQ(oh.get(), oh2.get());
 }
 
 TEST(MSGPACK, simple_buffer_fixext_4byte_65536)
@@ -480,6 +572,17 @@ TEST(MSGPACK, simple_buffer_fixext_4byte_65536)
     EXPECT_EQ(77, oh.get().via.ext.type());
     EXPECT_TRUE(
         std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
+
+    msgpack::sbuffer sbuf2;
+    msgpack::pack(sbuf2, oh.get());
+    msgpack::object_handle oh2 =
+        msgpack::unpack(sbuf2.data(), sbuf2.size());
+    EXPECT_EQ(size, oh2.get().via.ext.size);
+    EXPECT_EQ(77, oh2.get().via.ext.type());
+    EXPECT_TRUE(
+        std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
+
+    EXPECT_EQ(oh.get(), oh2.get());
 }
 
 TEST(MSGPACK, simple_buffer_ext_convert)
@@ -566,7 +669,7 @@ TEST(MSGPACK_STL, simple_buffer_string)
     for (unsigned int k = 0; k < kLoop; k++) {
         string val1;
         for (unsigned int i = 0; i < kElements; i++)
-            val1 += 'a' + rand() % 26;
+            val1 += static_cast<char>('a' + rand() % 26);
         msgpack::sbuffer sbuf;
         msgpack::pack(sbuf, val1);
         msgpack::object_handle oh =
@@ -583,7 +686,7 @@ TEST(MSGPACK_STL, simple_buffer_cstring)
     for (unsigned int k = 0; k < kLoop; k++) {
         string val1;
         for (unsigned int i = 0; i < kElements; i++)
-            val1 += 'a' + rand() % 26;
+            val1 += static_cast<char>('a' + rand() % 26);
         msgpack::sbuffer sbuf;
         msgpack::pack(sbuf, val1.c_str());
         msgpack::object_handle oh =
@@ -600,7 +703,7 @@ TEST(MSGPACK_STL, simple_buffer_non_const_cstring)
     for (unsigned int k = 0; k < kLoop; k++) {
         string val1;
         for (unsigned int i = 0; i < kElements; i++)
-            val1 += 'a' + rand() % 26;
+            val1 += static_cast<char>('a' + rand() % 26);
         msgpack::sbuffer sbuf;
         char* s = new char[val1.size() + 1];
         std::memcpy(s, val1.c_str(), val1.size() + 1);
@@ -614,3 +717,22 @@ TEST(MSGPACK_STL, simple_buffer_non_const_cstring)
         EXPECT_EQ(val1, val2);
     }
 }
+
+TEST(MSGPACK_STL, simple_buffer_wstring)
+{
+    for (unsigned int k = 0; k < kLoop; k++) {
+        wstring val1;
+        for (unsigned int i = 0; i < kElements; i++)
+            val1 += L'a' + rand() % 26;
+        msgpack::sbuffer sbuf;
+        msgpack::pack(sbuf, val1);
+        msgpack::object_handle oh =
+            msgpack::unpack(sbuf.data(), sbuf.size());
+        EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
+        wstring val2 = oh.get().as<wstring>();
+        EXPECT_EQ(val1, val2);
+        wstring val3;
+        oh.get().convert(val3);
+        EXPECT_EQ(val1, val3);
+    }
+}

test/msgpack_c.cpp

@@ -4,8 +4,13 @@
 #include <vector>
 #include <limits>
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 #if defined(_MSC_VER) || defined(__MINGW32__)
 #define msgpack_rand() ((double)rand() / RAND_MAX)
 #else  // _MSC_VER || __MINGW32__
@@ -26,7 +31,7 @@ const double kEPS = 1e-10;
         v.push_back(numeric_limits<test_type>::min());                  \
         v.push_back(numeric_limits<test_type>::max());                  \
         for (unsigned int i = 0; i < kLoop; i++)                        \
-            v.push_back(rand());                                        \
+            v.push_back(static_cast<test_type>(rand()));                \
         for (unsigned int i = 0; i < v.size() ; i++) {                  \
             test_type val = v[i];                                       \
             msgpack_sbuffer sbuf;                                       \
@@ -61,7 +66,7 @@ const double kEPS = 1e-10;
         v.push_back(numeric_limits<test_type>::min());                  \
         v.push_back(numeric_limits<test_type>::max());                  \
         for (unsigned int i = 0; i < kLoop; i++)                        \
-            v.push_back(rand());                                        \
+            v.push_back(static_cast<test_type>(rand()));                \
         for (unsigned int i = 0; i < v.size() ; i++) {                  \
             test_type val = v[i];                                       \
             msgpack_sbuffer sbuf;                                       \
@@ -1363,3 +1368,45 @@ TEST(MSGPACKC, vref_buffer_overflow)
     EXPECT_FALSE(msgpack_vrefbuffer_init(&vbuf, ref_size, chunk_size));
     EXPECT_EQ(-1, msgpack_vrefbuffer_migrate(&vbuf, &to));
 }
+
+TEST(MSGPACKC, object_print_buffer_overflow) {
+  msgpack_object obj;
+  obj.type = MSGPACK_OBJECT_NIL;
+  char buffer[4];
+
+  int ret;
+  ret = msgpack_object_print_buffer(buffer, 1, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 2, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 3, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 4, obj);
+  EXPECT_EQ(3, ret);
+  EXPECT_STREQ("nil", buffer);
+}
+
+TEST(MSGPACKC, object_bin_print_buffer_overflow) {
+  msgpack_object obj;
+  obj.type = MSGPACK_OBJECT_BIN;
+  obj.via.bin.ptr = "test";
+  obj.via.bin.size = 4;
+  char buffer[7];
+
+  int ret;
+  ret = msgpack_object_print_buffer(buffer, 1, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 2, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 3, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 4, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 5, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 6, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 7, obj);
+  EXPECT_EQ(6, ret);
+  EXPECT_STREQ("\"test\"", buffer);
+}

test/msgpack_container.cpp

@@ -12,8 +12,13 @@
 
 #include "test_allocator.hpp"
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -75,7 +80,7 @@ TEST(MSGPACK_STL, simple_buffer_vector_char)
     for (unsigned int k = 0; k < kLoop; k++) {
         type val1;
         for (unsigned int i = 0; i < kElements; i++)
-            val1.push_back(rand());
+            val1.push_back(static_cast<char>(rand()));
         msgpack::sbuffer sbuf;
         msgpack::pack(sbuf, val1);
         msgpack::object_handle oh =
@@ -107,7 +112,7 @@ TEST(MSGPACK_STL, simple_buffer_vector_unsigned_char)
     for (unsigned int k = 0; k < kLoop; k++) {
         type val1;
         for (unsigned int i = 0; i < kElements; i++)
-            val1.push_back(rand());
+            val1.push_back(static_cast<unsigned char>(rand()));
         msgpack::sbuffer sbuf;
         msgpack::pack(sbuf, val1);
         msgpack::object_handle oh =
@@ -140,7 +145,7 @@ TEST(MSGPACK_STL, simple_buffer_vector_uint8_t)
     for (unsigned int k = 0; k < kLoop; k++) {
         type val1;
         for (unsigned int i = 0; i < kElements; i++)
-            val1.push_back(rand());
+            val1.push_back(static_cast<uint8_t>(rand()));
         msgpack::sbuffer sbuf;
         msgpack::pack(sbuf, val1);
         msgpack::object_handle oh =
@@ -528,6 +533,18 @@ TEST(MSGPACK_TUPLE, simple_tuple_less_than_convert)
     EXPECT_EQ(val1.get<1>(), val2.get<1>());
 }
 
+TEST(MSGPACK_TUPLE, simple_tuple_nest)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::type::tuple<msgpack::type::tuple<> > val1;
+    msgpack::pack(sbuf, val1);
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    msgpack::type::tuple<msgpack::type::tuple<> > val2;
+    oh.get().convert(val2);
+    EXPECT_EQ(oh.get().via.array.size, 1u);
+}
+
 // TR1
 
 #if defined(MSGPACK_HAS_STD_TR1_UNORDERED_MAP) || defined(MSGPACK_HAS_STD_TR1_UNORDERED_SET)

test/msgpack_cpp11.cpp

@@ -1,7 +1,12 @@
 #include <msgpack.hpp>
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -178,7 +183,7 @@ TEST(MSGPACK_CPP11, simple_buffer_array_char)
     for (unsigned int k = 0; k < kLoop; k++) {
         array<char, kElements> val1;
         for (unsigned int i = 0; i < kElements; i++)
-            val1[i] = rand();
+            val1[i] = static_cast<char>(rand());
         msgpack::sbuffer sbuf;
         msgpack::pack(sbuf, val1);
         msgpack::object_handle oh =
@@ -209,7 +214,7 @@ TEST(MSGPACK_CPP11, simple_buffer_array_unsigned_char)
     for (unsigned int k = 0; k < kLoop; k++) {
         array<unsigned char, kElements> val1;
         for (unsigned int i = 0; i < kElements; i++)
-            val1[i] = rand();
+            val1[i] = static_cast<unsigned char>(rand());
         msgpack::sbuffer sbuf;
         msgpack::pack(sbuf, val1);
         msgpack::object_handle oh =
@@ -1044,4 +1049,164 @@ TEST(MSGPACK_CHRONO, system_clock_impl_now)
     EXPECT_EQ(val1, val3);
 }
 
+TEST(MSGPACK_TIMESPEC, timespec_pack_convert_zero)
+{
+    std::stringstream ss;
+    timespec val1{ 0, 0 };
+
+    msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
+    EXPECT_EQ(str.data()[0], static_cast<char>(0xd6));
+
+    msgpack::object_handle oh;
+    msgpack::unpack(oh, str.data(), str.size());
+    timespec val2 = oh.get().as<timespec>();
+    EXPECT_EQ(val1.tv_sec, val2.tv_sec);
+    EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_object_with_zone_zero)
+{
+    msgpack::zone z;
+    timespec val1{ 0, 0 };
+    msgpack::object obj(val1, z);
+    timespec val2 = obj.as<timespec>();
+    EXPECT_EQ(val1.tv_sec, val2.tv_sec);
+    EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_pack_convert_32bit_sec)
+{
+    std::stringstream ss;
+    timespec val1{ 0xffffffffUL, 0 };
+
+    msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
+    EXPECT_EQ(str.data()[0], static_cast<char>(0xd6));
+
+    msgpack::object_handle oh;
+    msgpack::unpack(oh, str.data(), str.size());
+    timespec val2 = oh.get().as<timespec>();
+    EXPECT_EQ(val1.tv_sec, val2.tv_sec);
+    EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_object_with_zone_32bit_sec)
+{
+    msgpack::zone z;
+    timespec val1{ 0xffffffffUL, 0 };
+    msgpack::object obj(val1, z);
+    timespec val2 = obj.as<timespec>();
+    EXPECT_EQ(val1.tv_sec, val2.tv_sec);
+    EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_pack_convert_max_nano)
+{
+    std::stringstream ss;
+    timespec val1{ 0, 999999999 };
+
+    msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
+    EXPECT_EQ(str.data()[0], static_cast<char>(0xd7));
+    msgpack::object_handle oh;
+    msgpack::unpack(oh, str.data(), str.size());
+    timespec val2 = oh.get().as<timespec>();
+    EXPECT_EQ(val1.tv_sec, val2.tv_sec);
+    EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_object_with_zone_max_nano)
+{
+    msgpack::zone z;
+    timespec val1{ 0, 999999999 };
+    msgpack::object obj(val1, z);
+    timespec val2 = obj.as<timespec>();
+    EXPECT_EQ(val1.tv_sec, val2.tv_sec);
+    EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_pack_convert_34bit_sec_max_nano)
+{
+    if (sizeof(decltype(std::declval<timespec>().tv_sec)) <= 4) return;
+    std::stringstream ss;
+    timespec val1{ static_cast<decltype(std::declval<timespec>().tv_sec)>(0x3ffffffffULL), 999999999 };
+
+    msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
+    EXPECT_EQ(str.data()[0], static_cast<char>(0xd7));
+
+    msgpack::object_handle oh;
+    msgpack::unpack(oh, str.data(), str.size());
+    timespec val2 = oh.get().as<timespec>();
+    EXPECT_EQ(val1.tv_sec, val2.tv_sec);
+    EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_object_with_zone_34bit_sec_max_nano)
+{
+    if (sizeof(decltype(std::declval<timespec>().tv_sec)) <= 4) return;
+    msgpack::zone z;
+    timespec val1{ static_cast<decltype(std::declval<timespec>().tv_sec)>(0x3ffffffffULL), 999999999 };
+    msgpack::object obj(val1, z);
+    timespec val2 = obj.as<timespec>();
+    EXPECT_EQ(val1.tv_sec, val2.tv_sec);
+    EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_pack_convert_35bit_sec_max_nano)
+{
+    if (sizeof(decltype(std::declval<timespec>().tv_sec)) <= 4) return;
+    std::stringstream ss;
+    timespec val1{ static_cast<decltype(std::declval<timespec>().tv_sec)>(0x7ffffffffULL), 999999999 };
+
+    msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
+    EXPECT_EQ(str.data()[0], static_cast<char>(0xc7));
+
+    msgpack::object_handle oh;
+    msgpack::unpack(oh, str.data(), str.size());
+    timespec val2 = oh.get().as<timespec>();
+    EXPECT_EQ(val1.tv_sec, val2.tv_sec);
+    EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_object_with_zone_35bit_sec_max_nano)
+{
+    if (sizeof(decltype(std::declval<timespec>().tv_sec)) <= 4) return;
+    msgpack::zone z;
+    timespec val1{ static_cast<decltype(std::declval<timespec>().tv_sec)>(0x7ffffffffULL), 999999999 };
+    msgpack::object obj(val1, z);
+    timespec val2 = obj.as<timespec>();
+    EXPECT_EQ(val1.tv_sec, val2.tv_sec);
+    EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_pack_convert_64bit_sec_max_nano)
+{
+    std::stringstream ss;
+    timespec val1{ std::numeric_limits<decltype(std::declval<timespec>().tv_sec)>::max(), 999999999 };
+
+    msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
+    EXPECT_EQ(str.data()[0], static_cast<char>(0xc7));
+
+    msgpack::object_handle oh;
+    msgpack::unpack(oh, str.data(), str.size());
+    timespec val2 = oh.get().as<timespec>();
+    EXPECT_EQ(val1.tv_sec, val2.tv_sec);
+    EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_object_with_zone_64bit_sec_max_nano)
+{
+    msgpack::zone z;
+    timespec val1{ std::numeric_limits<decltype(std::declval<timespec>().tv_sec)>::max(), 999999999 };
+    msgpack::object obj(val1, z);
+    timespec val2 = obj.as<timespec>();
+    EXPECT_EQ(val1.tv_sec, val2.tv_sec);
+    EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
+}
+
+
 #endif // !defined(MSGPACK_USE_CPP03)

test/msgpack_cpp17.cpp

@@ -1,7 +1,12 @@
 #include <msgpack.hpp>
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -22,8 +27,9 @@ TEST(MSGPACK_CPP17, optional_pack_convert_nil)
     std::stringstream ss;
     std::optional<int> val1;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::optional<int> val2 = oh.get().as<std::optional<int> >();
     EXPECT_TRUE(val1 == val2);
 }
@@ -33,8 +39,9 @@ TEST(MSGPACK_CPP17, optional_pack_convert_int)
     std::stringstream ss;
     std::optional<int> val1 = 1;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::optional<int> val2 = oh.get().as<std::optional<int> >();
     EXPECT_TRUE(val1 == val2);
 }
@@ -50,8 +57,9 @@ TEST(MSGPACK_CPP17, optional_pack_convert_vector)
     v.push_back(3);
     val1 = v;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     ovi_t  val2 = oh.get().as<ovi_t>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -65,8 +73,9 @@ TEST(MSGPACK_CPP17, optional_pack_convert_vector_optional)
     val1[0] = 1;
     val1[2] = 3;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     voi_t  val2 = oh.get().as<voi_t>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -172,8 +181,9 @@ 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);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::optional<no_def_con> val2 = oh.get().as<std::optional<no_def_con>>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -190,8 +200,9 @@ TEST(MSGPACK_CPP17, string_view_pack_convert)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    msgpack::unpack(oh, str.data(), str.size());
     std::string_view val2 = oh.get().as<std::string_view>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -225,7 +236,8 @@ TEST(MSGPACK_CPP17, byte_pack_convert)
     msgpack::pack(ss, val1);
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::unpack(oh, str.data(), str.size());
     std::byte val2 = oh.get().as<std::byte>();
     EXPECT_EQ(val1, val2);
 }
@@ -258,11 +270,13 @@ TEST(MSGPACK_CPP17, vector_byte_pack_convert)
 
     char packed[] = { char(0xc4), char(0x05), char(0x01), char(0x02), char(0x7f), char(0x80), char(0xff) };
     for (size_t i = 0; i != sizeof(packed); ++i) {
-        EXPECT_EQ(ss.str()[i], packed[i]);
+        std::string const& str = ss.str();
+        EXPECT_EQ(str[i], packed[i]);
     }
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::unpack(oh, str.data(), str.size());
     std::vector<std::byte> val2 = oh.get().as<std::vector<std::byte>>();
     EXPECT_EQ(val1, val2);
 }
@@ -303,11 +317,13 @@ TEST(MSGPACK_CPP17, carray_byte_pack_convert)
 
     char packed[] = { char(0xc4), char(0x05), char(0x01), char(0x02), char(0x7f), char(0x80), char(0xff) };
     for (size_t i = 0; i != sizeof(packed); ++i) {
-        EXPECT_EQ(ss.str()[i], packed[i]);
+        std::string const& str = ss.str();
+        EXPECT_EQ(str[i], packed[i]);
     }
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::unpack(oh, str.data(), str.size());
     std::byte val2[sizeof(val1)];
     oh.get().convert(val2);
     for (size_t i = 0; i != sizeof(val1); ++i) {

test/msgpack_stream.cpp

@@ -9,8 +9,13 @@
 #include <list>
 #include <limits>
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -26,8 +31,8 @@ const unsigned int kLoop = 1000;
         msgpack::packer<msgpack::sbuffer> pk(sbuf);                     \
         typedef std::vector<test_type> vec_type;                        \
         vec_type vec;                                                   \
-        for(unsigned int i = 0; i < rand() % kLoop; ++i) {              \
-            vec_type::value_type r = rand();                            \
+        for(unsigned int i = 0; i < static_cast<unsigned int>(rand()) % kLoop; ++i) { \
+            vec_type::value_type r = static_cast<test_type>(rand());    \
             vec.push_back(r);                                           \
             pk.pack(r);                                                 \
         }                                                               \
@@ -36,7 +41,7 @@ const unsigned int kLoop = 1000;
         const char *p = sbuf.data();                                    \
         const char * const pend = p + sbuf.size();                      \
         while (p < pend) {                                              \
-            const size_t sz = std::min<size_t>(pend - p, rand() % 128); \
+            const size_t sz = std::min<size_t>(static_cast<std::size_t>(pend - p), static_cast<std::size_t>(rand() % 128)); \
             pac.reserve_buffer(sz);                                     \
             memcpy(pac.buffer(), p, sz);                                \
             pac.buffer_consumed(sz);                                    \

test/msgpack_tuple.cpp

@@ -1,6 +1,12 @@
 #include <msgpack.hpp>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 
 TEST(msgpack_tuple, member_get)
 {

test/msgpack_vref.cpp

@@ -9,8 +9,13 @@
 #include <list>
 #include <limits>
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif

test/msgpack_x3_parse.cpp

@@ -4,8 +4,13 @@
 #include <limits>
 #include <cmath>
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 // To avoid link error
 TEST(MSGPACK_X3_PARSE, dummy)
 {
@@ -169,7 +174,7 @@ TEST(MSGPACK_X3_PARSE, uint64_2)
 
 TEST(MSGPACK_X3_PARSE, int8_1)
 {
-    int8_t v = 0b11011111;
+    int8_t v = static_cast<int8_t>(0b11011111);
     std::stringstream ss;
     msgpack::pack(ss, v);
 
@@ -179,7 +184,7 @@ TEST(MSGPACK_X3_PARSE, int8_1)
 
 TEST(MSGPACK_X3_PARSE, int8_2)
 {
-    int8_t v = 0b10000000;
+    int8_t v = static_cast<int8_t>(0b10000000);
     std::stringstream ss;
     msgpack::pack(ss, v);
 
@@ -189,7 +194,7 @@ TEST(MSGPACK_X3_PARSE, int8_2)
 
 TEST(MSGPACK_X3_PARSE, int16_1)
 {
-    int16_t v = 0xff00;
+    int16_t v = static_cast<int16_t>(0xff00);
     std::stringstream ss;
     msgpack::pack(ss, v);
 
@@ -199,7 +204,7 @@ TEST(MSGPACK_X3_PARSE, int16_1)
 
 TEST(MSGPACK_X3_PARSE, int16_2)
 {
-    int16_t v = 0x8000;
+    int16_t v = static_cast<int16_t>(0x8000);
     std::stringstream ss;
     msgpack::pack(ss, v);
 
@@ -209,7 +214,7 @@ TEST(MSGPACK_X3_PARSE, int16_2)
 
 TEST(MSGPACK_X3_PARSE, int32_1)
 {
-    int32_t v = 0xff000000L;
+    int32_t v = static_cast<int32_t>(0xff000000L);
     std::stringstream ss;
     msgpack::pack(ss, v);
 
@@ -219,7 +224,7 @@ TEST(MSGPACK_X3_PARSE, int32_1)
 
 TEST(MSGPACK_X3_PARSE, int32_2)
 {
-    int32_t v = 0x80000000L;
+    int32_t v = static_cast<int32_t>(0x80000000L);
     std::stringstream ss;
     msgpack::pack(ss, v);
 
@@ -229,7 +234,7 @@ TEST(MSGPACK_X3_PARSE, int32_2)
 
 TEST(MSGPACK_X3_PARSE, int64_1)
 {
-    int64_t v = 0xff00000000000000LL;
+    int64_t v = static_cast<int64_t>(0xff00000000000000LL);
     std::stringstream ss;
     msgpack::pack(ss, v);
 
@@ -239,7 +244,7 @@ TEST(MSGPACK_X3_PARSE, int64_1)
 
 TEST(MSGPACK_X3_PARSE, int64_2)
 {
-    int64_t v = 0x8000000000000000LL;
+    int64_t v = static_cast<int64_t>(0x8000000000000000LL);
     std::stringstream ss;
     msgpack::pack(ss, v);
 
@@ -445,7 +450,7 @@ TEST(MSGPACK_X3_PARSE, string_2)
 {
     std::string v;
 
-    for (uint64_t i = 0; i != 0x1fU; ++i) v.push_back('0'+(i%10));
+    for (uint64_t i = 0; i != 0x1fU; ++i) v.push_back(static_cast<char>('0'+(i%10)));
 
     std::stringstream ss;
     msgpack::pack(ss, v);
@@ -458,7 +463,7 @@ TEST(MSGPACK_X3_PARSE, string_3)
 {
     std::string v;
 
-    for (uint64_t i = 0; i != 0xffU; ++i) v.push_back('0'+(i%10));
+    for (uint64_t i = 0; i != 0xffU; ++i) v.push_back(static_cast<char>('0'+(i%10)));
 
     std::stringstream ss;
     msgpack::pack(ss, v);
@@ -471,7 +476,7 @@ TEST(MSGPACK_X3_PARSE, string_4)
 {
     std::string v;
 
-    for (uint64_t i = 0; i != 0xffU+1U; ++i) v.push_back('0'+(i%10));
+    for (uint64_t i = 0; i != 0xffU+1U; ++i) v.push_back(static_cast<char>('0'+(i%10)));
 
     std::stringstream ss;
     msgpack::pack(ss, v);
@@ -484,7 +489,7 @@ TEST(MSGPACK_X3_PARSE, string_5)
 {
     std::string v;
 
-    for (uint64_t i = 0; i != 0xffffU; ++i) v.push_back('0'+(i%10));
+    for (uint64_t i = 0; i != 0xffffU; ++i) v.push_back(static_cast<char>('0'+(i%10)));
 
     std::stringstream ss;
     msgpack::pack(ss, v);
@@ -497,7 +502,7 @@ TEST(MSGPACK_X3_PARSE, string_6)
 {
     std::string v;
 
-    for (uint64_t i = 0; i != 0xffffUL + 1UL; ++i) v.push_back('0'+(i%10));
+    for (uint64_t i = 0; i != 0xffffUL + 1UL; ++i) v.push_back(static_cast<char>('0'+(i%10)));
 
     std::stringstream ss;
     msgpack::pack(ss, v);
@@ -520,7 +525,7 @@ TEST(MSGPACK_X3_PARSE, bin_2)
 {
     std::vector<char> v;
 
-    for (uint64_t i = 0; i != 0x1fU; ++i) v.push_back(i%0xff);
+    for (uint64_t i = 0; i != 0x1fU; ++i) v.push_back(static_cast<char>(i%0xff));
 
     std::stringstream ss;
     msgpack::pack(ss, v);
@@ -533,7 +538,7 @@ TEST(MSGPACK_X3_PARSE, bin_3)
 {
     std::vector<char> v;
 
-    for (uint64_t i = 0; i != 0xffU; ++i) v.push_back(i%0xff);
+    for (uint64_t i = 0; i != 0xffU; ++i) v.push_back(static_cast<char>(i%0xff));
 
     std::stringstream ss;
     msgpack::pack(ss, v);
@@ -546,7 +551,7 @@ TEST(MSGPACK_X3_PARSE, bin_4)
 {
     std::vector<char> v;
 
-    for (uint64_t i = 0; i != 0xffU+1U; ++i) v.push_back(i%0xff);
+    for (uint64_t i = 0; i != 0xffU+1U; ++i) v.push_back(static_cast<char>(i%0xff));
 
     std::stringstream ss;
     msgpack::pack(ss, v);
@@ -559,7 +564,7 @@ TEST(MSGPACK_X3_PARSE, bin_5)
 {
     std::vector<char> v;
 
-    for (uint64_t i = 0; i != 0xffffU; ++i) v.push_back(i%0xff);
+    for (uint64_t i = 0; i != 0xffffU; ++i) v.push_back(static_cast<char>(i%0xff));
 
     std::stringstream ss;
     msgpack::pack(ss, v);
@@ -572,7 +577,7 @@ TEST(MSGPACK_X3_PARSE, bin_6)
 {
     std::vector<char> v;
 
-    for (uint64_t i = 0; i != 0xffffUL + 1UL; ++i) v.push_back(i%0xff);
+    for (uint64_t i = 0; i != 0xffffUL + 1UL; ++i) v.push_back(static_cast<char>(i%0xff));
 
     std::stringstream ss;
     msgpack::pack(ss, v);

test/object.cpp

@@ -1,6 +1,12 @@
 #include <msgpack.hpp>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 
 enum enum_test {
     elem
@@ -361,67 +367,93 @@ TEST(object, clone_int)
 
 TEST(object, clone_str)
 {
-    msgpack::zone z;
+    msgpack::object_handle oh;
     std::string v = "123456789";
-    msgpack::object obj(v, z);
-    std::size_t sz1 = msgpack::aligned_zone_size(obj);
-    msgpack::object_handle h = msgpack::clone(obj);
-    EXPECT_EQ(h.get(), obj);
-    EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
-    h = msgpack::clone(obj);
-    EXPECT_EQ(h.get(), obj);
-    EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+    {
+        msgpack::zone z;
+        msgpack::object obj(v, z);
+        std::size_t sz1 = msgpack::aligned_zone_size(obj);
+        msgpack::object_handle h = msgpack::clone(obj);
+        EXPECT_EQ(h.get(), obj);
+        EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+        h = msgpack::clone(obj);
+        EXPECT_EQ(h.get(), obj);
+        EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+        oh = msgpack::move(h);
+    }
+    EXPECT_EQ(v, oh.get().as<std::string>());
 }
 
 TEST(object, clone_bin)
 {
-    msgpack::zone z;
+    msgpack::object_handle oh;
     std::vector<char> v;
-    v.push_back('A');
-    v.push_back('B');
-    v.push_back('C');
-    msgpack::object obj(v, z);
-    std::size_t sz1 = msgpack::aligned_zone_size(obj);
-    msgpack::object_handle h = msgpack::clone(obj);
-    EXPECT_EQ(h.get(), obj);
-    EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
-    h = msgpack::clone(obj);
-    EXPECT_EQ(h.get(), obj);
-    EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+    {
+        msgpack::zone z;
+        v.push_back('A');
+        v.push_back('B');
+        v.push_back('C');
+        msgpack::object obj(v, z);
+        std::size_t sz1 = msgpack::aligned_zone_size(obj);
+        msgpack::object_handle h = msgpack::clone(obj);
+        EXPECT_EQ(h.get(), obj);
+        EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+        h = msgpack::clone(obj);
+        EXPECT_EQ(h.get(), obj);
+        EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+        oh = msgpack::move(h);
+    }
+    std::vector<char> v2 = oh.get().as<std::vector<char> >();
+    EXPECT_EQ(v.size(), v2.size());
+    EXPECT_TRUE(equal(v.begin(), v.end(), v2.begin()));
 }
 
 TEST(object, clone_array)
 {
-    msgpack::zone z;
+    msgpack::object_handle oh;
     std::vector<int> v;
-    v.push_back(1);
-    v.push_back(2);
-    v.push_back(3);
-    msgpack::object obj(v, z);
-    std::size_t sz1 = msgpack::aligned_zone_size(obj);
-    msgpack::object_handle h = msgpack::clone(obj);
-    EXPECT_EQ(h.get(), obj);
-    EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
-    h = msgpack::clone(obj);
-    EXPECT_EQ(h.get(), obj);
-    EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+    {
+        msgpack::zone z;
+        v.push_back(1);
+        v.push_back(2);
+        v.push_back(3);
+        msgpack::object obj(v, z);
+        std::size_t sz1 = msgpack::aligned_zone_size(obj);
+        msgpack::object_handle h = msgpack::clone(obj);
+        EXPECT_EQ(h.get(), obj);
+        EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+        h = msgpack::clone(obj);
+        EXPECT_EQ(h.get(), obj);
+        EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+        oh = msgpack::move(h);
+    }
+    std::vector<int> v2 = oh.get().as<std::vector<int> >();
+    EXPECT_EQ(v.size(), v2.size());
+    EXPECT_TRUE(equal(v.begin(), v.end(), v2.begin()));
 }
 
 TEST(object, clone_map)
 {
-    msgpack::zone z;
+    msgpack::object_handle oh;
     std::map<int, std::string> v;
-    v.insert(std::map<int, std::string>::value_type(1, "ABC"));
-    v.insert(std::map<int, std::string>::value_type(2, "DEF"));
-    v.insert(std::map<int, std::string>::value_type(3, "GHI"));
-    msgpack::object obj(v, z);
-    std::size_t sz1 = msgpack::aligned_zone_size(obj);
-    msgpack::object_handle h = msgpack::clone(obj);
-    EXPECT_EQ(h.get(), obj);
-    EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
-    h = msgpack::clone(obj);
-    EXPECT_EQ(h.get(), obj);
-    EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+    {
+        msgpack::zone z;
+        v.insert(std::map<int, std::string>::value_type(1, "ABC"));
+        v.insert(std::map<int, std::string>::value_type(2, "DEF"));
+        v.insert(std::map<int, std::string>::value_type(3, "GHI"));
+        msgpack::object obj(v, z);
+        std::size_t sz1 = msgpack::aligned_zone_size(obj);
+        msgpack::object_handle h = msgpack::clone(obj);
+        EXPECT_EQ(h.get(), obj);
+        EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+        h = msgpack::clone(obj);
+        EXPECT_EQ(h.get(), obj);
+        EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+        oh = msgpack::move(h);
+    }
+    std::map<int, std::string> v2 = oh.get().as<std::map<int, std::string> >();
+    EXPECT_EQ(v.size(), v2.size());
+    EXPECT_TRUE(equal(v.begin(), v.end(), v2.begin()));
 }
 
 TEST(object, pack_float)

test/object_with_zone.cpp

@@ -1,5 +1,12 @@
 #include <msgpack.hpp>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
+
+#pragma GCC diagnostic pop
+
 #include <cmath>
 
 #ifdef HAVE_CONFIG_H
@@ -202,7 +209,7 @@ TEST(object_with_zone, vector)
         vector<int> v1;
         v1.push_back(1);
         for (unsigned int i = 1; i < kElements; i++)
-            v1.push_back(i);
+            v1.push_back(static_cast<int>(i));
         msgpack::zone z;
         msgpack::object obj(v1, z);
         EXPECT_TRUE(obj.as<vector<int> >() == v1);
@@ -282,7 +289,7 @@ TEST(object_with_zone, list)
         list<int> v1;
         v1.push_back(1);
         for (unsigned int i = 1; i < kElements; i++)
-            v1.push_back(i);
+            v1.push_back(static_cast<int>(i));
         msgpack::zone z;
         msgpack::object obj(v1, z);
         EXPECT_TRUE(obj.as<list<int> >() == v1);
@@ -298,7 +305,7 @@ TEST(object_with_zone, deque)
         deque<int> v1;
         v1.push_back(1);
         for (unsigned int i = 1; i < kElements; i++)
-            v1.push_back(i);
+            v1.push_back(static_cast<int>(i));
         msgpack::zone z;
         msgpack::object obj(v1, z);
         EXPECT_TRUE(obj.as<deque<int> >() == v1);
@@ -332,6 +339,17 @@ TEST(object_without_zone, string)
 
 #endif // MSGPACK_DEFAULT_API_VERSION == 1
 
+// wstring
+TEST(object_with_zone, wstring)
+{
+    wstring v = L"abc";
+    msgpack::zone z;
+    msgpack::object obj(v, z);
+    EXPECT_EQ(obj.as<wstring>(), v);
+    v[0] = 'd';
+    EXPECT_EQ(obj.as<wstring>()[0], L'a');
+}
+
 // char*
 TEST(object_with_zone, char_ptr)
 {
@@ -401,7 +419,7 @@ TEST(object_with_zone, set)
     for (unsigned int k = 0; k < kLoop; k++) {
         set<int> v1;
         for (unsigned int i = 0; i < kElements; i++)
-            v1.insert(i);
+            v1.insert(static_cast<int>(i));
         msgpack::zone z;
         msgpack::object obj(v1, z);
         EXPECT_TRUE(obj.as<set<int> >() == v1);
@@ -861,7 +879,7 @@ TEST(object_with_zone, array_char)
         test_t v1;
         v1[0] = 1;
         for (unsigned int i = 1; i < kElements; i++)
-            v1[i] = rand();
+            v1[i] = static_cast<char>(rand());
         msgpack::zone z;
         msgpack::object obj(v1, z);
         EXPECT_TRUE(obj.as<test_t>() == v1);
@@ -877,7 +895,7 @@ TEST(object_without_zone, array_char)
         test_t v1;
         v1[0] = 1;
         for (unsigned int i = 1; i < kElements; i++)
-            v1[i] = rand();
+            v1[i] = static_cast<char>(rand());
         msgpack::object obj(v1);
         EXPECT_TRUE(obj.as<test_t>() == v1);
         v1.front() = 42;
@@ -894,7 +912,7 @@ TEST(object_with_zone, array_unsigned_char)
         test_t v1;
         v1[0] = 1;
         for (unsigned int i = 1; i < kElements; i++)
-            v1[i] = rand();
+            v1[i] = static_cast<unsigned char>(rand());
         msgpack::zone z;
         msgpack::object obj(v1, z);
         EXPECT_TRUE(obj.as<test_t>() == v1);
@@ -911,7 +929,7 @@ TEST(object_without_zone, array_unsigned_char)
         test_t v1;
         v1[0] = 1;
         for (unsigned int i = 1; i < kElements; i++)
-            v1[i] = rand();
+            v1[i] = static_cast<unsigned char>(rand());
         msgpack::object obj(v1);
         EXPECT_TRUE(obj.as<test_t>() == v1);
         v1.front() = 42;
@@ -926,7 +944,7 @@ TEST(object_with_zone, forward_list)
     for (unsigned int k = 0; k < kLoop; k++) {
         forward_list<int> v1;
         for (unsigned int i = 0; i < kElements; i++)
-            v1.push_front(i);
+            v1.push_front(static_cast<int>(i));
         msgpack::zone z;
         msgpack::object obj(v1, z);
         EXPECT_TRUE(obj.as<forward_list<int> >() == v1);
@@ -1031,7 +1049,7 @@ TEST(object_with_zone, ext_empty)
 TEST(object_with_zone, ext)
 {
     msgpack::type::ext v(42, 10);
-    for (int i = 0; i < 10; ++i) v.data()[i] = i;
+    for (int i = 0; i < 10; ++i) v.data()[i] = static_cast<char>(i);
     msgpack::zone z;
     msgpack::object obj(v, z);
     EXPECT_TRUE(obj.as<msgpack::type::ext>() == v);

test/pack_unpack.cpp

@@ -1,5 +1,12 @@
 #include <msgpack.hpp>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
+
+#pragma GCC diagnostic pop
+
 #include <sstream>
 
 TEST(pack, num)
@@ -517,7 +524,7 @@ TEST(unpack, int_off_larger_than_length)
 TEST(unpack, empty_array_fix)
 {
     std::string buf;
-    buf.push_back(static_cast<unsigned char>(0x90));
+    buf.push_back(static_cast<char>(0x90));
     std::size_t off = 0;
 
     msgpack::object_handle oh = msgpack::unpack(buf.data(), buf.size(), off);
@@ -529,9 +536,9 @@ TEST(unpack, empty_array_fix)
 TEST(unpack, empty_array_16)
 {
     std::string buf;
-    buf.push_back(static_cast<unsigned char>(0xdc));
-    buf.push_back(static_cast<unsigned char>(0x00));
-    buf.push_back(static_cast<unsigned char>(0x00));
+    buf.push_back(static_cast<char>(0xdc));
+    buf.push_back(static_cast<char>(0x00));
+    buf.push_back(static_cast<char>(0x00));
     std::size_t off = 0;
 
     msgpack::object_handle oh = msgpack::unpack(buf.data(), buf.size(), off);
@@ -543,11 +550,11 @@ TEST(unpack, empty_array_16)
 TEST(unpack, empty_array_32)
 {
     std::string buf;
-    buf.push_back(static_cast<unsigned char>(0xdd));
-    buf.push_back(static_cast<unsigned char>(0x00));
-    buf.push_back(static_cast<unsigned char>(0x00));
-    buf.push_back(static_cast<unsigned char>(0x00));
-    buf.push_back(static_cast<unsigned char>(0x00));
+    buf.push_back(static_cast<char>(0xdd));
+    buf.push_back(static_cast<char>(0x00));
+    buf.push_back(static_cast<char>(0x00));
+    buf.push_back(static_cast<char>(0x00));
+    buf.push_back(static_cast<char>(0x00));
     std::size_t off = 0;
 
     msgpack::object_handle oh = msgpack::unpack(buf.data(), buf.size(), off);
@@ -559,7 +566,7 @@ TEST(unpack, empty_array_32)
 TEST(unpack, empty_map_fix)
 {
     std::string buf;
-    buf.push_back(static_cast<unsigned char>(0x80));
+    buf.push_back(static_cast<char>(0x80));
     std::size_t off = 0;
 
     msgpack::object_handle oh = msgpack::unpack(buf.data(), buf.size(), off);
@@ -571,9 +578,9 @@ TEST(unpack, empty_map_fix)
 TEST(unpack, empty_map_16)
 {
     std::string buf;
-    buf.push_back(static_cast<unsigned char>(0xde));
-    buf.push_back(static_cast<unsigned char>(0x00));
-    buf.push_back(static_cast<unsigned char>(0x00));
+    buf.push_back(static_cast<char>(0xde));
+    buf.push_back(static_cast<char>(0x00));
+    buf.push_back(static_cast<char>(0x00));
     std::size_t off = 0;
 
     msgpack::object_handle oh = msgpack::unpack(buf.data(), buf.size(), off);
@@ -585,11 +592,11 @@ TEST(unpack, empty_map_16)
 TEST(unpack, empty_map_32)
 {
     std::string buf;
-    buf.push_back(static_cast<unsigned char>(0xdf));
-    buf.push_back(static_cast<unsigned char>(0x00));
-    buf.push_back(static_cast<unsigned char>(0x00));
-    buf.push_back(static_cast<unsigned char>(0x00));
-    buf.push_back(static_cast<unsigned char>(0x00));
+    buf.push_back(static_cast<char>(0xdf));
+    buf.push_back(static_cast<char>(0x00));
+    buf.push_back(static_cast<char>(0x00));
+    buf.push_back(static_cast<char>(0x00));
+    buf.push_back(static_cast<char>(0x00));
     std::size_t off = 0;
 
     msgpack::object_handle oh = msgpack::unpack(buf.data(), buf.size(), off);

test/pack_unpack_c.cpp

@@ -1,5 +1,12 @@
 #include <msgpack.h>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
+
+#pragma GCC diagnostic pop
+
 #include <stdio.h>
 
 TEST(pack, num)

test/raw.cpp

@@ -3,8 +3,13 @@
 #include <string>
 #include <sstream>
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -13,7 +18,7 @@ TEST(MSGPACK_RAW_REF, pack_unpack)
 {
     std::string s = "ABC";
 
-    msgpack::type::raw_ref rr1(s.data(), s.size());
+    msgpack::type::raw_ref rr1(s.data(), static_cast<uint32_t>(s.size()));
     std::stringstream ss;
     msgpack::pack(ss, rr1);
     std::string packed_str = ss.str();
@@ -24,7 +29,7 @@ TEST(MSGPACK_RAW_REF, pack_unpack)
     EXPECT_EQ(packed_str[4], 'C');
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -33,7 +38,7 @@ TEST(MSGPACK_RAW_REF, pack_unpack_8_l)
 {
     std::string s;
 
-    msgpack::type::raw_ref rr1(s.data(), s.size());
+    msgpack::type::raw_ref rr1(s.data(), static_cast<uint32_t>(s.size()));
     std::stringstream ss;
     msgpack::pack(ss, rr1);
     std::string packed_str = ss.str();
@@ -41,7 +46,7 @@ TEST(MSGPACK_RAW_REF, pack_unpack_8_l)
     EXPECT_EQ(packed_str[1], static_cast<char>(0x00u));
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -50,7 +55,7 @@ TEST(MSGPACK_RAW_REF, pack_unpack_8_h)
 {
     std::string s(0xff, 'A');
 
-    msgpack::type::raw_ref rr1(s.data(), s.size());
+    msgpack::type::raw_ref rr1(s.data(), static_cast<uint32_t>(s.size()));
     std::stringstream ss;
     msgpack::pack(ss, rr1);
     std::string packed_str = ss.str();
@@ -59,7 +64,7 @@ TEST(MSGPACK_RAW_REF, pack_unpack_8_h)
     EXPECT_EQ(packed_str[2], 'A');
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -68,7 +73,7 @@ TEST(MSGPACK_RAW_REF, pack_unpack_16_l)
 {
     std::string s(0xff+1, 'A');
 
-    msgpack::type::raw_ref rr1(s.data(), s.size());
+    msgpack::type::raw_ref rr1(s.data(), static_cast<uint32_t>(s.size()));
     std::stringstream ss;
     msgpack::pack(ss, rr1);
     std::string packed_str = ss.str();
@@ -78,7 +83,7 @@ TEST(MSGPACK_RAW_REF, pack_unpack_16_l)
     EXPECT_EQ(packed_str[3], 'A');
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -87,7 +92,7 @@ TEST(MSGPACK_RAW_REF, pack_unpack_16_h)
 {
     std::string s(0xffff, 'A');
 
-    msgpack::type::raw_ref rr1(s.data(), s.size());
+    msgpack::type::raw_ref rr1(s.data(), static_cast<uint32_t>(s.size()));
     std::stringstream ss;
     msgpack::pack(ss, rr1);
     std::string packed_str = ss.str();
@@ -97,7 +102,7 @@ TEST(MSGPACK_RAW_REF, pack_unpack_16_h)
     EXPECT_EQ(packed_str[3], 'A');
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -106,7 +111,7 @@ TEST(MSGPACK_RAW_REF, pack_unpack_32_l)
 {
     std::string s(0xffff+1, 'A');
 
-    msgpack::type::raw_ref rr1(s.data(), s.size());
+    msgpack::type::raw_ref rr1(s.data(), static_cast<uint32_t>(s.size()));
     std::stringstream ss;
     msgpack::pack(ss, rr1);
     std::string packed_str = ss.str();
@@ -118,7 +123,7 @@ TEST(MSGPACK_RAW_REF, pack_unpack_32_l)
     EXPECT_EQ(packed_str[5], 'A');
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -127,7 +132,7 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack)
 {
     std::string s = "ABC";
 
-    msgpack::type::v4raw_ref rr1(s.data(), s.size());
+    msgpack::type::v4raw_ref rr1(s.data(), static_cast<uint32_t>(s.size()));
     std::stringstream ss;
     msgpack::pack(ss, rr1);
     std::string packed_str = ss.str();
@@ -137,7 +142,7 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack)
     EXPECT_EQ(packed_str[3], 'C');
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -146,14 +151,14 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack_fix_l)
 {
     std::string s;
 
-    msgpack::type::v4raw_ref rr1(s.data(), s.size());
+    msgpack::type::v4raw_ref rr1(s.data(), static_cast<uint32_t>(s.size()));
     std::stringstream ss;
     msgpack::pack(ss, rr1);
     std::string packed_str = ss.str();
     EXPECT_EQ(packed_str[0], static_cast<char>(0xa0u));
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -162,7 +167,7 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack_fix_h)
 {
     std::string s(0x1f, 'A');
 
-    msgpack::type::v4raw_ref rr1(s.data(), s.size());
+    msgpack::type::v4raw_ref rr1(s.data(), static_cast<uint32_t>(s.size()));
     std::stringstream ss;
     msgpack::pack(ss, rr1);
     std::string packed_str = ss.str();
@@ -170,7 +175,7 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack_fix_h)
     EXPECT_EQ(packed_str[1], 'A');
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -179,7 +184,7 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack_16_l)
 {
     std::string s(0x1f+1, 'A');
 
-    msgpack::type::v4raw_ref rr1(s.data(), s.size());
+    msgpack::type::v4raw_ref rr1(s.data(), static_cast<uint32_t>(s.size()));
     std::stringstream ss;
     msgpack::pack(ss, rr1);
     std::string packed_str = ss.str();
@@ -189,7 +194,7 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack_16_l)
     EXPECT_EQ(packed_str[3], 'A');
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -198,7 +203,7 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack_16_h)
 {
     std::string s(0xffff, 'A');
 
-    msgpack::type::v4raw_ref rr1(s.data(), s.size());
+    msgpack::type::v4raw_ref rr1(s.data(), static_cast<uint32_t>(s.size()));
     std::stringstream ss;
     msgpack::pack(ss, rr1);
     std::string packed_str = ss.str();
@@ -208,7 +213,7 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack_16_h)
     EXPECT_EQ(packed_str[3], 'A');
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -217,7 +222,7 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack_32_l)
 {
     std::string s(0xffff+1, 'A');
 
-    msgpack::type::v4raw_ref rr1(s.data(), s.size());
+    msgpack::type::v4raw_ref rr1(s.data(), static_cast<uint32_t>(s.size()));
     std::stringstream ss;
     msgpack::pack(ss, rr1);
     std::string packed_str = ss.str();
@@ -229,7 +234,7 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack_32_l)
     EXPECT_EQ(packed_str[5], 'A');
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }

test/reference.cpp

@@ -1,6 +1,12 @@
 #include <msgpack.hpp>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 TEST(reference, unpack_int)
 {
     msgpack::sbuffer sbuf;

test/reference_cpp11.cpp

@@ -1,6 +1,12 @@
 #include <msgpack.hpp>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 #if !defined(MSGPACK_USE_CPP03)
 
 TEST(reference, unpack_int)

test/reference_wrapper_cpp11.cpp

@@ -1,7 +1,13 @@
 #include <msgpack.hpp>
 #include <sstream>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -14,7 +20,8 @@ TEST(MSGPACK_REFERENCE_WRAPPER, pack_convert)
     std::reference_wrapper<int> val1(i1);
     std::stringstream ss;
     msgpack::pack(ss, val1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     int i2 = 0;
     std::reference_wrapper<int> val2(i2);
     oh.get().convert(val2);
@@ -27,7 +34,8 @@ TEST(MSGPACK_REFERENCE_WRAPPER, pack_convert_const)
     std::reference_wrapper<const int> val1(i1);
     std::stringstream ss;
     msgpack::pack(ss, val1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     int i2 = 0;
     std::reference_wrapper<int> val2(i2);
     oh.get().convert(val2);
@@ -40,7 +48,8 @@ TEST(MSGPACK_REFERENCE_WRAPPER, pack_vector)
     std::vector<std::reference_wrapper<int>> val1{i1};
     std::stringstream ss;
     msgpack::pack(ss, val1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     std::vector<int> val2 = oh.get().as<std::vector<int>>();
     EXPECT_EQ(val2.size(), static_cast<size_t>(1));
     EXPECT_EQ(val1[0], val2[0]);

test/shared_ptr_cpp11.cpp

@@ -1,8 +1,14 @@
 #include <msgpack.hpp>
 #include <sstream>
 #include <iterator>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -14,8 +20,9 @@ TEST(SHARED_PTR, pack_convert_nil)
     std::stringstream ss;
     std::shared_ptr<int> val1;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::shared_ptr<int> val2 = oh.get().as<std::shared_ptr<int>>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -25,8 +32,9 @@ TEST(SHARED_PTR, pack_convert_int)
     std::stringstream ss;
     std::shared_ptr<int> val1(new int(1));
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::shared_ptr<int> val2 = oh.get().as<std::shared_ptr<int>>();
     EXPECT_TRUE(*val1 == *val2);
 }
@@ -113,8 +121,9 @@ TEST(SHARED_PTR, pack_convert_nil_no_def_con)
     std::stringstream ss;
     std::shared_ptr<no_def_con> val1(new no_def_con(1));
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::shared_ptr<no_def_con> val2 = oh.get().as<std::shared_ptr<no_def_con>>();
     EXPECT_TRUE(*val1 == *val2);
 }

test/size_equal_only.cpp

@@ -1,7 +1,13 @@
 #include <sstream>
 #include <msgpack.hpp>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 TEST(size_equal_only, array)
 {
     std::stringstream ss;
@@ -9,7 +15,8 @@ TEST(size_equal_only, array)
     msgpack::type::size_equal_only<int[3]> seo(buf);
 
     msgpack::pack(ss, seo);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
 
     int ret_buf1[3];
     oh.get().convert(ret_buf1);
@@ -52,7 +59,8 @@ TEST(size_equal_only, vector)
     msgpack::type::size_equal_only<std::vector<int> > seo(buf);
 
     msgpack::pack(ss, seo);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
 
     std::vector<int> ret_buf1;
     oh.get().convert(ret_buf1);
@@ -85,7 +93,8 @@ TEST(size_equal_only, msgpack_tuple)
     msgpack::type::size_equal_only<msgpack::type::tuple<int, bool, std::string> > seo(buf);
 
     msgpack::pack(ss, seo);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
 
     msgpack::type::tuple<int, bool, std::string> ret_buf1;
     oh.get().convert(ret_buf1);
@@ -142,7 +151,8 @@ TEST(size_equal_only, tuple)
     auto seo = msgpack::type::make_size_equal_only(buf);
 
     msgpack::pack(ss, seo);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
 
     std::tuple<int, bool, std::string> ret_buf1;
     oh.get().convert(ret_buf1);
@@ -186,7 +196,6 @@ TEST(size_equal_only, tuple)
 }
 
 struct foo1 {
-    foo1() = default;
     foo1(int i, bool b):t(i, b), seo(t) {}
     std::tuple<int, bool> t;
     msgpack::type::size_equal_only<std::tuple<int, bool> > seo;
@@ -194,7 +203,6 @@ struct foo1 {
 };
 
 struct foo2 {
-    foo2() = default;
     foo2(int i, bool b, std::string const& s):t(i, b, s), seo(t) {}
     std::tuple<int, bool, std::string> t;
     msgpack::type::size_equal_only<std::tuple<int, bool, std::string> > seo;
@@ -206,7 +214,8 @@ TEST(size_equal_only, custom_class)
     std::stringstream ss;
     foo1 f1(42, true);
     msgpack::pack(ss, f1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
 
     foo2 f2(123, false, "ABC");
     try {