generic-library/msgpack
1
0
Fork 0
mirror of https://github.com/msgpack/msgpack-c.git synced 2025-10-14 23:07:58 +02:00
Code Issues Projects Releases Wiki Activity

Add support for more binary buffer types

Browse Source 
Add support for the following types:
- `std::array<std::byte>`
- `std::span<char>`
- `std::span<unsigned char>`
- `std::span<std::byte>`
This commit is contained in:
Daniil Kovalev
2021-05-10 15:39:17 +03:00
parent fc3de9806e
commit 388891edad
8 changed files with 415 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
CMakeLists.txt
View File

@@ -35,7 +35,15 @@ IF (MSGPACK_USE_X3_PARSE)
ENDIF ()
ENDIF ()
ELSE ()
IF (MSGPACK_CXX17)
IF (MSGPACK_CXX20)
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
SET (CMAKE_CXX_FLAGS "-std=c++20 ${CMAKE_CXX_FLAGS}")
ELSEIF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
SET (CMAKE_CXX_FLAGS "-std=c++20 ${CMAKE_CXX_FLAGS}")
ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
# MESSAGE ( FATAL_ERROR "MSVC doesn't support C++20.")
ENDIF ()
ELSEIF (MSGPACK_CXX17)
IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
SET (CMAKE_CXX_FLAGS "-std=c++17 ${CMAKE_CXX_FLAGS}")
ELSEIF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")

4
Files.cmake
View File

@@ -28,11 +28,13 @@ SET (msgpackc_HEADERS
include/msgpack/adaptor/cpp11/unique_ptr.hpp
include/msgpack/adaptor/cpp11/unordered_map.hpp
include/msgpack/adaptor/cpp11/unordered_set.hpp
include/msgpack/adaptor/cpp17/array_byte.hpp
include/msgpack/adaptor/cpp17/byte.hpp
include/msgpack/adaptor/cpp17/carray_byte.hpp
include/msgpack/adaptor/cpp17/optional.hpp
include/msgpack/adaptor/cpp17/string_view.hpp
include/msgpack/adaptor/cpp17/vector_byte.hpp
include/msgpack/adaptor/cpp20/span.hpp
include/msgpack/adaptor/define.hpp
include/msgpack/adaptor/define_decl.hpp
include/msgpack/adaptor/deque.hpp
@@ -124,11 +126,13 @@ SET (msgpackc_HEADERS
include/msgpack/v1/adaptor/cpp11/unique_ptr.hpp
include/msgpack/v1/adaptor/cpp11/unordered_map.hpp
include/msgpack/v1/adaptor/cpp11/unordered_set.hpp
include/msgpack/v1/adaptor/cpp17/array_byte.hpp
include/msgpack/v1/adaptor/cpp17/byte.hpp
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/vector_byte.hpp
include/msgpack/v1/adaptor/cpp20/span.hpp
include/msgpack/v1/adaptor/define.hpp
include/msgpack/v1/adaptor/define_decl.hpp
include/msgpack/v1/adaptor/deque.hpp

16
include/msgpack/adaptor/cpp17/array_byte.hpp Normal file
View File

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

16
include/msgpack/adaptor/cpp20/span.hpp Normal file
View File

@@ -0,0 +1,16 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2021 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_CPP20_SPAN_HPP
#define MSGPACK_TYPE_CPP20_SPAN_HPP
#include "msgpack/v1/adaptor/cpp20/span.hpp"
#endif // MSGPACK_TYPE_CPP20_SPAN_HPP

5
include/msgpack/type.hpp
View File

@@ -54,10 +54,15 @@
#include "adaptor/cpp17/string_view.hpp"
#endif // MSGPACK_HAS_INCLUDE(<string_view>)
#include "adaptor/cpp17/array_byte.hpp"
#include "adaptor/cpp17/byte.hpp"
#include "adaptor/cpp17/carray_byte.hpp"
#include "adaptor/cpp17/vector_byte.hpp"
#if MSGPACK_HAS_INCLUDE(<span>)
#include "adaptor/cpp20/span.hpp"
#endif // MSGPACK_HAS_INCLUDE(<span>)
#endif // defined(MSGPACK_USE_CPP03)
#include "adaptor/boost/fusion.hpp"

121
include/msgpack/v1/adaptor/cpp17/array_byte.hpp Normal file
View File

@@ -0,0 +1,121 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2021 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_ARRAY_BYTE_HPP
#define MSGPACK_V1_TYPE_ARRAY_BYTE_HPP
#if __cplusplus >= 201703
#include "msgpack/versioning.hpp"
#include "msgpack/adaptor/adaptor_base.hpp"
#include "msgpack/adaptor/check_container_size.hpp"
#include <array>
#include <cstring>
#include <cstddef>
namespace msgpack {
/// @cond
MSGPACK_API_VERSION_NAMESPACE(v1) {
/// @endcond
namespace adaptor {
template <std::size_t N>
struct convert<std::array<std::byte, N> > {
msgpack::object const& operator()(msgpack::object const& o, std::array<std::byte, N>& v) const {
switch (o.type) {
case msgpack::type::BIN:
if (o.via.bin.size != N)
throw msgpack::type_error();
if (N != 0) {
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
std::memcpy(&v.front(), o.via.bin.ptr, o.via.bin.size);
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
#pragma GCC diagnostic pop
#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
}
break;
case msgpack::type::STR:
if (o.via.bin.size != N)
throw msgpack::type_error();
if (N != 0) {
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
std::memcpy(&v.front(), o.via.str.ptr, o.via.str.size);
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
#pragma GCC diagnostic pop
#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
}
break;
default:
throw msgpack::type_error();
break;
}
return o;
}
};
template <std::size_t N>
struct pack<std::array<std::byte, N> > {
template <typename Stream>
msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::array<std::byte, N>& v) const {
uint32_t size = checked_get_container_size(v.size());
o.pack_bin(size);
if (size != 0) {
o.pack_bin_body(reinterpret_cast<char const*>(&v.front()), size);
}
return o;
}
};
template <std::size_t N>
struct object<std::array<std::byte, N> > {
void operator()(msgpack::object& o, const std::array<std::byte, N>& v) const {
uint32_t size = checked_get_container_size(v.size());
o.type = msgpack::type::BIN;
if (size != 0) {
o.via.bin.ptr = reinterpret_cast<char const*>(&v.front());
}
o.via.bin.size = size;
}
};
template <std::size_t N>
struct object_with_zone<std::array<std::byte, N> > {
void operator()(msgpack::object::with_zone& o, const std::array<std::byte, N>& v) const {
uint32_t size = checked_get_container_size(v.size());
o.type = msgpack::type::BIN;
o.via.bin.size = size;
if (size != 0) {
char* ptr = static_cast<char*>(o.zone.allocate_align(size, MSGPACK_ZONE_ALIGNOF(char)));
o.via.bin.ptr = ptr;
std::memcpy(ptr, &v.front(), size);
}
}
};
} // namespace adaptor
/// @cond
} // MSGPACK_API_VERSION_NAMESPACE(v1)
/// @endcond
} // namespace msgpack
#endif // __cplusplus >= 201703
#endif // MSGPACK_V1_TYPE_ARRAY_BYTE_HPP

121
include/msgpack/v1/adaptor/cpp20/span.hpp Normal file
View File

@@ -0,0 +1,121 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2021 KONDO Takatoshi and Daniil Kovalev
//
// 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_CPP20_SPAN_HPP
#define MSGPACK_V1_TYPE_CPP20_SPAN_HPP
// Some compilers still do not set __cplusplus to 202002
#if __cplusplus > 201703
#include "msgpack/versioning.hpp"
#include "msgpack/adaptor/adaptor_base.hpp"
#include "msgpack/adaptor/check_container_size.hpp"
#include "msgpack/meta.hpp"
#include <span>
#include <cstring>
#include <cstddef>
namespace msgpack {
/// @cond
MSGPACK_API_VERSION_NAMESPACE(v1) {
/// @endcond
namespace adaptor {
#define MSGPACK_ADAPTOR_CONVERT_SPAN_BINARY(byte_t) \
template <> \
struct convert<std::span<const byte_t> > { \
msgpack::object const& operator()(msgpack::object const& o, std::span<const byte_t>& v) const { \
switch (o.type) { \
case msgpack::type::BIN: \
v = std::span(reinterpret_cast<const byte_t*>(o.via.bin.ptr), o.via.bin.size); \
break; \
default: \
throw msgpack::type_error(); \
break; \
} \
return o; \
} \
};
#define MSGPACK_ADAPTOR_PACK_SPAN_BINARY(byte_t) \
template <> \
struct pack<std::span<byte_t> > { \
template <typename Stream> \
msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::span<byte_t>& v) const { \
uint32_t size = checked_get_container_size(v.size()); \
o.pack_bin(size); \
if (size != 0) { \
o.pack_bin_body(reinterpret_cast<char const*>(v.data()), size); \
} \
return o; \
} \
};
#define MSGPACK_ADAPTOR_OBJECT_SPAN_BINARY(byte_t) \
template <> \
struct object<std::span<byte_t> > { \
void operator()(msgpack::object& o, const std::span<byte_t>& v) const { \
uint32_t size = checked_get_container_size(v.size()); \
o.type = msgpack::type::BIN; \
if (size != 0) { \
o.via.bin.ptr = reinterpret_cast<char const*>(v.data()); \
} \
o.via.bin.size = size; \
} \
};
#define MSGPACK_ADAPTOR_OBJECT_WITH_ZONE_SPAN_BINARY(byte_t) \
template <> \
struct object_with_zone<std::span<byte_t> > { \
void operator()(msgpack::object::with_zone& o, const std::span<byte_t>& v) const { \
uint32_t size = checked_get_container_size(v.size()); \
o.type = msgpack::type::BIN; \
o.via.bin.size = size; \
if (size != 0) { \
char* ptr = static_cast<char*>(o.zone.allocate_align(size, MSGPACK_ZONE_ALIGNOF(char))); \
o.via.bin.ptr = ptr; \
std::memcpy(ptr, v.data(), size); \
} \
} \
};
#define MSGPACK_ADAPTOR_SPAN_BINARY(byte_t) \
MSGPACK_ADAPTOR_CONVERT_SPAN_BINARY(byte_t) \
MSGPACK_ADAPTOR_PACK_SPAN_BINARY(byte_t) \
MSGPACK_ADAPTOR_PACK_SPAN_BINARY(const byte_t) \
MSGPACK_ADAPTOR_OBJECT_SPAN_BINARY(byte_t) \
MSGPACK_ADAPTOR_OBJECT_SPAN_BINARY(const byte_t) \
MSGPACK_ADAPTOR_OBJECT_WITH_ZONE_SPAN_BINARY(byte_t) \
MSGPACK_ADAPTOR_OBJECT_WITH_ZONE_SPAN_BINARY(const byte_t)
MSGPACK_ADAPTOR_SPAN_BINARY(char)
MSGPACK_ADAPTOR_SPAN_BINARY(unsigned char)
MSGPACK_ADAPTOR_SPAN_BINARY(std::byte)
#undef MSGPACK_ADAPTOR_SPAN_BINARY
#undef MSGPACK_ADAPTOR_OBJECT_WITH_ZONE_SPAN_BINARY
#undef MSGPACK_ADAPTOR_OBJECT_SPAN_BINARY
#undef MSGPACK_ADAPTOR_PACK_SPAN_BINARY
#undef MSGPACK_ADAPTOR_CONVERT_SPAN_BINARY
} // namespace adaptor
/// @cond
} // MSGPACK_API_VERSION_NAMESPACE(v1)
/// @endcond
} // namespace msgpack
#endif // __cplusplus > 201703
#endif // MSGPACK_V1_TYPE_CPP11_ARRAY_HPP

127
test/msgpack_cpp17.cpp
View File

@@ -271,15 +271,15 @@ TEST(MSGPACK_CPP17, vector_byte_pack_convert)
};
msgpack::pack(ss, val1);
std::string const& str = ss.str();
char packed[] = { char(0xc4), char(0x05), char(0x01), char(0x02), char(0x7f), char(0x80), char(0xff) };
EXPECT_EQ(str.size(), sizeof(packed));
for (size_t i = 0; i != sizeof(packed); ++i) {
std::string const& str = ss.str();
EXPECT_EQ(str[i], packed[i]);
}
msgpack::object_handle oh;
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);
@@ -310,6 +310,125 @@ TEST(MSGPACK_CPP17, vector_byte_object_with_zone)
EXPECT_EQ(val1, val2);
}
TEST(MSGPACK_CPP17, array_byte_pack_convert)
{
std::stringstream ss;
std::array<std::byte, 5> val1{
std::byte{0x01}, std::byte{0x02}, std::byte{0x7f}, std::byte{0x80}, std::byte{0xff}
};
msgpack::pack(ss, val1);
std::string const& str = ss.str();
char packed[] = { char(0xc4), char(0x05), char(0x01), char(0x02), char(0x7f), char(0x80), char(0xff) };
EXPECT_EQ(str.size(), sizeof(packed));
for (size_t i = 0; i != sizeof(packed); ++i) {
EXPECT_EQ(str[i], packed[i]);
}
{
msgpack::object_handle oh;
msgpack::unpack(oh, str.data(), str.size());
auto val2 = oh.get().as<std::array<std::byte, 5>>();
EXPECT_EQ(val1, val2);
}
{
msgpack::object_handle oh;
msgpack::unpack(oh, str.data(), str.size());
EXPECT_THROW((oh.get().as<std::array<std::byte, 0>>()), msgpack::type_error);
EXPECT_THROW((oh.get().as<std::array<std::byte, 1>>()), msgpack::type_error);
EXPECT_THROW((oh.get().as<std::array<std::byte, 8192>>()), msgpack::type_error);
}
}
TEST(MSGPACK_CPP17, array_byte_object)
{
std::array<std::byte, 5> val1{
std::byte{0x01}, std::byte{0x02}, std::byte{0x7f}, std::byte{0x80}, std::byte{0xff}
};
// Caller need to manage val1's lifetime. The Data is not copied.
msgpack::object obj(val1);
auto val2 = obj.as<std::array<std::byte, 5>>();
EXPECT_EQ(val1, val2);
EXPECT_THROW((obj.as<std::array<std::byte, 0>>()), msgpack::type_error);
EXPECT_THROW((obj.as<std::array<std::byte, 1>>()), msgpack::type_error);
EXPECT_THROW((obj.as<std::array<std::byte, 8192>>()), msgpack::type_error);
}
TEST(MSGPACK_CPP17, array_byte_object_with_zone)
{
msgpack::zone z;
std::array<std::byte, 5> val1{
std::byte{0x01}, std::byte{0x02}, std::byte{0x7f}, std::byte{0x80}, std::byte{0xff}
};
msgpack::object obj(val1, z);
auto val2 = obj.as<std::array<std::byte, 5>>();
EXPECT_EQ(val1, val2);
EXPECT_THROW((obj.as<std::array<std::byte, 0>>()), msgpack::type_error);
EXPECT_THROW((obj.as<std::array<std::byte, 1>>()), msgpack::type_error);
EXPECT_THROW((obj.as<std::array<std::byte, 8192>>()), msgpack::type_error);
}
TEST(MSGPACK_CPP17, array_byte_empty_pack_convert)
{
std::stringstream ss;
std::array<std::byte, 0> val1{};
msgpack::pack(ss, val1);
std::string const& str = ss.str();
char packed[] = { char(0xc4), char(0x00) };
EXPECT_EQ(str.size(), sizeof(packed));
for (size_t i = 0; i != sizeof(packed); ++i) {
EXPECT_EQ(str[i], packed[i]);
}
{
msgpack::object_handle oh;
msgpack::unpack(oh, str.data(), str.size());
auto val2 = oh.get().as<std::array<std::byte, 0>>();
EXPECT_EQ(val1, val2);
}
{
msgpack::object_handle oh;
msgpack::unpack(oh, str.data(), str.size());
EXPECT_THROW((oh.get().as<std::array<std::byte, 1>>()), msgpack::type_error);
EXPECT_THROW((oh.get().as<std::array<std::byte, 8192>>()), msgpack::type_error);
}
}
TEST(MSGPACK_CPP17, array_byte_empty_object)
{
std::array<std::byte, 0> val1{};
// Caller need to manage val1's lifetime. The Data is not copied.
msgpack::object obj(val1);
auto val2 = obj.as<std::array<std::byte, 0>>();
EXPECT_EQ(val1, val2);
EXPECT_THROW((obj.as<std::array<std::byte, 1>>()), msgpack::type_error);
EXPECT_THROW((obj.as<std::array<std::byte, 8192>>()), msgpack::type_error);
}
TEST(MSGPACK_CPP17, array_byte_empty_object_with_zone)
{
msgpack::zone z;
std::array<std::byte, 0> val1{};
msgpack::object obj(val1, z);
auto val2 = obj.as<std::array<std::byte, 0>>();
EXPECT_EQ(val1, val2);
EXPECT_THROW((obj.as<std::array<std::byte, 1>>()), msgpack::type_error);
EXPECT_THROW((obj.as<std::array<std::byte, 8192>>()), msgpack::type_error);
}
TEST(MSGPACK_CPP17, carray_byte_pack_convert)
{
std::stringstream ss;
@@ -318,15 +437,15 @@ TEST(MSGPACK_CPP17, carray_byte_pack_convert)
};
msgpack::pack(ss, val1);
std::string const& str = ss.str();
char packed[] = { char(0xc4), char(0x05), char(0x01), char(0x02), char(0x7f), char(0x80), char(0xff) };
EXPECT_EQ(str.size(), sizeof(packed));
for (size_t i = 0; i != sizeof(packed); ++i) {
std::string const& str = ss.str();
EXPECT_EQ(str[i], packed[i]);
}
msgpack::object_handle oh;
std::string const& str = ss.str();
msgpack::unpack(oh, str.data(), str.size());
std::byte val2[sizeof(val1)];
oh.get().convert(val2);