Script 'mail_helper' called by obssrc
Hello community,
here is the log from the commit of package msgpack-cxx for openSUSE:Factory
checked in at 2023-11-30 21:59:57
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/msgpack-cxx (Old)
and /work/SRC/openSUSE:Factory/.msgpack-cxx.new.25432 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "msgpack-cxx"
Thu Nov 30 21:59:57 2023 rev:4 rq:1122999 version:6.1.0
Changes:
--------
--- /work/SRC/openSUSE:Factory/msgpack-cxx/msgpack-cxx.changes 2022-12-05
18:00:51.476469442 +0100
+++ /work/SRC/openSUSE:Factory/.msgpack-cxx.new.25432/msgpack-cxx.changes
2023-11-30 22:00:52.280065330 +0100
@@ -1,0 +2,7 @@
+Thu Nov 2 21:44:34 UTC 2023 - Jan Engelhardt <jeng...@inai.de>
+
+- Update to release 6.1.0
+ * Remove dependency on boost in chrono.hpp
+ * Add support for std::variant behavior
+
+-------------------------------------------------------------------
Old:
----
msgpack-cxx-4.1.3.tar.gz
New:
----
msgpack-cxx-6.1.0.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ msgpack-cxx.spec ++++++
--- /var/tmp/diff_new_pack.NiDkUr/_old 2023-11-30 22:00:53.280102169 +0100
+++ /var/tmp/diff_new_pack.NiDkUr/_new 2023-11-30 22:00:53.280102169 +0100
@@ -1,7 +1,7 @@
#
# spec file for package msgpack-cxx
#
-# Copyright (c) 2022 SUSE LLC
+# Copyright (c) 2023 SUSE LLC
#
# All modifications and additions to the file contributed by third parties
# remain the property of their copyright owners, unless otherwise agreed
@@ -17,7 +17,7 @@
Name: msgpack-cxx
-Version: 4.1.3
+Version: 6.1.0
Release: 0
Summary: Object serialization library for cross-language communication
(C++ interface)
License: BSL-1.0
@@ -27,6 +27,7 @@
BuildRequires: boost-devel
BuildRequires: c++_compiler
BuildRequires: cmake
+BuildRequires: fdupes
BuildRequires: pkg-config
%description
@@ -37,9 +38,9 @@
Summary: Development headers for libmsgpack C++ library
Group: Development/Libraries/C and C++
Requires: libboost_headers-devel
-Requires: msgpack-c-devel >= 4
+Requires: msgpack-c-devel >= 6
Provides: libmsgpack-devel = %{version}-%{release}
-Conflicts: msgpack-devel < 4
+Conflicts: msgpack-devel < 6
%description devel
MessagePack is a binary-based object serialization library. It enables to
@@ -52,10 +53,11 @@
%build
%cmake
-%make_jobs
+%cmake_build
%install
%cmake_install
+%fdupes %buildroot/%_prefix
%files devel
%license COPYING
++++++ msgpack-cxx-4.1.3.tar.gz -> msgpack-cxx-6.1.0.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/msgpack-cxx-4.1.3/CMakeLists.txt
new/msgpack-cxx-6.1.0/CMakeLists.txt
--- old/msgpack-cxx-4.1.3/CMakeLists.txt 2022-09-07 05:49:03.000000000
+0200
+++ new/msgpack-cxx-6.1.0/CMakeLists.txt 2023-07-08 05:21:22.000000000
+0200
@@ -2,9 +2,9 @@
CMAKE_POLICY (SET CMP0054 NEW)
-PROJECT (msgpack LANGUAGES CXX)
+PROJECT (msgpack-cxx LANGUAGES CXX)
-ADD_LIBRARY (msgpackc-cxx INTERFACE)
+ADD_LIBRARY (msgpack-cxx INTERFACE)
FILE (READ ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/version_master.hpp
contents)
STRING (REGEX MATCH "#define MSGPACK_VERSION_MAJOR *([0-9a-zA-Z_]*)" NULL_OUT
${contents})
@@ -23,16 +23,17 @@
OPTION (MSGPACK_CXX17 "Using c++17 compiler" OFF)
OPTION (MSGPACK_CXX20 "Using c++20 compiler" OFF)
-OPTION (MSGPACK_32BIT "32bit compile" OFF)
-OPTION (MSGPACK_USE_BOOST "Use Boost libraried" ON)
-OPTION (MSGPACK_USE_X3_PARSE "Use Boost X3 parse" OFF)
-OPTION (MSGPACK_BUILD_TESTS "Build tests" OFF)
-OPTION (MSGPACK_BUILD_DOCS "Build Doxygen documentation" ON)
-OPTION (MSGPACK_FUZZ_REGRESSION "Enable regression testing" OFF)
-OPTION (MSGPACK_BUILD_EXAMPLES "Build msgpack examples" OFF)
-OPTION (MSGPACK_GEN_COVERAGE "Generate coverage report" OFF)
-OPTION (MSGPACK_USE_STATIC_BOOST "Statically link with boost libraries" OFF)
-OPTION (MSGPACK_CHAR_SIGN "Char sign to use (signed or unsigned)")
+OPTION (MSGPACK_32BIT "32bit compile"
OFF)
+OPTION (MSGPACK_USE_BOOST "Use Boost libraried"
ON)
+OPTION (MSGPACK_USE_X3_PARSE "Use Boost X3 parse"
OFF)
+OPTION (MSGPACK_BUILD_TESTS "Build tests"
OFF)
+OPTION (MSGPACK_BUILD_DOCS "Build Doxygen documentation"
ON)
+OPTION (MSGPACK_FUZZ_REGRESSION "Enable regression testing"
OFF)
+OPTION (MSGPACK_BUILD_EXAMPLES "Build msgpack examples"
OFF)
+OPTION (MSGPACK_GEN_COVERAGE "Generate coverage report"
OFF)
+OPTION (MSGPACK_USE_STATIC_BOOST "Statically link with boost libraries"
OFF)
+OPTION (MSGPACK_CHAR_SIGN "Char sign to use (signed or
unsigned)")
+OPTION (MSGPACK_USE_STD_VARIANT_ADAPTOR "Enable the adaptor for std::variant"
OFF)
SET (CMAKE_CXX_STANDARD_REQUIRED ON)
@@ -57,11 +58,11 @@
IF (MSGPACK_32BIT)
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
- TARGET_COMPILE_OPTIONS(msgpackc-cxx INTERFACE -m32)
- TARGET_LINK_OPTIONS(msgpackc-cxx INTERFACE -m32)
+ TARGET_COMPILE_OPTIONS(msgpack-cxx INTERFACE -m32)
+ TARGET_LINK_OPTIONS(msgpack-cxx INTERFACE -m32)
ELSEIF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
- TARGET_COMPILE_OPTIONS(msgpackc-cxx INTERFACE -m32)
- TARGET_LINK_OPTIONS(msgpackc-cxx INTERFACE -m32)
+ TARGET_COMPILE_OPTIONS(msgpack-cxx INTERFACE -m32)
+ TARGET_LINK_OPTIONS(msgpack-cxx INTERFACE -m32)
ENDIF ()
ENDIF ()
@@ -78,18 +79,22 @@
FIND_PACKAGE (Boost REQUIRED)
ELSE ()
- TARGET_COMPILE_DEFINITIONS(msgpackc-cxx INTERFACE MSGPACK_NO_BOOST)
+ TARGET_COMPILE_DEFINITIONS(msgpack-cxx INTERFACE MSGPACK_NO_BOOST)
ENDIF ()
IF (MSGPACK_CHAR_SIGN)
- TARGET_COMPILE_OPTIONS(msgpackc-cxx INTERFACE -f${MSGPACK_CHAR_SIGN}-char)
+ TARGET_COMPILE_OPTIONS(msgpack-cxx INTERFACE -f${MSGPACK_CHAR_SIGN}-char)
ENDIF ()
IF (MSGPACK_DEFAULT_API_VERSION)
- TARGET_COMPILE_DEFINITIONS(msgpackc-cxx INTERFACE
MSGPACK_DEFAULT_API_VERSION=${MSGPACK_DEFAULT_API_VERSION})
+ TARGET_COMPILE_DEFINITIONS(msgpack-cxx INTERFACE
MSGPACK_DEFAULT_API_VERSION=${MSGPACK_DEFAULT_API_VERSION})
ELSE ()
SET (MSGPACK_DEFAULT_API_VERSION 3)
- TARGET_COMPILE_DEFINITIONS(msgpackc-cxx INTERFACE
MSGPACK_DEFAULT_API_VERSION=3)
+ TARGET_COMPILE_DEFINITIONS(msgpack-cxx INTERFACE
MSGPACK_DEFAULT_API_VERSION=3)
+ENDIF ()
+
+IF (MSGPACK_USE_STD_VARIANT_ADAPTOR)
+ TARGET_COMPILE_DEFINITIONS(msgpack-cxx INTERFACE
MSGPACK_USE_STD_VARIANT_ADAPTOR)
ENDIF ()
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
@@ -112,7 +117,7 @@
INCLUDE (Files.cmake)
-TARGET_INCLUDE_DIRECTORIES (msgpackc-cxx
+TARGET_INCLUDE_DIRECTORIES (msgpack-cxx
INTERFACE
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
@@ -120,7 +125,7 @@
)
IF (MSGPACK_USE_BOOST)
- TARGET_LINK_LIBRARIES (msgpackc-cxx INTERFACE Boost::boost)
+ TARGET_LINK_LIBRARIES (msgpack-cxx INTERFACE Boost::boost)
ENDIF ()
IF (MSGPACK_GEN_COVERAGE)
@@ -156,7 +161,7 @@
ENDIF ()
IF ("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "sparc")
- TARGET_COMPILE_DEFINITIONS(msgpackc-cxx INTERFACE MSGPACK_ZONE_ALIGN=8)
+ TARGET_COMPILE_DEFINITIONS(msgpack-cxx INTERFACE MSGPACK_ZONE_ALIGN=8)
ENDIF ()
IF (MSGPACK_BUILD_EXAMPLES)
@@ -193,9 +198,9 @@
include (GNUInstallDirs)
# Install library.
-INSTALL (TARGETS msgpackc-cxx
- EXPORT msgpackc-cxx-targets
- COMPONENT msgpackc-cxx
+INSTALL (TARGETS msgpack-cxx
+ EXPORT msgpack-cxx-targets
+ COMPONENT msgpack-cxx
# This provides include directory in exported target
# relative to prefix in single directory we've put everything in.
INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
@@ -204,7 +209,7 @@
# Install headers from source tree.
INSTALL (DIRECTORY include/
DESTINATION include
- COMPONENT msgpackc-cxx
+ COMPONENT msgpack-cxx
)
INCLUDE (CMakePackageConfigHelpers)
@@ -212,18 +217,18 @@
IF (NOT (CMAKE_VERSION VERSION_LESS 3.14))
SET (extra_version_file_args ARCH_INDEPENDENT)
ENDIF ()
-SET (cmake_config_path "${CMAKE_INSTALL_LIBDIR}/cmake/msgpackc-cxx")
+SET (cmake_config_path "${CMAKE_INSTALL_LIBDIR}/cmake/msgpack-cxx")
# Configure the main package file from source tree.
CONFIGURE_PACKAGE_CONFIG_FILE (
- msgpack-config.cmake.in
- "${CMAKE_CURRENT_BINARY_DIR}/msgpack-config.cmake"
+ msgpack-cxx-config.cmake.in
+ "${CMAKE_CURRENT_BINARY_DIR}/msgpack-cxx-config.cmake"
INSTALL_DESTINATION "${cmake_config_path}"
)
# Write package version file.
WRITE_BASIC_PACKAGE_VERSION_FILE (
- msgpack-config-version.cmake
+ msgpack-cxx-config-version.cmake
VERSION ${VERSION}
COMPATIBILITY SameMajorVersion
${extra_version_file_args}
@@ -231,16 +236,16 @@
# Install the generated package version file and the main package file.
INSTALL (FILES
- "${CMAKE_CURRENT_BINARY_DIR}/msgpack-config.cmake"
- "${CMAKE_CURRENT_BINARY_DIR}/msgpack-config-version.cmake"
+ "${CMAKE_CURRENT_BINARY_DIR}/msgpack-cxx-config.cmake"
+ "${CMAKE_CURRENT_BINARY_DIR}/msgpack-cxx-config-version.cmake"
DESTINATION "${cmake_config_path}"
- COMPONENT msgpackc-cxx
+ COMPONENT msgpack-cxx
)
# This installs package in install tree for using installed targets.
INSTALL (
- EXPORT msgpackc-cxx-targets
- FILE msgpackc-cxx-targets.cmake
+ EXPORT msgpack-cxx-targets
+ FILE msgpack-cxx-targets.cmake
DESTINATION "${cmake_config_path}"
- COMPONENT msgpackc-cxx
+ COMPONENT msgpack-cxx
)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/msgpack-cxx-4.1.3/ChangeLog
new/msgpack-cxx-6.1.0/ChangeLog
--- old/msgpack-cxx-4.1.3/ChangeLog 2022-11-02 05:47:51.000000000 +0100
+++ new/msgpack-cxx-6.1.0/ChangeLog 2023-03-04 14:47:52.000000000 +0100
@@ -1,3 +1,13 @@
+# 2023-03-02 version 6.0.0
+## << breaking changes >>
+ * Change CMake package name of C++ library to msgpack-cxx (#1054)
+ Unified all C++ package, library, cmake, tarball name become msgpack-cxx.
+
+# 2023-01-10 version 5.0.0 for C++
+ * Fix config for new MSVC preprocessor (#1040)
+## << breaking changes >>
+ * Change CMake package name of C++ library to msgpackc-cxx (#1045, #1048)
+
# 2022-11-02 version 4.1.3 for C++
* Fix compile error that direct inclusion of chrono with `MSGPACK_NO_BOOST`
(#1038))
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/msgpack-cxx-4.1.3/Files.cmake
new/msgpack-cxx-6.1.0/Files.cmake
--- old/msgpack-cxx-4.1.3/Files.cmake 2022-09-07 06:25:24.000000000 +0200
+++ new/msgpack-cxx-6.1.0/Files.cmake 2023-07-08 05:28:00.000000000 +0200
@@ -1,4 +1,4 @@
-SET (msgpackc_HEADERS
+SET (msgpack-cxx_HEADERS
include/msgpack.hpp
include/msgpack/adaptor/adaptor_base.hpp
include/msgpack/adaptor/adaptor_base_decl.hpp
@@ -33,6 +33,7 @@
include/msgpack/adaptor/cpp17/carray_byte.hpp
include/msgpack/adaptor/cpp17/optional.hpp
include/msgpack/adaptor/cpp17/string_view.hpp
+ include/msgpack/adaptor/cpp17/variant.hpp
include/msgpack/adaptor/cpp17/vector_byte.hpp
include/msgpack/adaptor/cpp20/span.hpp
include/msgpack/adaptor/define.hpp
@@ -542,6 +543,7 @@
include/msgpack/v1/adaptor/cpp17/carray_byte.hpp
include/msgpack/v1/adaptor/cpp17/optional.hpp
include/msgpack/v1/adaptor/cpp17/string_view.hpp
+ include/msgpack/v1/adaptor/cpp17/variant.hpp
include/msgpack/v1/adaptor/cpp17/vector_byte.hpp
include/msgpack/v1/adaptor/cpp20/span.hpp
include/msgpack/v1/adaptor/define.hpp
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/msgpack-cxx-4.1.3/README new/msgpack-cxx-6.1.0/README
--- old/msgpack-cxx-4.1.3/README 2022-11-02 05:47:51.000000000 +0100
+++ new/msgpack-cxx-6.1.0/README 2023-03-04 14:47:52.000000000 +0100
@@ -1,7 +1,7 @@
`msgpack` for C++
===================
-Version 4.1.3 [](https://github.com/msgpack/msgpack-c/actions)
[](https://ci.appveyor.com/project/redboltz/msgpack-c/branch/cpp_master)
+Version 6.0.0 [](https://github.com/msgpack/msgpack-c/actions)
[](https://ci.appveyor.com/project/redboltz/msgpack-c/branch/cpp_master)
[](https://codecov.io/gh/msgpack/msgpack-c/branch/cpp_master)
It's like JSON but smaller and faster.
@@ -98,7 +98,7 @@
# ...
find_package(msgpack REQUIRED)
# ...
- target_link_libraries(your_target_name <PRIVATE/PUBLIC/INTERFACE>
msgpackc-cxx)
+ target_link_libraries(your_target_name <PRIVATE/PUBLIC/INTERFACE>
msgpack-cxx)
# ...
```
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/msgpack-cxx-4.1.3/README.md
new/msgpack-cxx-6.1.0/README.md
--- old/msgpack-cxx-4.1.3/README.md 2022-11-02 05:47:31.000000000 +0100
+++ new/msgpack-cxx-6.1.0/README.md 2023-07-08 06:16:09.000000000 +0200
@@ -1,7 +1,7 @@
`msgpack` for C++
===================
-Version 4.1.3 [](https://github.com/msgpack/msgpack-c/actions)
[](https://ci.appveyor.com/project/redboltz/msgpack-c/branch/cpp_master)
+Version 6.1.0 [](https://github.com/msgpack/msgpack-c/actions)
[](https://ci.appveyor.com/project/redboltz/msgpack-c/branch/cpp_master)
[](https://codecov.io/gh/msgpack/msgpack-c/branch/cpp_master)
It's like JSON but smaller and faster.
@@ -98,7 +98,7 @@
# ...
find_package(msgpack REQUIRED)
# ...
- target_link_libraries(your_target_name <PRIVATE/PUBLIC/INTERFACE>
msgpackc-cxx)
+ target_link_libraries(your_target_name <PRIVATE/PUBLIC/INTERFACE>
msgpack-cxx)
# ...
```
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/msgpack-cxx-4.1.3/example/boost/CMakeLists.txt
new/msgpack-cxx-6.1.0/example/boost/CMakeLists.txt
--- old/msgpack-cxx-4.1.3/example/boost/CMakeLists.txt 2022-08-25
11:56:15.000000000 +0200
+++ new/msgpack-cxx-6.1.0/example/boost/CMakeLists.txt 2023-07-08
05:21:22.000000000 +0200
@@ -21,7 +21,7 @@
${source_file}
)
TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
- msgpackc-cxx
+ msgpack-cxx
Boost::system
Threads::Threads
)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/msgpack-cxx-4.1.3/example/cpp03/CMakeLists.txt
new/msgpack-cxx-6.1.0/example/cpp03/CMakeLists.txt
--- old/msgpack-cxx-4.1.3/example/cpp03/CMakeLists.txt 2022-08-25
11:56:15.000000000 +0200
+++ new/msgpack-cxx-6.1.0/example/cpp03/CMakeLists.txt 2023-07-08
05:21:22.000000000 +0200
@@ -43,7 +43,7 @@
${source_file}
)
TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
- msgpackc-cxx
+ msgpack-cxx
)
IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" OR
"${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY
COMPILE_FLAGS " -Wall -Wextra")
@@ -64,7 +64,7 @@
${source_file}
)
TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
- msgpackc-cxx
+ msgpack-cxx
Threads::Threads
)
IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" OR
"${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
@@ -86,7 +86,7 @@
${source_file}
)
TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
- msgpackc-cxx
+ msgpack-cxx
Boost::timer
)
IF (NOT MSVC AND NOT APPLE)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/msgpack-cxx-4.1.3/example/cpp11/CMakeLists.txt
new/msgpack-cxx-6.1.0/example/cpp11/CMakeLists.txt
--- old/msgpack-cxx-4.1.3/example/cpp11/CMakeLists.txt 2022-08-25
11:56:15.000000000 +0200
+++ new/msgpack-cxx-6.1.0/example/cpp11/CMakeLists.txt 2023-07-08
05:21:22.000000000 +0200
@@ -17,7 +17,7 @@
${source_file}
)
TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
- msgpackc-cxx
+ msgpack-cxx
)
IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" OR
"${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY
COMPILE_FLAGS " -Wall -Wextra")
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/msgpack-cxx-4.1.3/example/x3/CMakeLists.txt
new/msgpack-cxx-6.1.0/example/x3/CMakeLists.txt
--- old/msgpack-cxx-4.1.3/example/x3/CMakeLists.txt 2022-08-25
11:56:15.000000000 +0200
+++ new/msgpack-cxx-6.1.0/example/x3/CMakeLists.txt 2023-07-08
05:21:22.000000000 +0200
@@ -15,7 +15,7 @@
${source_file_we}
${source_file}
)
- TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE msgpackc-cxx)
+ TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE msgpack-cxx)
IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" OR
"${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY
COMPILE_FLAGS " -Wall -Wextra")
@@ -40,7 +40,7 @@
${source_file}
)
TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
- msgpackc-cxx
+ msgpack-cxx
Boost::context
Boost::system
Threads::Threads
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/msgpack-cxx-4.1.3/fuzz/CMakeLists.txt
new/msgpack-cxx-6.1.0/fuzz/CMakeLists.txt
--- old/msgpack-cxx-4.1.3/fuzz/CMakeLists.txt 2022-08-25 11:56:15.000000000
+0200
+++ new/msgpack-cxx-6.1.0/fuzz/CMakeLists.txt 2023-07-08 05:21:22.000000000
+0200
@@ -16,7 +16,7 @@
$<IF:$<BOOL:${MSGPACK_USE_STATIC_BOOST}>,,BOOST_TEST_DYN_LINK>)
TARGET_LINK_LIBRARIES (${source_file_we}
- msgpackc-cxx
+ msgpack-cxx
Threads::Threads
Boost::filesystem
Boost::system
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/msgpack-cxx-4.1.3/include/msgpack/adaptor/cpp17/variant.hpp
new/msgpack-cxx-6.1.0/include/msgpack/adaptor/cpp17/variant.hpp
--- old/msgpack-cxx-4.1.3/include/msgpack/adaptor/cpp17/variant.hpp
1970-01-01 01:00:00.000000000 +0100
+++ new/msgpack-cxx-6.1.0/include/msgpack/adaptor/cpp17/variant.hpp
2023-07-08 05:21:22.000000000 +0200
@@ -0,0 +1,16 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2023 Uy Ha
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef MSGPACK_TYPE_CPP17_VARIANT_HPP
+#define MSGPACK_TYPE_CPP17_VARIANT_HPP
+
+#include "msgpack/v1/adaptor/cpp17/variant.hpp"
+
+#endif // MSGPACK_TYPE_CPP17_VARIANT_HPP
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/msgpack-cxx-4.1.3/include/msgpack/preprocessor/config/config.hpp
new/msgpack-cxx-6.1.0/include/msgpack/preprocessor/config/config.hpp
--- old/msgpack-cxx-4.1.3/include/msgpack/preprocessor/config/config.hpp
2022-08-25 11:56:15.000000000 +0200
+++ new/msgpack-cxx-6.1.0/include/msgpack/preprocessor/config/config.hpp
2023-07-08 05:21:22.000000000 +0200
@@ -24,16 +24,22 @@
# define MSGPACK_PP_CONFIG_EDG() 0x0020
# define MSGPACK_PP_CONFIG_DMC() 0x0040
#
+# if !defined(__clang__) && (!defined(_MSVC_TRADITIONAL) || _MSVC_TRADITIONAL)
+# define MSGPACK_TRADITIONAL_MSVC 1
+# else
+# define MSGPACK_TRADITIONAL_MSVC 0
+# endif
+#
# ifndef MSGPACK_PP_CONFIG_FLAGS
# if defined(__GCCXML__) || defined(__WAVE__) || defined(__MWERKS__) &&
__MWERKS__ >= 0x3200
# define MSGPACK_PP_CONFIG_FLAGS() (MSGPACK_PP_CONFIG_STRICT())
# elif defined(__EDG__) || defined(__EDG_VERSION__)
-# if defined(_MSC_VER) && !defined(__clang__) &&
(defined(__INTELLISENSE__) || __EDG_VERSION__ >= 308)
+# if defined(_MSC_VER) && MSGPACK_TRADITIONAL_MSVC &&
(defined(__INTELLISENSE__) || __EDG_VERSION__ >= 308)
# define MSGPACK_PP_CONFIG_FLAGS() (MSGPACK_PP_CONFIG_MSVC())
# else
# define MSGPACK_PP_CONFIG_FLAGS() (MSGPACK_PP_CONFIG_EDG() |
MSGPACK_PP_CONFIG_STRICT())
# endif
-# elif defined(_MSC_VER) && defined(__clang__)
+# elif defined(_MSC_VER) && !MSGPACK_TRADITIONAL_MSVC
# define MSGPACK_PP_CONFIG_FLAGS() (MSGPACK_PP_CONFIG_STRICT())
# elif defined(__MWERKS__)
# define MSGPACK_PP_CONFIG_FLAGS() (MSGPACK_PP_CONFIG_MWCC())
@@ -75,7 +81,7 @@
# define MSGPACK_PP_VARIADICS 0
# elif defined(__CUDACC__)
# define MSGPACK_PP_VARIADICS 1
-# elif defined(_MSC_VER) && defined(__clang__)
+# elif defined(_MSC_VER) && !MSGPACK_TRADITIONAL_MSVC
# define MSGPACK_PP_VARIADICS 1
# /* VC++ (C/C++) and Intel C++ Compiler >= 17.0 with MSVC */
# elif defined _MSC_VER && _MSC_VER >= 1400 && (!defined __EDG__ ||
defined(__INTELLISENSE__) || defined(__INTEL_COMPILER) && __INTEL_COMPILER >=
1700)
@@ -94,7 +100,7 @@
# elif !MSGPACK_PP_VARIADICS + 1 < 2
# undef MSGPACK_PP_VARIADICS
# define MSGPACK_PP_VARIADICS 1
-# if defined _MSC_VER && _MSC_VER >= 1400 && !defined(__clang__) &&
(defined(__INTELLISENSE__) || (defined(__INTEL_COMPILER) && __INTEL_COMPILER >=
1700) || !(defined __EDG__ || defined __GCCXML__ || defined __CUDACC__ ||
defined __PATHSCALE__ || defined __DMC__ || defined __CODEGEARC__ || defined
__BORLANDC__ || defined __MWERKS__ || defined __SUNPRO_CC || defined __HP_aCC
|| defined __MRC__ || defined __SC__ || defined __IBMCPP__ || defined __PGI))
+# if defined _MSC_VER && _MSC_VER >= 1400 && MSGPACK_TRADITIONAL_MSVC &&
(defined(__INTELLISENSE__) || (defined(__INTEL_COMPILER) && __INTEL_COMPILER >=
1700) || !(defined __EDG__ || defined __GCCXML__ || defined __CUDACC__ ||
defined __PATHSCALE__ || defined __DMC__ || defined __CODEGEARC__ || defined
__BORLANDC__ || defined __MWERKS__ || defined __SUNPRO_CC || defined __HP_aCC
|| defined __MRC__ || defined __SC__ || defined __IBMCPP__ || defined __PGI))
# undef MSGPACK_PP_VARIADICS_MSVC
# define MSGPACK_PP_VARIADICS_MSVC 1
# endif
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/msgpack-cxx-4.1.3/include/msgpack/type.hpp
new/msgpack-cxx-6.1.0/include/msgpack/type.hpp
--- old/msgpack-cxx-4.1.3/include/msgpack/type.hpp 2022-08-25
11:56:15.000000000 +0200
+++ new/msgpack-cxx-6.1.0/include/msgpack/type.hpp 2023-07-08
05:21:22.000000000 +0200
@@ -37,9 +37,7 @@
#include "adaptor/cpp11/array_char.hpp"
#include "adaptor/cpp11/array_unsigned_char.hpp"
-#if !defined(MSGPACK_NO_BOOST)
#include "adaptor/cpp11/chrono.hpp"
-#endif // !defined(MSGPACK_NO_BOOST)
#include "adaptor/cpp11/forward_list.hpp"
#include "adaptor/cpp11/reference_wrapper.hpp"
@@ -63,6 +61,10 @@
#include "adaptor/cpp17/carray_byte.hpp"
#include "adaptor/cpp17/vector_byte.hpp"
+#if MSGPACK_HAS_INCLUDE(<variant>)
+#include "adaptor/cpp17/variant.hpp"
+#endif // MSGPACK_HAS_INCLUDE(<variant>)
+
#if MSGPACK_HAS_INCLUDE(<span>)
#include "adaptor/cpp20/span.hpp"
#endif // MSGPACK_HAS_INCLUDE(<span>)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/msgpack-cxx-4.1.3/include/msgpack/v1/adaptor/boost/msgpack_variant.hpp
new/msgpack-cxx-6.1.0/include/msgpack/v1/adaptor/boost/msgpack_variant.hpp
--- old/msgpack-cxx-4.1.3/include/msgpack/v1/adaptor/boost/msgpack_variant.hpp
2022-08-25 11:56:15.000000000 +0200
+++ new/msgpack-cxx-6.1.0/include/msgpack/v1/adaptor/boost/msgpack_variant.hpp
2023-07-08 05:21:22.000000000 +0200
@@ -122,6 +122,12 @@
int_init(v);
}
basic_variant(unsigned long long v):base(uint64_t(v)) {}
+ basic_variant(float v) {
+ double_init(v);
+ }
+ basic_variant(double v) {
+ double_init(v);
+ }
bool is_nil() const {
return boost::get<msgpack::type::nil_t>(this) != MSGPACK_NULLPTR;
@@ -177,71 +183,50 @@
int64_t as_int64_t() const {
return boost::get<int64_t>(*this);
}
- int64_t& as_int64_t() {
- return boost::get<int64_t>(*this);
- }
uint64_t as_uint64_t() const {
return boost::get<uint64_t>(*this);
}
- uint64_t& as_uint64_t() {
- return boost::get<uint64_t>(*this);
- }
double as_double() const {
- return boost::get<double>(*this);
- }
- double& as_double() {
- return boost::get<double>(*this);
+ if (is_double()) {
+ return boost::get<double>(*this);
+ }
+ if (is_int64_t()) {
+ return static_cast<double>(boost::get<int64_t>(*this));
+ }
+ if (is_uint64_t()) {
+ return static_cast<double>(boost::get<uint64_t>(*this));
+ }
+ throw msgpack::type_error();
}
std::string const& as_string() const {
return boost::get<std::string>(*this);
}
- std::string& as_string() {
- return boost::get<std::string>(*this);
- }
#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
boost::string_ref const& as_boost_string_ref() const {
return boost::get<boost::string_ref>(*this);
}
- boost::string_ref& as_boost_string_ref() {
- return boost::get<boost::string_ref>(*this);
- }
#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
std::vector<char> const& as_vector_char() const {
return boost::get<std::vector<char> >(*this);
}
- std::vector<char>& as_vector_char() {
- return boost::get<std::vector<char> >(*this);
- }
raw_ref const& as_raw_ref() const {
return boost::get<raw_ref>(*this);
}
ext const& as_ext() const {
return boost::get<ext>(*this);
}
- ext& as_ext() {
- return boost::get<ext>(*this);
- }
ext_ref const& as_ext_ref() const {
return boost::get<ext_ref>(*this);
}
std::vector<basic_variant<STR, BIN, EXT> > const& as_vector() const {
return boost::get<std::vector<basic_variant<STR, BIN, EXT> > >(*this);
}
- std::vector<basic_variant<STR, BIN, EXT> >& as_vector() {
- return boost::get<std::vector<basic_variant<STR, BIN, EXT> > >(*this);
- }
std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> >
const& as_map() const {
return boost::get<std::map<basic_variant<STR, BIN, EXT>,
basic_variant<STR, BIN, EXT> > >(*this);
}
- std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> >&
as_map() {
- return boost::get<std::map<basic_variant<STR, BIN, EXT>,
basic_variant<STR, BIN, EXT> > >(*this);
- }
std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> >
const& as_multimap() const {
return boost::get<std::multimap<basic_variant<STR, BIN, EXT>,
basic_variant<STR, BIN, EXT> > >(*this);
}
- std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT>
>& as_multimap() {
- return boost::get<std::multimap<basic_variant<STR, BIN, EXT>,
basic_variant<STR, BIN, EXT> > >(*this);
- }
private:
template <typename T>
void int_init(T v) {
@@ -252,6 +237,19 @@
static_cast<base&>(*this) = uint64_t(v);
}
}
+ void double_init(double v) {
+ if (v == v) { // check for nan
+ if (v >= 0 && v <= double(std::numeric_limits<uint64_t>::max()) &&
v == double(uint64_t(v))) {
+ static_cast<base&>(*this) = uint64_t(v);
+ return;
+ }
+ else if (v < 0 && v >= double(std::numeric_limits<int64_t>::min())
&& v == double(int64_t(v))) {
+ static_cast<base&>(*this) = int64_t(v);
+ return;
+ }
+ }
+ static_cast<base&>(*this) = v;
+ }
};
template <typename STR, typename BIN, typename EXT>
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/msgpack-cxx-4.1.3/include/msgpack/v1/adaptor/cpp11/chrono.hpp
new/msgpack-cxx-6.1.0/include/msgpack/v1/adaptor/cpp11/chrono.hpp
--- old/msgpack-cxx-4.1.3/include/msgpack/v1/adaptor/cpp11/chrono.hpp
2022-11-02 04:53:39.000000000 +0100
+++ new/msgpack-cxx-6.1.0/include/msgpack/v1/adaptor/cpp11/chrono.hpp
2023-07-08 05:21:22.000000000 +0200
@@ -11,17 +11,14 @@
#ifndef MSGPACK_V1_TYPE_CPP11_CHRONO_HPP
#define MSGPACK_V1_TYPE_CPP11_CHRONO_HPP
-#if !defined(MSGPACK_NO_BOOST)
-
#include "msgpack/versioning.hpp"
#include "msgpack/adaptor/adaptor_base.hpp"
#include "msgpack/object.hpp"
#include "msgpack/adaptor/check_container_size.hpp"
+#include <limits>
#include <chrono>
-#include <boost/numeric/conversion/cast.hpp>
-
namespace msgpack {
/// @cond
@@ -30,6 +27,113 @@
namespace adaptor {
+namespace detail {
+template <
+ typename Target,
+ typename Source,
+ bool target_is_signed = std::is_signed<Target>::value,
+ bool source_is_signed = std::is_signed<Source>::value,
+ typename = typename std::enable_if<
+ std::is_integral<Target>::value &&
+ std::is_integral<Source>::value
+ >::type
+>
+struct would_underflow {
+ // The default case includes the cases that Source being unsigned, and
since Source
+ // is unsigned, no underflow can happen
+ would_underflow(Source) : value{false} {}
+ bool value;
+};
+
+template <typename Target, typename Source>
+struct would_underflow<Target, Source, false, true> {
+ // When Source is signed and Target is unsigned, we only need to compare
with 0 to
+ // detect underflow, this works correctly and also avoids warnings from
the compiler
+ would_underflow(Source source) : value{source < 0} {}
+ bool value;
+};
+template <typename Target, typename Source>
+struct would_underflow<Target, Source, true, true> {
+ // When Source and Target are signed, the promotion rules apply sensibly
so we do
+ // not need to do anything
+ would_underflow(Source source)
+ : value{source < std::numeric_limits<Target>::min()} {}
+ bool value;
+};
+
+template <
+ typename Target,
+ typename Source,
+ bool target_is_signed = std::is_signed<Target>::value,
+ bool source_is_signed = std::is_signed<Source>::value,
+ typename = typename std::enable_if<
+ std::is_integral<Target>::value &&
+ std::is_integral<Source>::value
+ >::type
+>
+struct would_overflow {
+ // The default case is Source and Target having the same signedness, the
promotion
+ // rule also apply sensibly here so nothing special needs to be done
+ would_overflow(Source source)
+ : value{source > std::numeric_limits<Target>::max()} {}
+ bool value;
+};
+template <typename Target, typename Source>
+struct would_overflow <Target, Source, false, true> {
+ // When Target is unsigned and Source is signed, we cannot rely on the
promotion
+ // rule.
+ would_overflow(Source source)
+ : value{
+ sizeof(Target) >= sizeof(Source)
+ // Given Source is signed, Target being unsigned and having at
least the
+ // same size makes impossible to overflow
+ ? false
+ // Source being larger than Target makes it safe to cast the
maximum value
+ // of Target to Source
+ : source >
static_cast<Source>(std::numeric_limits<Target>::max())
+ } {}
+ bool value;
+};
+template <typename Target, typename Source>
+struct would_overflow <Target, Source, true, false> {
+ // When Target is signed and Source is unsigned, we cannot rely on the
promotion
+ // rule.
+ would_overflow(Source source)
+ : value{
+ sizeof(Target) > sizeof(Source)
+ // Target being larger than Source makes it impossible to
overflow
+ ? false
+ // Source being unsigned and having at least the size of Target
makes it
+ // safe to cast the maximum value of Target to Source
+ : source >
static_cast<Source>(std::numeric_limits<Target>::max())
+ } {}
+ bool value;
+};
+
+template <
+ typename Target,
+ typename Source,
+ typename = typename std::enable_if<
+ std::is_integral<Target>::value &&
+ std::is_integral<Source>::value
+ >::type
+>
+Target integral_cast(Source source) {
+ if (would_underflow<Target, Source>(source).value) {
+ throw std::underflow_error{
+ "casting from Source to Target causes an underflow error"
+ };
+ }
+ if(would_overflow<Target, Source>(source).value) {
+ throw std::overflow_error{
+ "casting from Source to Target causes an overflow error"
+ };
+ }
+
+ return static_cast<Target>(source);
+}
+} // namespace detail
+
template <typename Clock, typename Duration>
struct as<std::chrono::time_point<Clock, Duration>> {
typename std::chrono::time_point<Clock, Duration>
operator()(msgpack::object const& o) const {
@@ -45,7 +149,7 @@
case 8: {
uint64_t value;
_msgpack_load64(uint64_t, o.via.ext.data(), &value);
- uint32_t nanosec = boost::numeric_cast<uint32_t>(value >> 34);
+ uint32_t nanosec = detail::integral_cast<uint32_t>(value >> 34);
uint64_t sec = value & 0x00000003ffffffffLL;
tp += std::chrono::duration_cast<Duration>(
std::chrono::nanoseconds(nanosec));
@@ -69,7 +173,7 @@
else {
++sec;
tp += std::chrono::seconds(sec);
- int64_t ns = boost::numeric_cast<int64_t>(nanosec) -
1000000000L;
+ int64_t ns = detail::integral_cast<int64_t>(nanosec) -
1000000000L;
tp += std::chrono::duration_cast<Duration>(
std::chrono::nanoseconds(ns));
}
@@ -98,7 +202,7 @@
case 8: {
uint64_t value;
_msgpack_load64(uint64_t, o.via.ext.data(), &value);
- uint32_t nanosec = boost::numeric_cast<uint32_t>(value >> 34);
+ uint32_t nanosec = detail::integral_cast<uint32_t>(value >> 34);
uint64_t sec = value & 0x00000003ffffffffLL;
tp += std::chrono::duration_cast<Duration>(
std::chrono::nanoseconds(nanosec));
@@ -123,7 +227,7 @@
else {
++sec;
tp += std::chrono::seconds(sec);
- int64_t ns = boost::numeric_cast<int64_t>(nanosec) -
1000000000L;
+ int64_t ns = detail::integral_cast<int64_t>(nanosec) -
1000000000L;
tp += std::chrono::duration_cast<Duration>(
std::chrono::nanoseconds(ns));
}
@@ -142,7 +246,7 @@
struct pack<std::chrono::time_point<Clock, Duration>> {
template <typename Stream>
msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o,
std::chrono::time_point<Clock, Duration> const& v) const {
- int64_t count =
boost::numeric_cast<int64_t>(v.time_since_epoch().count());
+ int64_t count =
detail::integral_cast<int64_t>(v.time_since_epoch().count());
int64_t nano_num =
Duration::period::ratio::num *
(1000000000L / Duration::period::ratio::den);
@@ -158,11 +262,11 @@
/ Duration::period::ratio::den;
if ((sec >> 34) == 0) {
- uint64_t data64 = (boost::numeric_cast<uint64_t>(nanosec) << 34) |
boost::numeric_cast<uint64_t>(sec);
+ uint64_t data64 = (detail::integral_cast<uint64_t>(nanosec) << 34)
| detail::integral_cast<uint64_t>(sec);
if ((data64 & 0xffffffff00000000L) == 0) {
// timestamp 32
o.pack_ext(4, -1);
- uint32_t data32 = boost::numeric_cast<uint32_t>(data64);
+ uint32_t data32 = detail::integral_cast<uint32_t>(data64);
char buf[4];
_msgpack_store32(buf, data32);
o.pack_ext_body(buf, 4);
@@ -181,7 +285,7 @@
char buf[12];
- _msgpack_store32(&buf[0], boost::numeric_cast<uint32_t>(nanosec));
+ _msgpack_store32(&buf[0],
detail::integral_cast<uint32_t>(nanosec));
_msgpack_store64(&buf[4], sec);
o.pack_ext_body(buf, 12);
}
@@ -192,7 +296,7 @@
template <typename Clock, typename Duration>
struct object_with_zone<std::chrono::time_point<Clock, Duration>> {
void operator()(msgpack::object::with_zone& o, const
std::chrono::time_point<Clock, Duration>& v) const {
- int64_t count =
boost::numeric_cast<int64_t>(v.time_since_epoch().count());
+ int64_t count =
detail::integral_cast<int64_t>(v.time_since_epoch().count());
int64_t nano_num =
Duration::period::ratio::num *
@@ -208,14 +312,14 @@
* Duration::period::ratio::num
/ Duration::period::ratio::den;
if ((sec >> 34) == 0) {
- uint64_t data64 = (boost::numeric_cast<uint64_t>(nanosec) << 34) |
boost::numeric_cast<uint64_t>(sec);
+ uint64_t data64 = (detail::integral_cast<uint64_t>(nanosec) << 34)
| detail::integral_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] = static_cast<char>(-1);
- uint32_t data32 = boost::numeric_cast<uint32_t>(data64);
+ uint32_t data32 = detail::integral_cast<uint32_t>(data64);
_msgpack_store32(&p[1], data32);
o.via.ext.ptr = p;
}
@@ -235,7 +339,7 @@
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], boost::numeric_cast<uint32_t>(nanosec));
+ _msgpack_store32(&p[1], detail::integral_cast<uint32_t>(nanosec));
_msgpack_store64(&p[1 + 4], sec);
o.via.ext.ptr = p;
}
@@ -250,6 +354,4 @@
} // namespace msgpack
-#endif // !defined(MSGPACK_NO_BOOST)
-
#endif // MSGPACK_V1_TYPE_CPP11_CHRONO_HPP
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/msgpack-cxx-4.1.3/include/msgpack/v1/adaptor/cpp17/variant.hpp
new/msgpack-cxx-6.1.0/include/msgpack/v1/adaptor/cpp17/variant.hpp
--- old/msgpack-cxx-4.1.3/include/msgpack/v1/adaptor/cpp17/variant.hpp
1970-01-01 01:00:00.000000000 +0100
+++ new/msgpack-cxx-6.1.0/include/msgpack/v1/adaptor/cpp17/variant.hpp
2023-07-08 05:21:22.000000000 +0200
@@ -0,0 +1,151 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2023 Uy Ha
+//
+// 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_VARIANT_HPP
+#define MSGPACK_V1_TYPE_VARIANT_HPP
+
+#if defined(MSGPACK_USE_STD_VARIANT_ADAPTOR)
+
+#include "msgpack/cpp_version.hpp"
+
+#if MSGPACK_CPP_VERSION >= 201703
+
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/object.hpp"
+#include "msgpack/versioning.hpp"
+
+#include <variant>
+
+namespace msgpack {
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+namespace adaptor {
+namespace detail {
+template <
+ typename Variant,
+ typename T,
+ typename... Ts,
+ std::size_t current_index,
+ std::size_t... indices
+>
+Variant construct_variant(
+ std::size_t index,
+ msgpack::object& object,
+ std::index_sequence<current_index, indices...>
+) {
+ if constexpr(sizeof...(Ts) == 0) {
+ return object.as<T>();
+ }
+ else {
+ if (index == current_index) {
+ return object.as<T>();
+ }
+ return construct_variant<Variant, Ts...>(
+ index,
+ object,
+ std::index_sequence<indices...>()
+ );
+ }
+}
+
+struct object_variant_overload {
+ object_variant_overload(msgpack::object& obj, msgpack::zone& zone)
+ : obj{obj}
+ , zone{zone} {}
+
+ template<typename T>
+ void operator()(T const& value) {
+ obj = msgpack::object(value, zone);
+ }
+
+ msgpack::object& obj;
+ msgpack::zone& zone;
+};
+} // namespace detail
+
+template <typename... Ts>
+struct as<std::variant<Ts...>, typename
std::enable_if<(msgpack::has_as<Ts>::value && ...)>::type> {
+ std::variant<Ts...> operator()(msgpack::object const& o) const {
+ if ( o.type != msgpack::type::ARRAY
+ || o.via.array.size != 2
+ || o.via.array.ptr[0].type != msgpack::type::POSITIVE_INTEGER
+ || o.via.array.ptr[0].via.u64 >= sizeof...(Ts)) {
+ throw msgpack::type_error{};
+ }
+
+ return detail::construct_variant<std::variant<Ts...>, Ts...>(
+ o.via.array.ptr[0].as<std::size_t>(),
+ o.via.array.ptr[1],
+ std::make_index_sequence<sizeof...(Ts)>()
+ );
+ }
+};
+
+template<typename... Ts>
+struct convert<std::variant<Ts...>> {
+ msgpack::object const& operator()(msgpack::object const& o,
std::variant<Ts...>& v) const {
+ if ( o.type != msgpack::type::ARRAY
+ || o.via.array.size != 2
+ || o.via.array.ptr[0].type != msgpack::type::POSITIVE_INTEGER
+ || o.via.array.ptr[0].via.u64 >= sizeof...(Ts)) {
+ throw msgpack::type_error{};
+ }
+
+ v = detail::construct_variant<std::variant<Ts...>, Ts...>(
+ o.via.array.ptr[0].as<std::size_t>(),
+ o.via.array.ptr[1],
+ std::make_index_sequence<sizeof...(Ts)>()
+ );
+ return o;
+ }
+};
+
+template <typename... Ts>
+struct pack<std::variant<Ts...>>{
+ template<typename Stream>
+ msgpack::packer<Stream>& operator()(
+ msgpack::packer<Stream>& o,
+ std::variant<Ts...> const& v
+ ) const {
+ o.pack_array(2);
+ o.pack_uint64(v.index());
+ std::visit([&o](auto const& value){o.pack(value);}, v);
+ return o;
+ }
+};
+
+
+template<typename... Ts>
+struct object_with_zone<std::variant<Ts...>> {
+ void operator()(
+ msgpack::object::with_zone& o,
+ std::variant<Ts...> const& v
+ ) const {
+ msgpack::object *p =
+ static_cast<msgpack::object *>(
+ o.zone.allocate_align(
+ sizeof(msgpack::object) * 2,
+ MSGPACK_ZONE_ALIGNOF(msgpack::object)
+ )
+ );
+
+ o.type = msgpack::type::ARRAY;
+ o.via.array.size = 2;
+ o.via.array.ptr = p;
+ o.via.array.ptr[0]= msgpack::object(v.index(), o.zone);
+ std::visit(detail::object_variant_overload(o.via.array.ptr[1],
o.zone), v);
+ }
+};
+} // namespace adaptor
+}
+} // namespace msgpack
+
+#endif // MSGPACK_CPP_VERSION >= 201703
+#endif // defined(MSGPACK_USE_STD_VARIANT_ADAPTOR)
+#endif // MSGPACK_V1_TYPE_VARIANT_HPP
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/msgpack-cxx-4.1.3/include/msgpack/v1/pack.hpp
new/msgpack-cxx-6.1.0/include/msgpack/v1/pack.hpp
--- old/msgpack-cxx-4.1.3/include/msgpack/v1/pack.hpp 2022-08-25
11:56:15.000000000 +0200
+++ new/msgpack-cxx-6.1.0/include/msgpack/v1/pack.hpp 2023-07-08
05:21:22.000000000 +0200
@@ -1138,11 +1138,11 @@
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_float(float d)
{
- if(d == d) { // check for nan
+ if(d == d) { // check for nan
// compare d to limits to avoid undefined behaviour
if(d >= 0 && d <= float(std::numeric_limits<uint64_t>::max()) && d ==
float(uint64_t(d))) {
pack_imp_uint64(uint64_t(d));
- return *this;
+ return *this;
} else if(d < 0 && d >= float(std::numeric_limits<int64_t>::min()) &&
d == float(int64_t(d))) {
pack_imp_int64(int64_t(d));
return *this;
@@ -1160,11 +1160,11 @@
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_double(double d)
{
- if(d == d) { // check for nan
+ if(d == d) { // check for nan
// compare d to limits to avoid undefined behaviour
if(d >= 0 && d <= double(std::numeric_limits<uint64_t>::max()) && d ==
double(uint64_t(d))) {
pack_imp_uint64(uint64_t(d));
- return *this;
+ return *this;
} else if(d < 0 && d >= double(std::numeric_limits<int64_t>::min()) &&
d == double(int64_t(d))) {
pack_imp_int64(int64_t(d));
return *this;
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/msgpack-cxx-4.1.3/include/msgpack/version_master.hpp
new/msgpack-cxx-6.1.0/include/msgpack/version_master.hpp
--- old/msgpack-cxx-4.1.3/include/msgpack/version_master.hpp 2022-11-02
05:47:31.000000000 +0100
+++ new/msgpack-cxx-6.1.0/include/msgpack/version_master.hpp 2023-07-08
06:16:09.000000000 +0200
@@ -1,3 +1,3 @@
-#define MSGPACK_VERSION_MAJOR 4
+#define MSGPACK_VERSION_MAJOR 6
#define MSGPACK_VERSION_MINOR 1
-#define MSGPACK_VERSION_REVISION 3
+#define MSGPACK_VERSION_REVISION 0
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/msgpack-cxx-4.1.3/msgpack-config.cmake.in
new/msgpack-cxx-6.1.0/msgpack-config.cmake.in
--- old/msgpack-cxx-4.1.3/msgpack-config.cmake.in 2022-09-07
05:49:03.000000000 +0200
+++ new/msgpack-cxx-6.1.0/msgpack-config.cmake.in 1970-01-01
01:00:00.000000000 +0100
@@ -1,11 +0,0 @@
-@PACKAGE_INIT@
-
-include(CMakeFindDependencyMacro)
-
-IF (@MSGPACK_USE_BOOST@)
- find_dependency(Boost REQUIRED)
-ENDIF ()
-
-include("${CMAKE_CURRENT_LIST_DIR}/msgpackc-cxx-targets.cmake")
-
-check_required_components(msgpackc-cxx)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/msgpack-cxx-4.1.3/msgpack-cxx-config.cmake.in
new/msgpack-cxx-6.1.0/msgpack-cxx-config.cmake.in
--- old/msgpack-cxx-4.1.3/msgpack-cxx-config.cmake.in 1970-01-01
01:00:00.000000000 +0100
+++ new/msgpack-cxx-6.1.0/msgpack-cxx-config.cmake.in 2023-07-08
05:21:22.000000000 +0200
@@ -0,0 +1,11 @@
+@PACKAGE_INIT@
+
+include(CMakeFindDependencyMacro)
+
+IF (@MSGPACK_USE_BOOST@)
+ find_dependency(Boost REQUIRED)
+ENDIF ()
+
+include("${CMAKE_CURRENT_LIST_DIR}/msgpack-cxx-targets.cmake")
+
+check_required_components(msgpack-cxx)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/msgpack-cxx-4.1.3/test/CMakeLists.txt
new/msgpack-cxx-6.1.0/test/CMakeLists.txt
--- old/msgpack-cxx-4.1.3/test/CMakeLists.txt 2022-08-25 11:56:15.000000000
+0200
+++ new/msgpack-cxx-6.1.0/test/CMakeLists.txt 2023-07-08 05:21:22.000000000
+0200
@@ -78,7 +78,7 @@
$<IF:$<BOOL:${MSGPACK_USE_STATIC_BOOST}>,,BOOST_TEST_DYN_LINK>)
TARGET_LINK_LIBRARIES (${source_file_we}
- msgpackc-cxx
+ msgpack-cxx
Boost::system
Boost::unit_test_framework
Threads::Threads
@@ -109,7 +109,7 @@
)
TARGET_LINK_LIBRARIES (multi_file
- msgpackc-cxx
+ msgpack-cxx
)
ADD_TEST (multi_file multi_file)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/msgpack-cxx-4.1.3/test/boost_variant.cpp
new/msgpack-cxx-6.1.0/test/boost_variant.cpp
--- old/msgpack-cxx-4.1.3/test/boost_variant.cpp 2022-08-25
11:56:15.000000000 +0200
+++ new/msgpack-cxx-6.1.0/test/boost_variant.cpp 2023-07-08
05:21:22.000000000 +0200
@@ -264,7 +264,7 @@
BOOST_CHECK(val2.is_double());
BOOST_CHECK(fabs(12.34 - val2.as_double()) <= kEPS);
BOOST_CHECK_NO_THROW(boost::get<double>(val2));
- BOOST_CHECK(fabs(val2.as_double() - val2.as_double()) <= kEPS);
+ BOOST_CHECK(fabs(val1.as_double() - val2.as_double()) <= kEPS);
}
BOOST_AUTO_TEST_CASE(object_variant_float)
@@ -277,7 +277,8 @@
BOOST_CHECK(val2.is_double());
BOOST_CHECK(fabs(12.34 - val2.as_double()) <= kEPS);
BOOST_CHECK_NO_THROW(boost::get<double>(val2));
- BOOST_CHECK(fabs(val2.as_double() - val2.as_double()) <= kEPS);
+ BOOST_CHECK(fabs(val1.as_double() - val2.as_double()) <= kEPS);
+ BOOST_CHECK(val1 == val2);
}
BOOST_AUTO_TEST_CASE(object_with_zone_variant_float)
@@ -291,7 +292,116 @@
BOOST_CHECK(val2.is_double());
BOOST_CHECK(fabs(12.34 - val2.as_double()) <= kEPS);
BOOST_CHECK_NO_THROW(boost::get<double>(val2));
- BOOST_CHECK(fabs(val2.as_double() - val2.as_double()) <= kEPS);
+ BOOST_CHECK(fabs(val1.as_double() - val2.as_double()) <= kEPS);
+ BOOST_CHECK(val1 == val2);
+}
+
+BOOST_AUTO_TEST_CASE(pack_convert_variant_float_zero_atdp_positive)
+{
+ std::stringstream ss;
+ msgpack::type::variant val1 = 12.0;
+ BOOST_CHECK(val1.is_uint64_t());
+ BOOST_CHECK_EQUAL(val1.as_uint64_t(), 12);
+ BOOST_CHECK(fabs(12.0 - val1.as_double()) <= kEPS);
+
+ msgpack::pack(ss, val1);
+
+ std::string const& str = ss.str();
+ msgpack::object_handle oh =
+ msgpack::unpack(str.data(), str.size());
+ msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
+ BOOST_CHECK(val2.is_uint64_t());
+ BOOST_CHECK_EQUAL(val2.as_uint64_t(), 12);
+ BOOST_CHECK_NO_THROW(boost::get<uint64_t>(val2));
+ BOOST_CHECK(fabs(12.0 - val2.as_double()) <= kEPS);
+ BOOST_CHECK_EQUAL(val1.as_uint64_t(), val2.as_uint64_t());
+}
+
+BOOST_AUTO_TEST_CASE(object_variant_float_zero_atdp_positive)
+{
+ msgpack::type::variant val1 = 12.0;
+ BOOST_CHECK(val1.is_uint64_t());
+ BOOST_CHECK_EQUAL(val1.as_uint64_t(), 12);
+ BOOST_CHECK(fabs(12.0 - val1.as_double()) <= kEPS);
+ msgpack::object obj(val1);
+ msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
+ BOOST_CHECK(val2.is_uint64_t());
+ BOOST_CHECK_EQUAL(val2.as_uint64_t(), 12);
+ BOOST_CHECK_NO_THROW(boost::get<uint64_t>(val2));
+ BOOST_CHECK(fabs(12.0 - val2.as_double()) <= kEPS);
+ BOOST_CHECK_EQUAL(val1.as_uint64_t(), val2.as_uint64_t());
+ BOOST_CHECK(val1 == val2);
+}
+
+BOOST_AUTO_TEST_CASE(object_with_zone_variant_float_zero_atdp_positive)
+{
+ msgpack::zone z;
+ msgpack::type::variant val1 = 12.0;
+ BOOST_CHECK(val1.is_uint64_t());
+ BOOST_CHECK_EQUAL(val1.as_uint64_t(), 12);
+ BOOST_CHECK(fabs(12.0 - val1.as_double()) <= kEPS);
+ msgpack::object obj(val1, z);
+ msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
+ BOOST_CHECK(val2.is_uint64_t());
+ BOOST_CHECK_EQUAL(val2.as_uint64_t(), 12);
+ BOOST_CHECK_NO_THROW(boost::get<uint64_t>(val2));
+ BOOST_CHECK_EQUAL(val1.as_uint64_t(), val2.as_uint64_t());
+ BOOST_CHECK(fabs(12.0 - val2.as_double()) <= kEPS);
+ BOOST_CHECK(val1 == val2);
+}
+
+BOOST_AUTO_TEST_CASE(pack_convert_variant_float_zero_atdp_negative)
+{
+ std::stringstream ss;
+ msgpack::type::variant val1 = -12.0;
+ BOOST_CHECK(val1.is_int64_t());
+ BOOST_CHECK_EQUAL(val1.as_int64_t(), -12);
+ BOOST_CHECK(fabs(-12.0 - val1.as_double()) <= kEPS);
+
+ msgpack::pack(ss, val1);
+
+ std::string const& str = ss.str();
+ msgpack::object_handle oh =
+ msgpack::unpack(str.data(), str.size());
+ msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
+ BOOST_CHECK(val2.is_int64_t());
+ BOOST_CHECK_EQUAL(val2.as_int64_t(), -12);
+ BOOST_CHECK_NO_THROW(boost::get<int64_t>(val2));
+ BOOST_CHECK(fabs(-12.0 - val2.as_double()) <= kEPS);
+ BOOST_CHECK_EQUAL(val1.as_int64_t(), val2.as_int64_t());
+}
+
+BOOST_AUTO_TEST_CASE(object_variant_float_zero_atdp_negative)
+{
+ msgpack::type::variant val1 = -12.0;
+ BOOST_CHECK(val1.is_int64_t());
+ BOOST_CHECK_EQUAL(val1.as_int64_t(), -12);
+ BOOST_CHECK(fabs(-12.0 - val1.as_double()) <= kEPS);
+ msgpack::object obj(val1);
+ msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
+ BOOST_CHECK(val2.is_int64_t());
+ BOOST_CHECK_EQUAL(val2.as_int64_t(), -12);
+ BOOST_CHECK_NO_THROW(boost::get<int64_t>(val2));
+ BOOST_CHECK(fabs(-12.0 - val2.as_double()) <= kEPS);
+ BOOST_CHECK_EQUAL(val1.as_int64_t(), val2.as_int64_t());
+ BOOST_CHECK(val1 == val2);
+}
+
+BOOST_AUTO_TEST_CASE(object_with_zone_variant_float_zero_atdp_negative)
+{
+ msgpack::zone z;
+ msgpack::type::variant val1 = -12.0;
+ BOOST_CHECK(val1.is_int64_t());
+ BOOST_CHECK_EQUAL(val1.as_int64_t(), -12);
+ BOOST_CHECK(fabs(-12.0 - val1.as_double()) <= kEPS);
+ msgpack::object obj(val1, z);
+ msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
+ BOOST_CHECK(val2.is_int64_t());
+ BOOST_CHECK_EQUAL(val2.as_int64_t(), -12);
+ BOOST_CHECK_NO_THROW(boost::get<int64_t>(val2));
+ BOOST_CHECK(fabs(-12.0 - val2.as_double()) <= kEPS);
+ BOOST_CHECK_EQUAL(val1.as_int64_t(), val2.as_int64_t());
+ BOOST_CHECK(val1 == val2);
}
// str
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/msgpack-cxx-4.1.3/test/msgpack_cpp11.cpp
new/msgpack-cxx-6.1.0/test/msgpack_cpp11.cpp
--- old/msgpack-cxx-4.1.3/test/msgpack_cpp11.cpp 2022-08-25
11:56:15.000000000 +0200
+++ new/msgpack-cxx-6.1.0/test/msgpack_cpp11.cpp 2023-07-08
05:21:22.000000000 +0200
@@ -252,6 +252,9 @@
template <class Key>
struct set_allocator : std::allocator<Key> {
using std::allocator<Key>::allocator;
+
+ template<class U>
+ struct rebind { using other = set_allocator<U>; };
};
// C++ named requirement Allocator implies that the first template type
@@ -262,6 +265,9 @@
template <typename KeyValuePair>
struct map_allocator_impl : std::allocator<KeyValuePair> {
using std::allocator<KeyValuePair>::allocator;
+
+ template<class U>
+ struct rebind { using other = map_allocator_impl<U>; };
};
template <class Key, class T>
@@ -270,6 +276,9 @@
template <class T>
struct allocator : std::allocator<T> {
using std::allocator<T>::allocator;
+
+ template<class U>
+ struct rebind { using other = allocator<U>; };
};
} // namespace test
@@ -861,8 +870,6 @@
BOOST_CHECK(val1 == val2);
}
-#if !defined(MSGPACK_NO_BOOST)
-
BOOST_AUTO_TEST_CASE(system_clock)
{
std::chrono::system_clock::time_point val1;
@@ -1428,8 +1435,6 @@
BOOST_CHECK(val1 == val3);
}
-#endif // !defined(MSGPACK_NO_BOOST)
-
BOOST_AUTO_TEST_CASE(timespec_pack_convert_zero)
{
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/msgpack-cxx-4.1.3/test/msgpack_cpp17.cpp
new/msgpack-cxx-6.1.0/test/msgpack_cpp17.cpp
--- old/msgpack-cxx-4.1.3/test/msgpack_cpp17.cpp 2022-08-25
11:56:15.000000000 +0200
+++ new/msgpack-cxx-6.1.0/test/msgpack_cpp17.cpp 2023-07-08
05:21:22.000000000 +0200
@@ -461,4 +461,30 @@
}
}
+#if defined(MSGPACK_USE_STD_VARIANT_ADAPTOR)
+
+BOOST_AUTO_TEST_CASE(variant_pack_unpack_as) {
+ std::stringstream ss;
+ std::variant<bool, int, float, double> val1{1.0};
+ msgpack::pack(ss, val1);
+ std::string const& str = ss.str();
+ msgpack::object_handle oh =
+ msgpack::unpack(str.data(), str.size());
+ std::variant<bool, int, float, double> val2 =
+ oh.get().as<std::variant<bool, int, float, double> >();
+ BOOST_CHECK(val1 == val2);
+ BOOST_CHECK_THROW((oh.get().as<std::variant<bool>>()),
msgpack::type_error);
+}
+
+BOOST_AUTO_TEST_CASE(variant_with_zone) {
+ msgpack::zone z;
+ std::variant<bool, int, float, double> val1{1.0};
+ msgpack::object obj(val1, z);
+ std::variant<bool, int, float, double> val2 = obj.as<std::variant<bool,
int, float, double>>();
+ BOOST_CHECK(val1 == val2);
+ BOOST_CHECK_THROW((obj.as<std::variant<bool>>()), msgpack::type_error);
+}
+
+#endif // defined(MSGPACK_USE_STD_VARIANT_ADAPTOR)
+
#endif // MSGPACK_CPP_VERSION >= 201703
