generic-library/cppzmq
1
0
Fork 0
mirror of https://github.com/zeromq/cppzmq.git synced 2025-04-27 18:30:54 +02:00
Code Issues Projects Releases Wiki Activity

Merge pull request #380 from zeromq/reformat

Browse Source 
Reformat all files with clang-format
This commit is contained in:
Luca Boccassi 2020-01-28 10:37:30 +00:00 committed by GitHub
commit 4bd01bc0ef
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 358 additions and 338 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

95
tests/active_poller.cpp
View File

@ -14,9 +14,9 @@ TEST_CASE("create destroy", "[active_poller]")
} }
static_assert(!std::is_copy_constructible<zmq::active_poller_t>::value, static_assert(!std::is_copy_constructible<zmq::active_poller_t>::value,
"active_active_poller_t should not be copy-constructible"); "active_active_poller_t should not be copy-constructible");
static_assert(!std::is_copy_assignable<zmq::active_poller_t>::value, static_assert(!std::is_copy_assignable<zmq::active_poller_t>::value,
"active_active_poller_t should not be copy-assignable"); "active_active_poller_t should not be copy-assignable");
TEST_CASE("move construct empty", "[active_poller]") TEST_CASE("move construct empty", "[active_poller]")
{ {
@ -47,7 +47,9 @@ TEST_CASE("move construct non empty", "[active_poller]")
zmq::socket_t socket{context, zmq::socket_type::router}; zmq::socket_t socket{context, zmq::socket_type::router};
zmq::active_poller_t a; zmq::active_poller_t a;
a.add(socket, zmq::event_flags::pollin, [](zmq::event_flags) {}); a.add(socket, zmq::event_flags::pollin, [](zmq::event_flags)
{
});
CHECK_FALSE(a.empty()); CHECK_FALSE(a.empty());
CHECK(1u == a.size()); CHECK(1u == a.size());
zmq::active_poller_t b = std::move(a); zmq::active_poller_t b = std::move(a);
@ -63,7 +65,9 @@ TEST_CASE("move assign non empty", "[active_poller]")
zmq::socket_t socket{context, zmq::socket_type::router}; zmq::socket_t socket{context, zmq::socket_type::router};
zmq::active_poller_t a; zmq::active_poller_t a;
a.add(socket, zmq::event_flags::pollin, [](zmq::event_flags) {}); a.add(socket, zmq::event_flags::pollin, [](zmq::event_flags)
{
});
CHECK_FALSE(a.empty()); CHECK_FALSE(a.empty());
CHECK(1u == a.size()); CHECK(1u == a.size());
zmq::active_poller_t b; zmq::active_poller_t b;
@ -92,7 +96,9 @@ TEST_CASE("add handler invalid events type", "[active_poller]")
zmq::active_poller_t active_poller; zmq::active_poller_t active_poller;
zmq::active_poller_t::handler_type handler; zmq::active_poller_t::handler_type handler;
short invalid_events_type = 2 << 10; short invalid_events_type = 2 << 10;
CHECK_THROWS_AS(active_poller.add(socket, static_cast<zmq::event_flags>(invalid_events_type), handler), const zmq::error_t&); CHECK_THROWS_AS(
active_poller.add(socket, static_cast<zmq::event_flags>(invalid_events_type),
handler), const zmq::error_t&);
CHECK(active_poller.empty()); CHECK(active_poller.empty());
CHECK(0u == active_poller.size()); CHECK(0u == active_poller.size());
} }
@ -106,14 +112,16 @@ TEST_CASE("add handler twice throws", "[active_poller]")
zmq::active_poller_t::handler_type handler; zmq::active_poller_t::handler_type handler;
active_poller.add(socket, zmq::event_flags::pollin, handler); active_poller.add(socket, zmq::event_flags::pollin, handler);
/// \todo the actual error code should be checked /// \todo the actual error code should be checked
CHECK_THROWS_AS(active_poller.add(socket, zmq::event_flags::pollin, handler), const zmq::error_t&); CHECK_THROWS_AS(active_poller.add(socket, zmq::event_flags::pollin, handler),
const zmq::error_t&);
} }
TEST_CASE("wait with no handlers throws", "[active_poller]") TEST_CASE("wait with no handlers throws", "[active_poller]")
{ {
zmq::active_poller_t active_poller; zmq::active_poller_t active_poller;
/// \todo the actual error code should be checked /// \todo the actual error code should be checked
CHECK_THROWS_AS(active_poller.wait(std::chrono::milliseconds{10}), const zmq::error_t&); CHECK_THROWS_AS(active_poller.wait(std::chrono::milliseconds{10}),
const zmq::error_t&);
} }
TEST_CASE("remove unregistered throws", "[active_poller]") TEST_CASE("remove unregistered throws", "[active_poller]")
@ -130,7 +138,8 @@ TEST_CASE("remove registered empty", "[active_poller]")
zmq::context_t context; zmq::context_t context;
zmq::socket_t socket{context, zmq::socket_type::router}; zmq::socket_t socket{context, zmq::socket_type::router};
zmq::active_poller_t active_poller; zmq::active_poller_t active_poller;
active_poller.add(socket, zmq::event_flags::pollin, zmq::active_poller_t::handler_type{}); active_poller.add(socket, zmq::event_flags::pollin,
zmq::active_poller_t::handler_type{});
CHECK_NOTHROW(active_poller.remove(socket)); CHECK_NOTHROW(active_poller.remove(socket));
} }
@ -139,7 +148,9 @@ TEST_CASE("remove registered non empty", "[active_poller]")
zmq::context_t context; zmq::context_t context;
zmq::socket_t socket{context, zmq::socket_type::router}; zmq::socket_t socket{context, zmq::socket_type::router};
zmq::active_poller_t active_poller; zmq::active_poller_t active_poller;
active_poller.add(socket, zmq::event_flags::pollin, [](zmq::event_flags) {}); active_poller.add(socket, zmq::event_flags::pollin, [](zmq::event_flags)
{
});
CHECK_NOTHROW(active_poller.remove(socket)); CHECK_NOTHROW(active_poller.remove(socket));
} }
@ -147,7 +158,10 @@ namespace
{ {
struct server_client_setup : common_server_client_setup struct server_client_setup : common_server_client_setup
{ {
zmq::active_poller_t::handler_type handler = [&](zmq::event_flags e) { events = e; }; zmq::active_poller_t::handler_type handler = [&](zmq::event_flags e)
{
events = e;
};
zmq::event_flags events = zmq::event_flags::none; zmq::event_flags events = zmq::event_flags::none;
}; };
@ -161,7 +175,9 @@ TEST_CASE("poll basic", "[active_poller]")
zmq::active_poller_t active_poller; zmq::active_poller_t active_poller;
bool message_received = false; bool message_received = false;
zmq::active_poller_t::handler_type handler = [&message_received](zmq::event_flags events) { zmq::active_poller_t::handler_type handler = [&message_received
](zmq::event_flags events)
{
CHECK(zmq::event_flags::none != (events & zmq::event_flags::pollin)); CHECK(zmq::event_flags::none != (events & zmq::event_flags::pollin));
message_received = true; message_received = true;
}; };
@ -181,7 +197,8 @@ TEST_CASE("client server", "[active_poller]")
// Setup active_poller // Setup active_poller
zmq::active_poller_t active_poller; zmq::active_poller_t active_poller;
zmq::event_flags events; zmq::event_flags events;
zmq::active_poller_t::handler_type handler = [&](zmq::event_flags e) { zmq::active_poller_t::handler_type handler = [&](zmq::event_flags e)
{
if (zmq::event_flags::none != (e & zmq::event_flags::pollin)) { if (zmq::event_flags::none != (e & zmq::event_flags::pollin)) {
zmq::message_t zmq_msg; zmq::message_t zmq_msg;
CHECK_NOTHROW(s.server.recv(zmq_msg)); // get message CHECK_NOTHROW(s.server.recv(zmq_msg)); // get message
@ -204,7 +221,9 @@ TEST_CASE("client server", "[active_poller]")
// Re-add server socket with pollout flag // Re-add server socket with pollout flag
CHECK_NOTHROW(active_poller.remove(s.server)); CHECK_NOTHROW(active_poller.remove(s.server));
CHECK_NOTHROW(active_poller.add(s.server, zmq::event_flags::pollin | zmq::event_flags::pollout, handler)); CHECK_NOTHROW(
active_poller.add(s.server, zmq::event_flags::pollin | zmq::event_flags::
pollout, handler));
CHECK(1 == active_poller.wait(std::chrono::milliseconds{-1})); CHECK(1 == active_poller.wait(std::chrono::milliseconds{-1}));
CHECK(events == zmq::event_flags::pollout); CHECK(events == zmq::event_flags::pollout);
} }
@ -215,8 +234,10 @@ TEST_CASE("add invalid socket throws", "[active_poller]")
zmq::active_poller_t active_poller; zmq::active_poller_t active_poller;
zmq::socket_t a{context, zmq::socket_type::router}; zmq::socket_t a{context, zmq::socket_type::router};
zmq::socket_t b{std::move(a)}; zmq::socket_t b{std::move(a)};
CHECK_THROWS_AS(active_poller.add(a, zmq::event_flags::pollin, zmq::active_poller_t::handler_type{}), CHECK_THROWS_AS(
const zmq::error_t&); active_poller.add(a, zmq::event_flags::pollin, zmq::active_poller_t::
handler_type{}),
const zmq::error_t&);
} }
TEST_CASE("remove invalid socket throws", "[active_poller]") TEST_CASE("remove invalid socket throws", "[active_poller]")
@ -225,7 +246,8 @@ TEST_CASE("remove invalid socket throws", "[active_poller]")
zmq::socket_t socket{context, zmq::socket_type::router}; zmq::socket_t socket{context, zmq::socket_type::router};
zmq::active_poller_t active_poller; zmq::active_poller_t active_poller;
CHECK_NOTHROW( CHECK_NOTHROW(
active_poller.add(socket, zmq::event_flags::pollin, zmq::active_poller_t::handler_type{})); active_poller.add(socket, zmq::event_flags::pollin, zmq::active_poller_t::
handler_type{}));
CHECK(1u == active_poller.size()); CHECK(1u == active_poller.size());
std::vector<zmq::socket_t> sockets; std::vector<zmq::socket_t> sockets;
sockets.emplace_back(std::move(socket)); sockets.emplace_back(std::move(socket));
@ -248,7 +270,8 @@ TEST_CASE("modify empty throws", "[active_poller]")
zmq::context_t context; zmq::context_t context;
zmq::socket_t socket{context, zmq::socket_type::push}; zmq::socket_t socket{context, zmq::socket_type::push};
zmq::active_poller_t active_poller; zmq::active_poller_t active_poller;
CHECK_THROWS_AS(active_poller.modify(socket, zmq::event_flags::pollin), const zmq::error_t&); CHECK_THROWS_AS(active_poller.modify(socket, zmq::event_flags::pollin),
const zmq::error_t&);
} }
TEST_CASE("modify invalid socket throws", "[active_poller]") TEST_CASE("modify invalid socket throws", "[active_poller]")
@ -257,7 +280,8 @@ TEST_CASE("modify invalid socket throws", "[active_poller]")
zmq::socket_t a{context, zmq::socket_type::push}; zmq::socket_t a{context, zmq::socket_type::push};
zmq::socket_t b{std::move(a)}; zmq::socket_t b{std::move(a)};
zmq::active_poller_t active_poller; zmq::active_poller_t active_poller;
CHECK_THROWS_AS(active_poller.modify(a, zmq::event_flags::pollin), const zmq::error_t&); CHECK_THROWS_AS(active_poller.modify(a, zmq::event_flags::pollin),
const zmq::error_t&);
} }
TEST_CASE("modify not added throws", "[active_poller]") TEST_CASE("modify not added throws", "[active_poller]")
@ -267,8 +291,10 @@ TEST_CASE("modify not added throws", "[active_poller]")
zmq::socket_t b{context, zmq::socket_type::push}; zmq::socket_t b{context, zmq::socket_type::push};
zmq::active_poller_t active_poller; zmq::active_poller_t active_poller;
CHECK_NOTHROW( CHECK_NOTHROW(
active_poller.add(a, zmq::event_flags::pollin, zmq::active_poller_t::handler_type{})); active_poller.add(a, zmq::event_flags::pollin, zmq::active_poller_t::
CHECK_THROWS_AS(active_poller.modify(b, zmq::event_flags::pollin), const zmq::error_t&); handler_type{}));
CHECK_THROWS_AS(active_poller.modify(b, zmq::event_flags::pollin),
const zmq::error_t&);
} }
TEST_CASE("modify simple", "[active_poller]") TEST_CASE("modify simple", "[active_poller]")
@ -277,8 +303,11 @@ TEST_CASE("modify simple", "[active_poller]")
zmq::socket_t a{context, zmq::socket_type::push}; zmq::socket_t a{context, zmq::socket_type::push};
zmq::active_poller_t active_poller; zmq::active_poller_t active_poller;
CHECK_NOTHROW( CHECK_NOTHROW(
active_poller.add(a, zmq::event_flags::pollin, zmq::active_poller_t::handler_type{})); active_poller.add(a, zmq::event_flags::pollin, zmq::active_poller_t::
CHECK_NOTHROW(active_poller.modify(a, zmq::event_flags::pollin | zmq::event_flags::pollout)); handler_type{}));
CHECK_NOTHROW(
active_poller.modify(a, zmq::event_flags::pollin | zmq::event_flags::pollout
));
} }
TEST_CASE("poll client server", "[active_poller]") TEST_CASE("poll client server", "[active_poller]")
@ -298,7 +327,9 @@ TEST_CASE("poll client server", "[active_poller]")
CHECK(s.events == zmq::event_flags::pollin); CHECK(s.events == zmq::event_flags::pollin);
// Modify server socket with pollout flag // Modify server socket with pollout flag
CHECK_NOTHROW(active_poller.modify(s.server, zmq::event_flags::pollin | zmq::event_flags::pollout)); CHECK_NOTHROW(
active_poller.modify(s.server, zmq::event_flags::pollin | zmq::event_flags::
pollout));
CHECK(1 == active_poller.wait(std::chrono::milliseconds{500})); CHECK(1 == active_poller.wait(std::chrono::milliseconds{500}));
CHECK(s.events == (zmq::event_flags::pollin | zmq::event_flags::pollout)); CHECK(s.events == (zmq::event_flags::pollin | zmq::event_flags::pollout));
} }
@ -313,7 +344,8 @@ TEST_CASE("wait one return", "[active_poller]")
// Setup active_poller // Setup active_poller
zmq::active_poller_t active_poller; zmq::active_poller_t active_poller;
CHECK_NOTHROW( CHECK_NOTHROW(
active_poller.add(s.server, zmq::event_flags::pollin, [&count](zmq::event_flags) { ++count; })); active_poller.add(s.server, zmq::event_flags::pollin, [&count](zmq::
event_flags) { ++count; }));
// client sends message // client sends message
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}, zmq::send_flags::none)); CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}, zmq::send_flags::none));
@ -359,7 +391,9 @@ TEST_CASE("received on move constructed active_poller", "[active_poller]")
int count = 0; int count = 0;
// Setup active_poller a // Setup active_poller a
zmq::active_poller_t a; zmq::active_poller_t a;
CHECK_NOTHROW(a.add(s.server, zmq::event_flags::pollin, [&count](zmq::event_flags) { ++count; })); CHECK_NOTHROW(
a.add(s.server, zmq::event_flags::pollin, [&count](zmq::event_flags) { ++
count; }));
// client sends message // client sends message
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}, zmq::send_flags::none)); CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}, zmq::send_flags::none));
// wait for message and verify it is received // wait for message and verify it is received
@ -389,11 +423,12 @@ TEST_CASE("remove from handler", "[active_poller]")
int count = 0; int count = 0;
for (size_t i = 0; i < ITER_NO; ++i) { for (size_t i = 0; i < ITER_NO; ++i) {
CHECK_NOTHROW( CHECK_NOTHROW(
active_poller.add(setup_list[i].server, zmq::event_flags::pollin, [&, i](zmq::event_flags events) { active_poller.add(setup_list[i].server, zmq::event_flags::pollin, [&, i](
CHECK(events == zmq::event_flags::pollin); zmq::event_flags events) {
active_poller.remove(setup_list[ITER_NO - i - 1].server); CHECK(events == zmq::event_flags::pollin);
CHECK((ITER_NO - i - 1) == active_poller.size()); active_poller.remove(setup_list[ITER_NO - i - 1].server);
})); CHECK((ITER_NO - i - 1) == active_poller.size());
}));
++count; ++count;
} }
CHECK(ITER_NO == active_poller.size()); CHECK(ITER_NO == active_poller.size());

12
tests/buffer.cpp
View File

@ -35,10 +35,10 @@ TEST_CASE("buffer data ctor", "[buffer]")
CHECK(mb.size() == from_mut.size()); CHECK(mb.size() == from_mut.size());
CHECK(mb.data() == from_mut.data()); CHECK(mb.data() == from_mut.data());
const auto cmb = mb; const auto cmb = mb;
static_assert(std::is_same<decltype(cmb.data()), void*>::value, ""); static_assert(std::is_same<decltype(cmb.data()), void *>::value, "");
constexpr const void* cp = nullptr; constexpr const void *cp = nullptr;
constexpr void* p = nullptr; constexpr void *p = nullptr;
constexpr zmq::const_buffer cecb = zmq::buffer(p, 0); constexpr zmq::const_buffer cecb = zmq::buffer(p, 0);
constexpr zmq::mutable_buffer cemb = zmq::buffer(p, 0); constexpr zmq::mutable_buffer cemb = zmq::buffer(p, 0);
CHECK(cecb.data() == nullptr); CHECK(cecb.data() == nullptr);
@ -188,14 +188,14 @@ TEST_CASE("mutable_buffer creation vector", "[buffer]")
TEST_CASE("const_buffer creation vector", "[buffer]") TEST_CASE("const_buffer creation vector", "[buffer]")
{ {
std::vector<BT> d(10); std::vector<BT> d(10);
zmq::const_buffer b = zmq::buffer(static_cast<const std::vector<BT>&>(d)); zmq::const_buffer b = zmq::buffer(static_cast<const std::vector<BT> &>(d));
CHECK(b.size() == d.size() * sizeof(BT)); CHECK(b.size() == d.size() * sizeof(BT));
CHECK(b.data() == d.data()); CHECK(b.data() == d.data());
zmq::const_buffer b2 = zmq::buffer(static_cast<const std::vector<BT>&>(d), 4); zmq::const_buffer b2 = zmq::buffer(static_cast<const std::vector<BT> &>(d), 4);
CHECK(b2.size() == 4); CHECK(b2.size() == 4);
CHECK(b2.data() == d.data()); CHECK(b2.data() == d.data());
d.clear(); d.clear();
b = zmq::buffer(static_cast<const std::vector<BT>&>(d)); b = zmq::buffer(static_cast<const std::vector<BT> &>(d));
CHECK(b.size() == 0); CHECK(b.size() == 0);
CHECK(b.data() == nullptr); CHECK(b.data() == nullptr);
} }

7
tests/message.cpp
View File

@ -4,9 +4,9 @@
#if defined(ZMQ_CPP11) #if defined(ZMQ_CPP11)
static_assert(!std::is_copy_constructible<zmq::message_t>::value, static_assert(!std::is_copy_constructible<zmq::message_t>::value,
"message_t should not be copy-constructible"); "message_t should not be copy-constructible");
static_assert(!std::is_copy_assignable<zmq::message_t>::value, static_assert(!std::is_copy_assignable<zmq::message_t>::value,
"message_t should not be copy-assignable"); "message_t should not be copy-assignable");
#endif #endif
#if (__cplusplus >= 201703L) #if (__cplusplus >= 201703L)
static_assert(std::is_nothrow_swappable<zmq::message_t>::value, static_assert(std::is_nothrow_swappable<zmq::message_t>::value,
@ -36,7 +36,8 @@ TEST_CASE("message swap", "[message]")
} }
#endif #endif
namespace { namespace
{
const char *const data = "Hi"; const char *const data = "Hi";
} }

39
tests/monitor.cpp
View File

@ -8,7 +8,7 @@
class mock_monitor_t : public zmq::monitor_t class mock_monitor_t : public zmq::monitor_t
{ {
public: public:
void on_event_connect_delayed(const zmq_event_t &, const char *) ZMQ_OVERRIDE void on_event_connect_delayed(const zmq_event_t &, const char *) ZMQ_OVERRIDE
{ {
++connect_delayed; ++connect_delayed;
@ -38,13 +38,11 @@ TEST_CASE("monitor move construct", "[monitor]")
{ {
zmq::context_t ctx; zmq::context_t ctx;
zmq::socket_t sock(ctx, ZMQ_DEALER); zmq::socket_t sock(ctx, ZMQ_DEALER);
SECTION("move ctor empty") SECTION("move ctor empty") {
{
zmq::monitor_t monitor1; zmq::monitor_t monitor1;
zmq::monitor_t monitor2 = std::move(monitor1); zmq::monitor_t monitor2 = std::move(monitor1);
} }
SECTION("move ctor init") SECTION("move ctor init") {
{
zmq::monitor_t monitor1; zmq::monitor_t monitor1;
monitor1.init(sock, "inproc://monitor-client"); monitor1.init(sock, "inproc://monitor-client");
zmq::monitor_t monitor2 = std::move(monitor1); zmq::monitor_t monitor2 = std::move(monitor1);
@ -55,21 +53,18 @@ TEST_CASE("monitor move assign", "[monitor]")
{ {
zmq::context_t ctx; zmq::context_t ctx;
zmq::socket_t sock(ctx, ZMQ_DEALER); zmq::socket_t sock(ctx, ZMQ_DEALER);
SECTION("move assign empty") SECTION("move assign empty") {
{ zmq::monitor_t monitor1;
zmq::monitor_t monitor1; zmq::monitor_t monitor2;
zmq::monitor_t monitor2; monitor1 = std::move(monitor2);
monitor1 = std::move(monitor2);
} }
SECTION("move assign init") SECTION("move assign init") {
{
zmq::monitor_t monitor1; zmq::monitor_t monitor1;
monitor1.init(sock, "inproc://monitor-client"); monitor1.init(sock, "inproc://monitor-client");
zmq::monitor_t monitor2; zmq::monitor_t monitor2;
monitor2 = std::move(monitor1); monitor2 = std::move(monitor1);
} }
SECTION("move assign init both") SECTION("move assign init both") {
{
zmq::monitor_t monitor1; zmq::monitor_t monitor1;
monitor1.init(sock, "inproc://monitor-client"); monitor1.init(sock, "inproc://monitor-client");
zmq::monitor_t monitor2; zmq::monitor_t monitor2;
@ -101,10 +96,11 @@ TEST_CASE("monitor init abort", "[monitor]")
{ {
class mock_monitor : public mock_monitor_t class mock_monitor : public mock_monitor_t
{ {
public: public:
mock_monitor(std::function<void(void)> handle_connected) mock_monitor(std::function<void(void)> handle_connected) :
: handle_connected{std::move(handle_connected)} handle_connected{std::move(handle_connected)}
{} {
}
void on_event_connected(const zmq_event_t &e, const char *m) ZMQ_OVERRIDE void on_event_connected(const zmq_event_t &e, const char *m) ZMQ_OVERRIDE
{ {
@ -113,7 +109,6 @@ TEST_CASE("monitor init abort", "[monitor]")
} }
std::function<void(void)> handle_connected; std::function<void(void)> handle_connected;
}; };
common_server_client_setup s(false); common_server_client_setup s(false);
@ -122,14 +117,16 @@ TEST_CASE("monitor init abort", "[monitor]")
std::condition_variable cond_var; std::condition_variable cond_var;
bool done{false}; bool done{false};
mock_monitor monitor([&]() { mock_monitor monitor([&]()
{
std::lock_guard<std::mutex> lock(mutex); std::lock_guard<std::mutex> lock(mutex);
done = true; done = true;
cond_var.notify_one(); cond_var.notify_one();
}); });
monitor.init(s.client, "inproc://foo"); monitor.init(s.client, "inproc://foo");
auto thread = std::thread([&monitor] { auto thread = std::thread([&monitor]
{
while (monitor.check_event(-1)) { while (monitor.check_event(-1)) {
} }
}); });

8
tests/multipart.cpp
View File

@ -74,12 +74,12 @@ TEST_CASE("multipart legacy test", "[multipart]")
multipart.pushtyp(1.0f); multipart.pushtyp(1.0f);
multipart.pushmem("Frame0", 6); multipart.pushmem("Frame0", 6);
assert(multipart.size() == 10); assert(multipart.size() == 10);
const message_t& front_msg = multipart.front(); const message_t &front_msg = multipart.front();
assert(multipart.size() == 10); assert(multipart.size() == 10);
assert(std::string(front_msg.data<char>(), front_msg.size()) == "Frame0"); assert(std::string(front_msg.data<char>(), front_msg.size()) == "Frame0");
const message_t& back_msg = multipart.back(); const message_t &back_msg = multipart.back();
assert(multipart.size() == 10); assert(multipart.size() == 10);
assert(std::string(back_msg.data<char>(), back_msg.size()) == "Frame9"); assert(std::string(back_msg.data<char>(), back_msg.size()) == "Frame9");

35
tests/poller.cpp
View File

@ -9,15 +9,16 @@
static_assert(std::is_nothrow_swappable_v<zmq::poller_t<>>); static_assert(std::is_nothrow_swappable_v<zmq::poller_t<>>);
#endif #endif
static_assert(sizeof(zmq_poller_event_t) == sizeof(zmq::poller_event<>), ""); static_assert(sizeof(zmq_poller_event_t) == sizeof(zmq::poller_event<>), "");
static_assert(sizeof(zmq_poller_event_t) == sizeof(zmq::poller_event<zmq::no_user_data>), ""); static_assert(sizeof(zmq_poller_event_t) == sizeof(zmq::poller_event<zmq::
no_user_data>), "");
static_assert(sizeof(zmq_poller_event_t) == sizeof(zmq::poller_event<int>), ""); static_assert(sizeof(zmq_poller_event_t) == sizeof(zmq::poller_event<int>), "");
static_assert(alignof(zmq_poller_event_t) == alignof(zmq::poller_event<>), ""); static_assert(alignof(zmq_poller_event_t) == alignof(zmq::poller_event<>), "");
static_assert(alignof(zmq_poller_event_t) == alignof(zmq::poller_event<int>), ""); static_assert(alignof(zmq_poller_event_t) == alignof(zmq::poller_event<int>), "");
static_assert(!std::is_copy_constructible<zmq::poller_t<>>::value, static_assert(!std::is_copy_constructible<zmq::poller_t<>>::value,
"poller_t should not be copy-constructible"); "poller_t should not be copy-constructible");
static_assert(!std::is_copy_assignable<zmq::poller_t<>>::value, static_assert(!std::is_copy_assignable<zmq::poller_t<>>::value,
"poller_t should not be copy-assignable"); "poller_t should not be copy-assignable");
TEST_CASE("event flags", "[poller]") TEST_CASE("event flags", "[poller]")
{ {
@ -106,7 +107,9 @@ TEST_CASE("poller add handler invalid events type", "[poller]")
zmq::socket_t socket{context, zmq::socket_type::router}; zmq::socket_t socket{context, zmq::socket_type::router};
zmq::poller_t<> poller; zmq::poller_t<> poller;
short invalid_events_type = 2 << 10; short invalid_events_type = 2 << 10;
CHECK_THROWS_AS(poller.add(socket, static_cast<zmq::event_flags>(invalid_events_type)), const zmq::error_t&); CHECK_THROWS_AS(
poller.add(socket, static_cast<zmq::event_flags>(invalid_events_type)),
const zmq::error_t&);
} }
#endif #endif
@ -117,7 +120,8 @@ TEST_CASE("poller add handler twice throws", "[poller]")
zmq::poller_t<> poller; zmq::poller_t<> poller;
poller.add(socket, zmq::event_flags::pollin); poller.add(socket, zmq::event_flags::pollin);
/// \todo the actual error code should be checked /// \todo the actual error code should be checked
CHECK_THROWS_AS(poller.add(socket, zmq::event_flags::pollin), const zmq::error_t&); CHECK_THROWS_AS(poller.add(socket, zmq::event_flags::pollin),
const zmq::error_t&);
} }
TEST_CASE("poller wait with no handlers throws", "[poller]") TEST_CASE("poller wait with no handlers throws", "[poller]")
@ -126,7 +130,7 @@ TEST_CASE("poller wait with no handlers throws", "[poller]")
std::vector<zmq::poller_event<>> events; std::vector<zmq::poller_event<>> events;
/// \todo the actual error code should be checked /// \todo the actual error code should be checked
CHECK_THROWS_AS(poller.wait_all(events, std::chrono::milliseconds{10}), CHECK_THROWS_AS(poller.wait_all(events, std::chrono::milliseconds{10}),
const zmq::error_t&); const zmq::error_t&);
} }
TEST_CASE("poller remove unregistered throws", "[poller]") TEST_CASE("poller remove unregistered throws", "[poller]")
@ -198,7 +202,8 @@ TEST_CASE("poller modify empty throws", "[poller]")
zmq::context_t context; zmq::context_t context;
zmq::socket_t socket{context, zmq::socket_type::push}; zmq::socket_t socket{context, zmq::socket_type::push};
zmq::poller_t<> poller; zmq::poller_t<> poller;
CHECK_THROWS_AS(poller.modify(socket, zmq::event_flags::pollin), const zmq::error_t&); CHECK_THROWS_AS(poller.modify(socket, zmq::event_flags::pollin),
const zmq::error_t&);
} }
TEST_CASE("poller modify invalid socket throws", "[poller]") TEST_CASE("poller modify invalid socket throws", "[poller]")
@ -226,7 +231,8 @@ TEST_CASE("poller modify simple", "[poller]")
zmq::socket_t a{context, zmq::socket_type::push}; zmq::socket_t a{context, zmq::socket_type::push};
zmq::poller_t<> poller; zmq::poller_t<> poller;
CHECK_NOTHROW(poller.add(a, zmq::event_flags::pollin)); CHECK_NOTHROW(poller.add(a, zmq::event_flags::pollin));
CHECK_NOTHROW(poller.modify(a, zmq::event_flags::pollin | zmq::event_flags::pollout)); CHECK_NOTHROW(
poller.modify(a, zmq::event_flags::pollin | zmq::event_flags::pollout));
} }
TEST_CASE("poller poll client server", "[poller]") TEST_CASE("poller poll client server", "[poller]")
@ -247,9 +253,12 @@ TEST_CASE("poller poll client server", "[poller]")
CHECK(zmq::event_flags::pollin == events[0].events); CHECK(zmq::event_flags::pollin == events[0].events);
// Modify server socket with pollout flag // Modify server socket with pollout flag
CHECK_NOTHROW(poller.modify(s.server, zmq::event_flags::pollin | zmq::event_flags::pollout)); CHECK_NOTHROW(
poller.modify(s.server, zmq::event_flags::pollin | zmq::event_flags::pollout
));
CHECK(1 == poller.wait_all(events, std::chrono::milliseconds{500})); CHECK(1 == poller.wait_all(events, std::chrono::milliseconds{500}));
CHECK((zmq::event_flags::pollin | zmq::event_flags::pollout) == events[0].events); CHECK((zmq::event_flags::pollin | zmq::event_flags::pollout) == events[0].events)
;
} }
TEST_CASE("poller wait one return", "[poller]") TEST_CASE("poller wait one return", "[poller]")
@ -278,7 +287,8 @@ TEST_CASE("poller wait on move constructed", "[poller]")
zmq::poller_t<> b{std::move(a)}; zmq::poller_t<> b{std::move(a)};
std::vector<zmq::poller_event<>> events(1); std::vector<zmq::poller_event<>> events(1);
/// \todo the actual error code should be checked /// \todo the actual error code should be checked
CHECK_THROWS_AS(a.wait_all(events, std::chrono::milliseconds{10}), const zmq::error_t&); CHECK_THROWS_AS(a.wait_all(events, std::chrono::milliseconds{10}),
const zmq::error_t&);
CHECK(1 == b.wait_all(events, std::chrono::milliseconds{-1})); CHECK(1 == b.wait_all(events, std::chrono::milliseconds{-1}));
} }
@ -292,7 +302,8 @@ TEST_CASE("poller wait on move assigned", "[poller]")
b = {std::move(a)}; b = {std::move(a)};
/// \todo the TEST_CASE error code should be checked /// \todo the TEST_CASE error code should be checked
std::vector<zmq::poller_event<>> events(1); std::vector<zmq::poller_event<>> events(1);
CHECK_THROWS_AS(a.wait_all(events, std::chrono::milliseconds{10}), const zmq::error_t&); CHECK_THROWS_AS(a.wait_all(events, std::chrono::milliseconds{10}),
const zmq::error_t&);
CHECK(1 == b.wait_all(events, std::chrono::milliseconds{-1})); CHECK(1 == b.wait_all(events, std::chrono::milliseconds{-1}));
} }

65
tests/recv_multipart.cpp
View File

@ -10,8 +10,7 @@ TEST_CASE("recv_multipart test", "[recv_multipart]")
output.bind("inproc://multipart.test"); output.bind("inproc://multipart.test");
input.connect("inproc://multipart.test"); input.connect("inproc://multipart.test");
SECTION("send 1 message") SECTION("send 1 message") {
{
input.send(zmq::str_buffer("hello")); input.send(zmq::str_buffer("hello"));
std::vector<zmq::message_t> msgs; std::vector<zmq::message_t> msgs;
@ -21,8 +20,7 @@ TEST_CASE("recv_multipart test", "[recv_multipart]")
REQUIRE(msgs.size() == 1); REQUIRE(msgs.size() == 1);
CHECK(msgs[0].size() == 5); CHECK(msgs[0].size() == 5);
} }
SECTION("send 2 messages") SECTION("send 2 messages") {
{
input.send(zmq::str_buffer("hello"), zmq::send_flags::sndmore); input.send(zmq::str_buffer("hello"), zmq::send_flags::sndmore);
input.send(zmq::str_buffer("world!")); input.send(zmq::str_buffer("world!"));
@ -34,26 +32,27 @@ TEST_CASE("recv_multipart test", "[recv_multipart]")
CHECK(msgs[0].size() == 5); CHECK(msgs[0].size() == 5);
CHECK(msgs[1].size() == 6); CHECK(msgs[1].size() == 6);
} }
SECTION("send no messages, dontwait") SECTION("send no messages, dontwait") {
{
std::vector<zmq::message_t> msgs; std::vector<zmq::message_t> msgs;
auto ret = zmq::recv_multipart(output, std::back_inserter(msgs), zmq::recv_flags::dontwait); auto ret = zmq::recv_multipart(output, std::back_inserter(msgs),
zmq::recv_flags::dontwait);
CHECK_FALSE(ret); CHECK_FALSE(ret);
REQUIRE(msgs.size() == 0); REQUIRE(msgs.size() == 0);
} }
SECTION("send 1 partial message, dontwait") SECTION("send 1 partial message, dontwait") {
{
input.send(zmq::str_buffer("hello"), zmq::send_flags::sndmore); input.send(zmq::str_buffer("hello"), zmq::send_flags::sndmore);
std::vector<zmq::message_t> msgs; std::vector<zmq::message_t> msgs;
auto ret = zmq::recv_multipart(output, std::back_inserter(msgs), zmq::recv_flags::dontwait); auto ret = zmq::recv_multipart(output, std::back_inserter(msgs),
zmq::recv_flags::dontwait);
CHECK_FALSE(ret); CHECK_FALSE(ret);
REQUIRE(msgs.size() == 0); REQUIRE(msgs.size() == 0);
} }
SECTION("recv with invalid socket") SECTION("recv with invalid socket") {
{
std::vector<zmq::message_t> msgs; std::vector<zmq::message_t> msgs;
CHECK_THROWS_AS(zmq::recv_multipart(zmq::socket_ref(), std::back_inserter(msgs)), const zmq::error_t &); CHECK_THROWS_AS(
zmq::recv_multipart(zmq::socket_ref(), std::back_inserter(msgs)),
const zmq::error_t &);
} }
} }
@ -65,8 +64,7 @@ TEST_CASE("recv_multipart_n test", "[recv_multipart]")
output.bind("inproc://multipart.test"); output.bind("inproc://multipart.test");
input.connect("inproc://multipart.test"); input.connect("inproc://multipart.test");
SECTION("send 1 message") SECTION("send 1 message") {
{
input.send(zmq::str_buffer("hello")); input.send(zmq::str_buffer("hello"));
std::array<zmq::message_t, 1> msgs; std::array<zmq::message_t, 1> msgs;
@ -75,8 +73,7 @@ TEST_CASE("recv_multipart_n test", "[recv_multipart]")
CHECK(*ret == 1); CHECK(*ret == 1);
CHECK(msgs[0].size() == 5); CHECK(msgs[0].size() == 5);
} }
SECTION("send 1 message 2") SECTION("send 1 message 2") {
{
input.send(zmq::str_buffer("hello")); input.send(zmq::str_buffer("hello"));
std::array<zmq::message_t, 2> msgs; std::array<zmq::message_t, 2> msgs;
@ -86,28 +83,25 @@ TEST_CASE("recv_multipart_n test", "[recv_multipart]")
CHECK(msgs[0].size() == 5); CHECK(msgs[0].size() == 5);
CHECK(msgs[1].size() == 0); CHECK(msgs[1].size() == 0);
} }
SECTION("send 2 messages, recv 1") SECTION("send 2 messages, recv 1") {
{
input.send(zmq::str_buffer("hello"), zmq::send_flags::sndmore); input.send(zmq::str_buffer("hello"), zmq::send_flags::sndmore);
input.send(zmq::str_buffer("world!")); input.send(zmq::str_buffer("world!"));
std::array<zmq::message_t, 1> msgs; std::array<zmq::message_t, 1> msgs;
CHECK_THROWS_AS( CHECK_THROWS_AS(
zmq::recv_multipart_n(output, msgs.data(), msgs.size()), zmq::recv_multipart_n(output, msgs.data(), msgs.size()),
const std::runtime_error&); const std::runtime_error&);
} }
SECTION("recv 0") SECTION("recv 0") {
{
input.send(zmq::str_buffer("hello"), zmq::send_flags::sndmore); input.send(zmq::str_buffer("hello"), zmq::send_flags::sndmore);
input.send(zmq::str_buffer("world!")); input.send(zmq::str_buffer("world!"));
std::array<zmq::message_t, 1> msgs; std::array<zmq::message_t, 1> msgs;
CHECK_THROWS_AS( CHECK_THROWS_AS(
zmq::recv_multipart_n(output, msgs.data(), 0), zmq::recv_multipart_n(output, msgs.data(), 0),
const std::runtime_error&); const std::runtime_error&);
} }
SECTION("send 2 messages") SECTION("send 2 messages") {
{
input.send(zmq::str_buffer("hello"), zmq::send_flags::sndmore); input.send(zmq::str_buffer("hello"), zmq::send_flags::sndmore);
input.send(zmq::str_buffer("world!")); input.send(zmq::str_buffer("world!"));
@ -118,26 +112,27 @@ TEST_CASE("recv_multipart_n test", "[recv_multipart]")
CHECK(msgs[0].size() == 5); CHECK(msgs[0].size() == 5);
CHECK(msgs[1].size() == 6); CHECK(msgs[1].size() == 6);
} }
SECTION("send no messages, dontwait") SECTION("send no messages, dontwait") {
{
std::array<zmq::message_t, 1> msgs; std::array<zmq::message_t, 1> msgs;
auto ret = zmq::recv_multipart_n(output, msgs.data(), msgs.size(), zmq::recv_flags::dontwait); auto ret = zmq::recv_multipart_n(output, msgs.data(), msgs.size(),
zmq::recv_flags::dontwait);
CHECK_FALSE(ret); CHECK_FALSE(ret);
REQUIRE(msgs[0].size() == 0); REQUIRE(msgs[0].size() == 0);
} }
SECTION("send 1 partial message, dontwait") SECTION("send 1 partial message, dontwait") {
{
input.send(zmq::str_buffer("hello"), zmq::send_flags::sndmore); input.send(zmq::str_buffer("hello"), zmq::send_flags::sndmore);
std::array<zmq::message_t, 1> msgs; std::array<zmq::message_t, 1> msgs;
auto ret = zmq::recv_multipart_n(output, msgs.data(), msgs.size(), zmq::recv_flags::dontwait); auto ret = zmq::recv_multipart_n(output, msgs.data(), msgs.size(),
zmq::recv_flags::dontwait);
CHECK_FALSE(ret); CHECK_FALSE(ret);
REQUIRE(msgs[0].size() == 0); REQUIRE(msgs[0].size() == 0);
} }
SECTION("recv with invalid socket") SECTION("recv with invalid socket") {
{
std::array<zmq::message_t, 1> msgs; std::array<zmq::message_t, 1> msgs;
CHECK_THROWS_AS(zmq::recv_multipart_n(zmq::socket_ref(), msgs.data(), msgs.size()), const zmq::error_t &); CHECK_THROWS_AS(
zmq::recv_multipart_n(zmq::socket_ref(), msgs.data(), msgs.size()),
const zmq::error_t &);
} }
} }

41
tests/send_multipart.cpp
View File

@ -12,15 +12,13 @@ TEST_CASE("send_multipart test", "[send_multipart]")
output.bind("inproc://multipart.test"); output.bind("inproc://multipart.test");
input.connect("inproc://multipart.test"); input.connect("inproc://multipart.test");
SECTION("send 0 messages") SECTION("send 0 messages") {
{
std::vector<zmq::message_t> imsgs; std::vector<zmq::message_t> imsgs;
auto iret = zmq::send_multipart(input, imsgs); auto iret = zmq::send_multipart(input, imsgs);
REQUIRE(iret); REQUIRE(iret);
CHECK(*iret == 0); CHECK(*iret == 0);
} }
SECTION("send 1 message") SECTION("send 1 message") {
{
std::array<zmq::message_t, 1> imsgs = {zmq::message_t(3)}; std::array<zmq::message_t, 1> imsgs = {zmq::message_t(3)};
auto iret = zmq::send_multipart(input, imsgs); auto iret = zmq::send_multipart(input, imsgs);
REQUIRE(iret); REQUIRE(iret);
@ -33,8 +31,7 @@ TEST_CASE("send_multipart test", "[send_multipart]")
REQUIRE(omsgs.size() == 1); REQUIRE(omsgs.size() == 1);
CHECK(omsgs[0].size() == 3); CHECK(omsgs[0].size() == 3);
} }
SECTION("send 2 messages") SECTION("send 2 messages") {
{
std::array<zmq::message_t, 2> imsgs = {zmq::message_t(3), zmq::message_t(4)}; std::array<zmq::message_t, 2> imsgs = {zmq::message_t(3), zmq::message_t(4)};
auto iret = zmq::send_multipart(input, imsgs); auto iret = zmq::send_multipart(input, imsgs);
REQUIRE(iret); REQUIRE(iret);
@ -48,9 +45,9 @@ TEST_CASE("send_multipart test", "[send_multipart]")
CHECK(omsgs[0].size() == 3); CHECK(omsgs[0].size() == 3);
CHECK(omsgs[1].size() == 4); CHECK(omsgs[1].size() == 4);
} }
SECTION("send 2 messages, const_buffer") SECTION("send 2 messages, const_buffer") {
{ std::array<zmq::const_buffer, 2> imsgs = {zmq::str_buffer("foo"),
std::array<zmq::const_buffer, 2> imsgs = {zmq::str_buffer("foo"), zmq::str_buffer("bar!")}; zmq::str_buffer("bar!")};
auto iret = zmq::send_multipart(input, imsgs); auto iret = zmq::send_multipart(input, imsgs);
REQUIRE(iret); REQUIRE(iret);
CHECK(*iret == 2); CHECK(*iret == 2);
@ -63,10 +60,10 @@ TEST_CASE("send_multipart test", "[send_multipart]")
CHECK(omsgs[0].size() == 3); CHECK(omsgs[0].size() == 3);
CHECK(omsgs[1].size() == 4); CHECK(omsgs[1].size() == 4);
} }
SECTION("send 2 messages, mutable_buffer") SECTION("send 2 messages, mutable_buffer") {
{
char buf[4] = {}; char buf[4] = {};
std::array<zmq::mutable_buffer, 2> imsgs = {zmq::buffer(buf, 3), zmq::buffer(buf)}; std::array<zmq::mutable_buffer, 2> imsgs = {
zmq::buffer(buf, 3), zmq::buffer(buf)};
auto iret = zmq::send_multipart(input, imsgs); auto iret = zmq::send_multipart(input, imsgs);
REQUIRE(iret); REQUIRE(iret);
CHECK(*iret == 2); CHECK(*iret == 2);
@ -79,17 +76,15 @@ TEST_CASE("send_multipart test", "[send_multipart]")
CHECK(omsgs[0].size() == 3); CHECK(omsgs[0].size() == 3);
CHECK(omsgs[1].size() == 4); CHECK(omsgs[1].size() == 4);
} }
SECTION("send 2 messages, dontwait") SECTION("send 2 messages, dontwait") {
{
zmq::socket_t push(context, ZMQ_PUSH); zmq::socket_t push(context, ZMQ_PUSH);
push.bind("inproc://multipart.test.push"); push.bind("inproc://multipart.test.push");
std::array<zmq::message_t, 2> imsgs = {zmq::message_t(3), zmq::message_t(4)}; std::array<zmq::message_t, 2> imsgs = {zmq::message_t(3), zmq::message_t(4)};
auto iret = zmq::send_multipart(push, imsgs, zmq::send_flags::dontwait); auto iret = zmq::send_multipart(push, imsgs, zmq::send_flags::dontwait);
REQUIRE_FALSE(iret); REQUIRE_FALSE(iret);
} }
SECTION("send, misc. containers") SECTION("send, misc. containers") {
{
std::vector<zmq::message_t> msgs_vec; std::vector<zmq::message_t> msgs_vec;
msgs_vec.emplace_back(3); msgs_vec.emplace_back(3);
msgs_vec.emplace_back(4); msgs_vec.emplace_back(4);
@ -110,15 +105,17 @@ TEST_CASE("send_multipart test", "[send_multipart]")
REQUIRE(iret); REQUIRE(iret);
CHECK(*iret == 2); CHECK(*iret == 2);
// rvalue // rvalue
iret = zmq::send_multipart(input, iret = zmq::send_multipart(input,
std::initializer_list<zmq::const_buffer>{zmq::str_buffer("foo"), zmq::str_buffer("bar!")}); std::initializer_list<zmq::const_buffer>{
zmq::str_buffer("foo"),
zmq::str_buffer("bar!")});
REQUIRE(iret); REQUIRE(iret);
CHECK(*iret == 2); CHECK(*iret == 2);
} }
SECTION("send with invalid socket") SECTION("send with invalid socket") {
{
std::vector<zmq::message_t> msgs(1); std::vector<zmq::message_t> msgs(1);
CHECK_THROWS_AS(zmq::send_multipart(zmq::socket_ref(), msgs), const zmq::error_t &); CHECK_THROWS_AS(zmq::send_multipart(zmq::socket_ref(), msgs),
const zmq::error_t &);
} }
} }
#endif #endif

40
tests/socket.cpp
View File

@ -50,19 +50,19 @@ TEST_CASE("socket swap", "[socket]")
TEST_CASE("socket flags", "[socket]") TEST_CASE("socket flags", "[socket]")
{ {
CHECK((zmq::recv_flags::dontwait | zmq::recv_flags::none) CHECK((zmq::recv_flags::dontwait | zmq::recv_flags::none)
== static_cast<zmq::recv_flags>(ZMQ_DONTWAIT | 0)); == static_cast<zmq::recv_flags>(ZMQ_DONTWAIT | 0));
CHECK((zmq::recv_flags::dontwait & zmq::recv_flags::none) CHECK((zmq::recv_flags::dontwait & zmq::recv_flags::none)
== static_cast<zmq::recv_flags>(ZMQ_DONTWAIT & 0)); == static_cast<zmq::recv_flags>(ZMQ_DONTWAIT & 0));
CHECK((zmq::recv_flags::dontwait ^ zmq::recv_flags::none) CHECK((zmq::recv_flags::dontwait ^ zmq::recv_flags::none)
== static_cast<zmq::recv_flags>(ZMQ_DONTWAIT ^ 0)); == static_cast<zmq::recv_flags>(ZMQ_DONTWAIT ^ 0));
CHECK(~zmq::recv_flags::dontwait == static_cast<zmq::recv_flags>(~ZMQ_DONTWAIT)); CHECK(~zmq::recv_flags::dontwait == static_cast<zmq::recv_flags>(~ZMQ_DONTWAIT));
CHECK((zmq::send_flags::dontwait | zmq::send_flags::sndmore) CHECK((zmq::send_flags::dontwait | zmq::send_flags::sndmore)
== static_cast<zmq::send_flags>(ZMQ_DONTWAIT | ZMQ_SNDMORE)); == static_cast<zmq::send_flags>(ZMQ_DONTWAIT | ZMQ_SNDMORE));
CHECK((zmq::send_flags::dontwait & zmq::send_flags::sndmore) CHECK((zmq::send_flags::dontwait & zmq::send_flags::sndmore)
== static_cast<zmq::send_flags>(ZMQ_DONTWAIT & ZMQ_SNDMORE)); == static_cast<zmq::send_flags>(ZMQ_DONTWAIT & ZMQ_SNDMORE));
CHECK((zmq::send_flags::dontwait ^ zmq::send_flags::sndmore) CHECK((zmq::send_flags::dontwait ^ zmq::send_flags::sndmore)
== static_cast<zmq::send_flags>(ZMQ_DONTWAIT ^ ZMQ_SNDMORE)); == static_cast<zmq::send_flags>(ZMQ_DONTWAIT ^ ZMQ_SNDMORE));
CHECK(~zmq::send_flags::dontwait == static_cast<zmq::send_flags>(~ZMQ_DONTWAIT)); CHECK(~zmq::send_flags::dontwait == static_cast<zmq::send_flags>(~ZMQ_DONTWAIT));
} }
@ -82,20 +82,20 @@ TEST_CASE("socket sends and receives const buffer", "[socket]")
zmq::socket_t receiver(context, ZMQ_PAIR); zmq::socket_t receiver(context, ZMQ_PAIR);
receiver.bind("inproc://test"); receiver.bind("inproc://test");
sender.connect("inproc://test"); sender.connect("inproc://test");
const char* str = "Hi"; const char *str = "Hi";
#ifdef ZMQ_CPP11 #ifdef ZMQ_CPP11
CHECK(2 == *sender.send(zmq::buffer(str, 2))); CHECK(2 == *sender.send(zmq::buffer(str, 2)));
char buf[2]; char buf[2];
const auto res = receiver.recv(zmq::buffer(buf)); const auto res = receiver.recv(zmq::buffer(buf));
CHECK(res); CHECK(res);
CHECK(!res->truncated()); CHECK(!res->truncated());
CHECK(2 == res->size); CHECK(2 == res->size);
#else #else
CHECK(2 == sender.send(str, 2)); CHECK(2 == sender.send(str, 2));
char buf[2]; char buf[2];
CHECK(2 == receiver.recv(buf, 2)); CHECK(2 == receiver.recv(buf, 2));
#endif #endif
CHECK(0 == memcmp(buf, str, 2)); CHECK(0 == memcmp(buf, str, 2));
} }
@ -126,7 +126,7 @@ TEST_CASE("socket send dontwait", "[socket]")
auto res = s.send(zmq::buffer(buf), zmq::send_flags::dontwait); auto res = s.send(zmq::buffer(buf), zmq::send_flags::dontwait);
CHECK(!res); CHECK(!res);
res = s.send(zmq::buffer(buf), res = s.send(zmq::buffer(buf),
zmq::send_flags::dontwait | zmq::send_flags::sndmore); zmq::send_flags::dontwait | zmq::send_flags::sndmore);
CHECK(!res); CHECK(!res);
zmq::message_t msg; zmq::message_t msg;
@ -253,16 +253,15 @@ TEST_CASE("socket proxy", "[socket]")
front.bind("inproc://test1"); front.bind("inproc://test1");
back.bind("inproc://test2"); back.bind("inproc://test2");
capture.bind("inproc://test3"); capture.bind("inproc://test3");
auto f = std::async(std::launch::async, [&]() { auto f = std::async(std::launch::async, [&]()
{
auto s1 = std::move(front); auto s1 = std::move(front);
auto s2 = std::move(back); auto s2 = std::move(back);
auto s3 = std::move(capture); auto s3 = std::move(capture);
try try {
{
zmq::proxy(s1, s2, zmq::socket_ref(s3)); zmq::proxy(s1, s2, zmq::socket_ref(s3));
} }
catch (const zmq::error_t& e) catch (const zmq::error_t &e) {
{
return e.num() == ETERM; return e.num() == ETERM;
} }
return false; return false;
@ -280,16 +279,15 @@ TEST_CASE("socket proxy steerable", "[socket]")
front.bind("inproc://test1"); front.bind("inproc://test1");
back.bind("inproc://test2"); back.bind("inproc://test2");
control.connect("inproc://test3"); control.connect("inproc://test3");
auto f = std::async(std::launch::async, [&]() { auto f = std::async(std::launch::async, [&]()
{
auto s1 = std::move(front); auto s1 = std::move(front);
auto s2 = std::move(back); auto s2 = std::move(back);
auto s3 = std::move(control); auto s3 = std::move(control);
try try {
{
zmq::proxy_steerable(s1, s2, zmq::socket_ref(), s3); zmq::proxy_steerable(s1, s2, zmq::socket_ref(), s3);
} }
catch (const zmq::error_t& e) catch (const zmq::error_t &e) {
{
return e.num() == ETERM; return e.num() == ETERM;
} }
return false; return false;

4
tests/socket_ref.cpp
View File

@ -8,7 +8,7 @@ static_assert(std::is_nothrow_swappable_v<zmq::socket_ref>);
static_assert(sizeof(zmq::socket_ref) == sizeof(void *), "size mismatch"); static_assert(sizeof(zmq::socket_ref) == sizeof(void *), "size mismatch");
static_assert(alignof(zmq::socket_ref) == alignof(void *), "alignment mismatch"); static_assert(alignof(zmq::socket_ref) == alignof(void *), "alignment mismatch");
static_assert(ZMQ_IS_TRIVIALLY_COPYABLE(zmq::socket_ref), static_assert(ZMQ_IS_TRIVIALLY_COPYABLE(zmq::socket_ref),
"needs to be trivially copyable"); "needs to be trivially copyable");
TEST_CASE("socket_ref default init", "[socket_ref]") TEST_CASE("socket_ref default init", "[socket_ref]")
{ {
@ -111,7 +111,7 @@ TEST_CASE("socket_ref type punning", "[socket_ref]")
CHECK(socket.handle() != nullptr); CHECK(socket.handle() != nullptr);
svp.p = socket.handle(); svp.p = socket.handle();
// static_cast to silence incorrect warning // static_cast to silence incorrect warning
std::memcpy(static_cast<void*>(&ssr), &svp, sizeof(ssr)); std::memcpy(static_cast<void *>(&ssr), &svp, sizeof(ssr));
CHECK(ssr.sr == socket); CHECK(ssr.sr == socket);
} }

14
tests/utilities.cpp
View File

@ -8,31 +8,38 @@ namespace test_ns
struct T_nr struct T_nr
{ {
}; };
struct T_mr struct T_mr
{ {
void *begin() const noexcept { return nullptr; } void *begin() const noexcept { return nullptr; }
void *end() const noexcept { return nullptr; } void *end() const noexcept { return nullptr; }
}; };
struct T_fr struct T_fr
{ {
}; };
inline void *begin(const T_fr &) noexcept inline void *begin(const T_fr &) noexcept
{ {
return nullptr; return nullptr;
} }
inline void *end(const T_fr &) noexcept inline void *end(const T_fr &) noexcept
{ {
return nullptr; return nullptr;
} }
struct T_mfr struct T_mfr
{ {
void *begin() const noexcept { return nullptr; } void *begin() const noexcept { return nullptr; }
void *end() const noexcept { return nullptr; } void *end() const noexcept { return nullptr; }
}; };
inline void *begin(const T_mfr &) noexcept inline void *begin(const T_mfr &) noexcept
{ {
return nullptr; return nullptr;
} }
inline void *end(const T_mfr &) noexcept inline void *end(const T_mfr &) noexcept
{ {
return nullptr; return nullptr;
@ -42,31 +49,38 @@ inline void *end(const T_mfr &) noexcept
struct T_assoc_ns_nr : std::exception struct T_assoc_ns_nr : std::exception
{ {
}; };
struct T_assoc_ns_mr : std::exception struct T_assoc_ns_mr : std::exception
{ {
void *begin() const noexcept { return nullptr; } void *begin() const noexcept { return nullptr; }
void *end() const noexcept { return nullptr; } void *end() const noexcept { return nullptr; }
}; };
struct T_assoc_ns_fr : std::exception struct T_assoc_ns_fr : std::exception
{ {
}; };
inline void *begin(const T_assoc_ns_fr &) noexcept inline void *begin(const T_assoc_ns_fr &) noexcept
{ {
return nullptr; return nullptr;
} }
inline void *end(const T_assoc_ns_fr &) noexcept inline void *end(const T_assoc_ns_fr &) noexcept
{ {
return nullptr; return nullptr;
} }
struct T_assoc_ns_mfr : std::exception struct T_assoc_ns_mfr : std::exception
{ {
void *begin() const noexcept { return nullptr; } void *begin() const noexcept { return nullptr; }
void *end() const noexcept { return nullptr; } void *end() const noexcept { return nullptr; }
}; };
inline void *begin(const T_assoc_ns_mfr &) noexcept inline void *begin(const T_assoc_ns_mfr &) noexcept
{ {
return nullptr; return nullptr;
} }
inline void *end(const T_assoc_ns_mfr &) noexcept inline void *end(const T_assoc_ns_mfr &) noexcept
{ {
return nullptr; return nullptr;

250
zmq.hpp
View File

@ -27,16 +27,20 @@
#define __ZMQ_HPP_INCLUDED__ #define __ZMQ_HPP_INCLUDED__
// macros defined if has a specific standard or greater // macros defined if has a specific standard or greater
#if (defined(__cplusplus) && __cplusplus >= 201103L) || (defined(_MSC_VER) && _MSC_VER >= 1900) #if (defined(__cplusplus) && __cplusplus >= 201103L) \
#define ZMQ_CPP11 || (defined(_MSC_VER) && _MSC_VER >= 1900)
#define ZMQ_CPP11
#endif #endif
#if (defined(__cplusplus) && __cplusplus >= 201402L) || \ #if (defined(__cplusplus) && __cplusplus >= 201402L) \
(defined(_HAS_CXX14) && _HAS_CXX14 == 1) || \ || (defined(_HAS_CXX14) && _HAS_CXX14 == 1) \
(defined(_HAS_CXX17) && _HAS_CXX17 == 1) // _HAS_CXX14 might not be defined when using C++17 on MSVC || (defined(_HAS_CXX17) \
#define ZMQ_CPP14 && _HAS_CXX17 \
== 1) // _HAS_CXX14 might not be defined when using C++17 on MSVC
#define ZMQ_CPP14
#endif #endif
#if (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) #if (defined(__cplusplus) && __cplusplus >= 201703L) \
#define ZMQ_CPP17 || (defined(_HAS_CXX17) && _HAS_CXX17 == 1)
#define ZMQ_CPP17
#endif #endif
#if defined(ZMQ_CPP14) #if defined(ZMQ_CPP14)
@ -134,8 +138,8 @@
#define ZMQ_DELETED_FUNCTION #define ZMQ_DELETED_FUNCTION
#endif #endif
#if defined(ZMQ_CPP11) && !defined(__llvm__) && !defined(__INTEL_COMPILER) \ #if defined(ZMQ_CPP11) && !defined(__llvm__) && !defined(__INTEL_COMPILER) \
&& defined(__GNUC__) && __GNUC__ < 5 && defined(__GNUC__) && __GNUC__ < 5
#define ZMQ_CPP11_PARTIAL #define ZMQ_CPP11_PARTIAL
#elif defined(__GLIBCXX__) && __GLIBCXX__ < 20160805 #elif defined(__GLIBCXX__) && __GLIBCXX__ < 20160805
//the date here is the last date of gcc 4.9.4, which //the date here is the last date of gcc 4.9.4, which
@ -182,7 +186,6 @@ typedef struct
namespace zmq namespace zmq
{ {
#ifdef ZMQ_CPP11 #ifdef ZMQ_CPP11
namespace detail namespace detail
{ {
@ -190,13 +193,11 @@ namespace ranges
{ {
using std::begin; using std::begin;
using std::end; using std::end;
template<class T> template<class T> auto begin(T &&r) -> decltype(begin(std::forward<T>(r)))
auto begin(T&& r) -> decltype(begin(std::forward<T>(r)))
{ {
return begin(std::forward<T>(r)); return begin(std::forward<T>(r));
} }
template<class T> template<class T> auto end(T &&r) -> decltype(end(std::forward<T>(r)))
auto end(T&& r) -> decltype(end(std::forward<T>(r)))
{ {
return end(std::forward<T>(r)); return end(std::forward<T>(r));
} }
@ -211,8 +212,7 @@ template<class Range>
using range_iter_t = decltype( using range_iter_t = decltype(
ranges::begin(std::declval<typename std::remove_reference<Range>::type &>())); ranges::begin(std::declval<typename std::remove_reference<Range>::type &>()));
template<class Range> template<class Range> using range_value_t = iter_value_t<range_iter_t<Range>>;
using range_value_t = iter_value_t<range_iter_t<Range>>;
template<class T, class = void> struct is_range : std::false_type template<class T, class = void> struct is_range : std::false_type
{ {
@ -238,7 +238,10 @@ class error_t : public std::exception
{ {
public: public:
error_t() : errnum(zmq_errno()) {} error_t() : errnum(zmq_errno()) {}
virtual const char *what() const ZMQ_NOTHROW ZMQ_OVERRIDE { return zmq_strerror(errnum); } virtual const char *what() const ZMQ_NOTHROW ZMQ_OVERRIDE
{
return zmq_strerror(errnum);
}
int num() const { return errnum; } int num() const { return errnum; }
private: private:
@ -264,14 +267,16 @@ ZMQ_DEPRECATED("from 4.3.1, use poll taking non-const items")
inline int inline int
poll(zmq_pollitem_t const *items, size_t nitems, std::chrono::milliseconds timeout) poll(zmq_pollitem_t const *items, size_t nitems, std::chrono::milliseconds timeout)
{ {
return poll(const_cast<zmq_pollitem_t *>(items), nitems, static_cast<long>(timeout.count())); return poll(const_cast<zmq_pollitem_t *>(items), nitems,
static_cast<long>(timeout.count()));
} }
ZMQ_DEPRECATED("from 4.3.1, use poll taking non-const items") ZMQ_DEPRECATED("from 4.3.1, use poll taking non-const items")
inline int poll(std::vector<zmq_pollitem_t> const &items, inline int poll(std::vector<zmq_pollitem_t> const &items,
std::chrono::milliseconds timeout) std::chrono::milliseconds timeout)
{ {
return poll(const_cast<zmq_pollitem_t *>(items.data()), items.size(), static_cast<long>(timeout.count())); return poll(const_cast<zmq_pollitem_t *>(items.data()), items.size(),
static_cast<long>(timeout.count()));
} }
ZMQ_DEPRECATED("from 4.3.1, use poll taking non-const items") ZMQ_DEPRECATED("from 4.3.1, use poll taking non-const items")
@ -477,10 +482,7 @@ class message_t
return zmq_msg_size(const_cast<zmq_msg_t *>(&msg)); return zmq_msg_size(const_cast<zmq_msg_t *>(&msg));
} }
ZMQ_NODISCARD bool empty() const ZMQ_NOTHROW ZMQ_NODISCARD bool empty() const ZMQ_NOTHROW { return size() == 0u; }
{
return size() == 0u;
}
template<typename T> T *data() ZMQ_NOTHROW { return static_cast<T *>(data()); } template<typename T> T *data() ZMQ_NOTHROW { return static_cast<T *>(data()); }
@ -490,10 +492,7 @@ class message_t
} }
ZMQ_DEPRECATED("from 4.3.0, use operator== instead") ZMQ_DEPRECATED("from 4.3.0, use operator== instead")
bool equal(const message_t *other) const ZMQ_NOTHROW bool equal(const message_t *other) const ZMQ_NOTHROW { return *this == *other; }
{
return *this == *other;
}
bool operator==(const message_t &other) const ZMQ_NOTHROW bool operator==(const message_t &other) const ZMQ_NOTHROW
{ {
@ -529,7 +528,7 @@ class message_t
#if defined(ZMQ_BUILD_DRAFT_API) && ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 0) #if defined(ZMQ_BUILD_DRAFT_API) && ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 0)
uint32_t routing_id() const uint32_t routing_id() const
{ {
return zmq_msg_routing_id(const_cast<zmq_msg_t*>(&msg)); return zmq_msg_routing_id(const_cast<zmq_msg_t *>(&msg));
} }
void set_routing_id(uint32_t routing_id) void set_routing_id(uint32_t routing_id)
@ -539,12 +538,12 @@ class message_t
throw error_t(); throw error_t();
} }
const char* group() const const char *group() const
{ {
return zmq_msg_group(const_cast<zmq_msg_t*>(&msg)); return zmq_msg_group(const_cast<zmq_msg_t *>(&msg));
} }
void set_group(const char* group) void set_group(const char *group)
{ {
int rc = zmq_msg_set_group(&msg, group); int rc = zmq_msg_set_group(&msg, group);
if (rc != 0) if (rc != 0)
@ -555,13 +554,13 @@ class message_t
// interpret message content as a string // interpret message content as a string
std::string to_string() const std::string to_string() const
{ {
return std::string(static_cast<const char*>(data()), size()); return std::string(static_cast<const char *>(data()), size());
} }
#ifdef ZMQ_CPP17 #ifdef ZMQ_CPP17
// interpret message content as a string // interpret message content as a string
std::string_view to_string_view() const noexcept std::string_view to_string_view() const noexcept
{ {
return std::string_view(static_cast<const char*>(data()), size()); return std::string_view(static_cast<const char *>(data()), size());
} }
#endif #endif
@ -642,8 +641,7 @@ class context_t
} }
explicit context_t(int io_threads_, explicit context_t(int io_threads_, int max_sockets_ = ZMQ_MAX_SOCKETS_DFLT)
int max_sockets_ = ZMQ_MAX_SOCKETS_DFLT)
{ {
ptr = zmq_ctx_new(); ptr = zmq_ctx_new();
if (ptr == ZMQ_NULLPTR) if (ptr == ZMQ_NULLPTR)
@ -712,10 +710,7 @@ class context_t
operator bool() const ZMQ_NOTHROW { return ptr != ZMQ_NULLPTR; } operator bool() const ZMQ_NOTHROW { return ptr != ZMQ_NULLPTR; }
void swap(context_t &other) ZMQ_NOTHROW void swap(context_t &other) ZMQ_NOTHROW { std::swap(ptr, other.ptr); }
{
std::swap(ptr, other.ptr);
}
private: private:
void *ptr; void *ptr;
@ -724,7 +719,8 @@ class context_t
void operator=(const context_t &) ZMQ_DELETED_FUNCTION; void operator=(const context_t &) ZMQ_DELETED_FUNCTION;
}; };
inline void swap(context_t &a, context_t &b) ZMQ_NOTHROW { inline void swap(context_t &a, context_t &b) ZMQ_NOTHROW
{
a.swap(b); a.swap(b);
} }
@ -732,8 +728,8 @@ inline void swap(context_t &a, context_t &b) ZMQ_NOTHROW {
struct recv_buffer_size struct recv_buffer_size
{ {
size_t size; // number of bytes written to buffer size_t size; // number of bytes written to buffer
size_t untruncated_size; // untruncated message size in bytes size_t untruncated_size; // untruncated message size in bytes
ZMQ_NODISCARD bool truncated() const noexcept ZMQ_NODISCARD bool truncated() const noexcept
{ {
@ -814,30 +810,25 @@ using recv_buffer_result_t = detail::trivial_optional<recv_buffer_size>;
namespace detail namespace detail
{ {
template<class T> constexpr T enum_bit_or(T a, T b) noexcept
template<class T>
constexpr T enum_bit_or(T a, T b) noexcept
{ {
static_assert(std::is_enum<T>::value, "must be enum"); static_assert(std::is_enum<T>::value, "must be enum");
using U = typename std::underlying_type<T>::type; using U = typename std::underlying_type<T>::type;
return static_cast<T>(static_cast<U>(a) | static_cast<U>(b)); return static_cast<T>(static_cast<U>(a) | static_cast<U>(b));
} }
template<class T> template<class T> constexpr T enum_bit_and(T a, T b) noexcept
constexpr T enum_bit_and(T a, T b) noexcept
{ {
static_assert(std::is_enum<T>::value, "must be enum"); static_assert(std::is_enum<T>::value, "must be enum");
using U = typename std::underlying_type<T>::type; using U = typename std::underlying_type<T>::type;
return static_cast<T>(static_cast<U>(a) & static_cast<U>(b)); return static_cast<T>(static_cast<U>(a) & static_cast<U>(b));
} }
template<class T> template<class T> constexpr T enum_bit_xor(T a, T b) noexcept
constexpr T enum_bit_xor(T a, T b) noexcept
{ {
static_assert(std::is_enum<T>::value, "must be enum"); static_assert(std::is_enum<T>::value, "must be enum");
using U = typename std::underlying_type<T>::type; using U = typename std::underlying_type<T>::type;
return static_cast<T>(static_cast<U>(a) ^ static_cast<U>(b)); return static_cast<T>(static_cast<U>(a) ^ static_cast<U>(b));
} }
template<class T> template<class T> constexpr T enum_bit_not(T a) noexcept
constexpr T enum_bit_not(T a) noexcept
{ {
static_assert(std::is_enum<T>::value, "must be enum"); static_assert(std::is_enum<T>::value, "must be enum");
using U = typename std::underlying_type<T>::type; using U = typename std::underlying_type<T>::type;
@ -947,8 +938,7 @@ class const_buffer
#endif #endif
} }
constexpr const_buffer(const mutable_buffer &mb) noexcept : constexpr const_buffer(const mutable_buffer &mb) noexcept :
_data(mb.data()), _data(mb.data()), _size(mb.size())
_size(mb.size())
{ {
} }
@ -980,40 +970,37 @@ inline const_buffer operator+(size_t n, const const_buffer &cb) noexcept
// buffer creation // buffer creation
constexpr mutable_buffer buffer(void* p, size_t n) noexcept constexpr mutable_buffer buffer(void *p, size_t n) noexcept
{ {
return mutable_buffer(p, n); return mutable_buffer(p, n);
} }
constexpr const_buffer buffer(const void* p, size_t n) noexcept constexpr const_buffer buffer(const void *p, size_t n) noexcept
{ {
return const_buffer(p, n); return const_buffer(p, n);
} }
constexpr mutable_buffer buffer(const mutable_buffer& mb) noexcept constexpr mutable_buffer buffer(const mutable_buffer &mb) noexcept
{ {
return mb; return mb;
} }
inline mutable_buffer buffer(const mutable_buffer& mb, size_t n) noexcept inline mutable_buffer buffer(const mutable_buffer &mb, size_t n) noexcept
{ {
return mutable_buffer(mb.data(), (std::min)(mb.size(), n)); return mutable_buffer(mb.data(), (std::min)(mb.size(), n));
} }
constexpr const_buffer buffer(const const_buffer& cb) noexcept constexpr const_buffer buffer(const const_buffer &cb) noexcept
{ {
return cb; return cb;
} }
inline const_buffer buffer(const const_buffer& cb, size_t n) noexcept inline const_buffer buffer(const const_buffer &cb, size_t n) noexcept
{ {
return const_buffer(cb.data(), (std::min)(cb.size(), n)); return const_buffer(cb.data(), (std::min)(cb.size(), n));
} }
namespace detail namespace detail
{ {
template<class T> struct is_buffer
template<class T>
struct is_buffer
{ {
static constexpr bool value = static constexpr bool value =
std::is_same<T, const_buffer>::value || std::is_same<T, const_buffer>::value || std::is_same<T, mutable_buffer>::value;
std::is_same<T, mutable_buffer>::value;
}; };
template<class T> struct is_pod_like template<class T> struct is_pod_like
@ -1181,38 +1168,36 @@ constexpr const_buffer str_buffer(const Char (&data)[N]) noexcept
#ifdef ZMQ_CPP14 #ifdef ZMQ_CPP14
assert(data[N - 1] == Char{0}); assert(data[N - 1] == Char{0});
#endif #endif
return const_buffer(static_cast<const Char*>(data), return const_buffer(static_cast<const Char *>(data), (N - 1) * sizeof(Char));
(N - 1) * sizeof(Char));
} }
namespace literals namespace literals
{ {
constexpr const_buffer operator"" _zbuf(const char* str, size_t len) noexcept constexpr const_buffer operator"" _zbuf(const char *str, size_t len) noexcept
{ {
return const_buffer(str, len * sizeof(char)); return const_buffer(str, len * sizeof(char));
} }
constexpr const_buffer operator"" _zbuf(const wchar_t* str, size_t len) noexcept constexpr const_buffer operator"" _zbuf(const wchar_t *str, size_t len) noexcept
{ {
return const_buffer(str, len * sizeof(wchar_t)); return const_buffer(str, len * sizeof(wchar_t));
} }
constexpr const_buffer operator"" _zbuf(const char16_t* str, size_t len) noexcept constexpr const_buffer operator"" _zbuf(const char16_t *str, size_t len) noexcept
{ {
return const_buffer(str, len * sizeof(char16_t)); return const_buffer(str, len * sizeof(char16_t));
} }
constexpr const_buffer operator"" _zbuf(const char32_t* str, size_t len) noexcept constexpr const_buffer operator"" _zbuf(const char32_t *str, size_t len) noexcept
{ {
return const_buffer(str, len * sizeof(char32_t)); return const_buffer(str, len * sizeof(char32_t));
} }
} }
#endif // ZMQ_CPP11 #endif // ZMQ_CPP11
namespace detail namespace detail
{ {
class socket_base class socket_base
{ {
public: public:
socket_base() ZMQ_NOTHROW : _handle(ZMQ_NULLPTR) {} socket_base() ZMQ_NOTHROW : _handle(ZMQ_NULLPTR) {}
ZMQ_EXPLICIT socket_base(void *handle) ZMQ_NOTHROW : _handle(handle) {} ZMQ_EXPLICIT socket_base(void *handle) ZMQ_NOTHROW : _handle(handle) {}
@ -1310,7 +1295,8 @@ public:
template<typename T> template<typename T>
#ifdef ZMQ_CPP11 #ifdef ZMQ_CPP11
ZMQ_DEPRECATED("from 4.4.1, use send taking message_t or buffer (for contiguous ranges), and send_flags") ZMQ_DEPRECATED("from 4.4.1, use send taking message_t or buffer (for contiguous "
"ranges), and send_flags")
#endif #endif
bool send(T first, T last, int flags_ = 0) bool send(T first, T last, int flags_ = 0)
{ {
@ -1330,11 +1316,11 @@ public:
bool send(message_t &&msg_, bool send(message_t &&msg_,
int flags_ = 0) // default until removed int flags_ = 0) // default until removed
{ {
#ifdef ZMQ_CPP11 #ifdef ZMQ_CPP11
return send(msg_, static_cast<send_flags>(flags_)).has_value(); return send(msg_, static_cast<send_flags>(flags_)).has_value();
#else #else
return send(msg_, flags_); return send(msg_, flags_);
#endif #endif
} }
#endif #endif
@ -1380,7 +1366,8 @@ public:
} }
#ifdef ZMQ_CPP11 #ifdef ZMQ_CPP11
ZMQ_DEPRECATED("from 4.3.1, use recv taking a reference to message_t and recv_flags") ZMQ_DEPRECATED(
"from 4.3.1, use recv taking a reference to message_t and recv_flags")
#endif #endif
bool recv(message_t *msg_, int flags_ = 0) bool recv(message_t *msg_, int flags_ = 0)
{ {
@ -1395,13 +1382,14 @@ public:
#ifdef ZMQ_CPP11 #ifdef ZMQ_CPP11
ZMQ_NODISCARD ZMQ_NODISCARD
recv_buffer_result_t recv(mutable_buffer buf, recv_buffer_result_t recv(mutable_buffer buf,
recv_flags flags = recv_flags::none) recv_flags flags = recv_flags::none)
{ {
const int nbytes = const int nbytes =
zmq_recv(_handle, buf.data(), buf.size(), static_cast<int>(flags)); zmq_recv(_handle, buf.data(), buf.size(), static_cast<int>(flags));
if (nbytes >= 0) { if (nbytes >= 0) {
return recv_buffer_size{(std::min)(static_cast<size_t>(nbytes), buf.size()), return recv_buffer_size{
static_cast<size_t>(nbytes)}; (std::min)(static_cast<size_t>(nbytes), buf.size()),
static_cast<size_t>(nbytes)};
} }
if (zmq_errno() == EAGAIN) if (zmq_errno() == EAGAIN)
return {}; return {};
@ -1411,7 +1399,8 @@ public:
ZMQ_NODISCARD ZMQ_NODISCARD
recv_result_t recv(message_t &msg, recv_flags flags = recv_flags::none) recv_result_t recv(message_t &msg, recv_flags flags = recv_flags::none)
{ {
const int nbytes = zmq_msg_recv(msg.handle(), _handle, static_cast<int>(flags)); const int nbytes =
zmq_msg_recv(msg.handle(), _handle, static_cast<int>(flags));
if (nbytes >= 0) { if (nbytes >= 0) {
assert(msg.size() == static_cast<size_t>(nbytes)); assert(msg.size() == static_cast<size_t>(nbytes));
return static_cast<size_t>(nbytes); return static_cast<size_t>(nbytes);
@ -1423,14 +1412,14 @@ public:
#endif #endif
#if defined(ZMQ_BUILD_DRAFT_API) && ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 0) #if defined(ZMQ_BUILD_DRAFT_API) && ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 0)
void join(const char* group) void join(const char *group)
{ {
int rc = zmq_join(_handle, group); int rc = zmq_join(_handle, group);
if (rc != 0) if (rc != 0)
throw error_t(); throw error_t();
} }
void leave(const char* group) void leave(const char *group)
{ {
int rc = zmq_leave(_handle, group); int rc = zmq_leave(_handle, group);
if (rc != 0) if (rc != 0)
@ -1446,7 +1435,7 @@ public:
// operator void* is removed from socket_t // operator void* is removed from socket_t
ZMQ_EXPLICIT operator bool() ZMQ_NOTHROW { return _handle != ZMQ_NULLPTR; } ZMQ_EXPLICIT operator bool() ZMQ_NOTHROW { return _handle != ZMQ_NULLPTR; }
protected: protected:
void *_handle; void *_handle;
}; };
} // namespace detail } // namespace detail
@ -1479,11 +1468,14 @@ enum class socket_type : int
struct from_handle_t struct from_handle_t
{ {
struct _private {}; // disabling use other than with from_handle struct _private
{
}; // disabling use other than with from_handle
ZMQ_CONSTEXPR_FN ZMQ_EXPLICIT from_handle_t(_private /*p*/) ZMQ_NOTHROW {} ZMQ_CONSTEXPR_FN ZMQ_EXPLICIT from_handle_t(_private /*p*/) ZMQ_NOTHROW {}
}; };
ZMQ_CONSTEXPR_VAR from_handle_t from_handle = from_handle_t(from_handle_t::_private()); ZMQ_CONSTEXPR_VAR from_handle_t from_handle =
from_handle_t(from_handle_t::_private());
// A non-owning nullable reference to a socket. // A non-owning nullable reference to a socket.
// The reference is invalidated on socket close or destruction. // The reference is invalidated on socket close or destruction.
@ -1495,7 +1487,9 @@ class socket_ref : public detail::socket_base
socket_ref(std::nullptr_t) ZMQ_NOTHROW : detail::socket_base() {} socket_ref(std::nullptr_t) ZMQ_NOTHROW : detail::socket_base() {}
#endif #endif
socket_ref(from_handle_t /*fh*/, void *handle) ZMQ_NOTHROW socket_ref(from_handle_t /*fh*/, void *handle) ZMQ_NOTHROW
: detail::socket_base(handle) {} : detail::socket_base(handle)
{
}
}; };
#ifdef ZMQ_CPP11 #ifdef ZMQ_CPP11
@ -1519,7 +1513,7 @@ inline bool operator!=(std::nullptr_t /*p*/, socket_ref sr) ZMQ_NOTHROW
inline bool operator==(socket_ref a, socket_ref b) ZMQ_NOTHROW inline bool operator==(socket_ref a, socket_ref b) ZMQ_NOTHROW
{ {
return std::equal_to<void*>()(a.handle(), b.handle()); return std::equal_to<void *>()(a.handle(), b.handle());
} }
inline bool operator!=(socket_ref a, socket_ref b) ZMQ_NOTHROW inline bool operator!=(socket_ref a, socket_ref b) ZMQ_NOTHROW
{ {
@ -1527,7 +1521,7 @@ inline bool operator!=(socket_ref a, socket_ref b) ZMQ_NOTHROW
} }
inline bool operator<(socket_ref a, socket_ref b) ZMQ_NOTHROW inline bool operator<(socket_ref a, socket_ref b) ZMQ_NOTHROW
{ {
return std::less<void*>()(a.handle(), b.handle()); return std::less<void *>()(a.handle(), b.handle());
} }
inline bool operator>(socket_ref a, socket_ref b) ZMQ_NOTHROW inline bool operator>(socket_ref a, socket_ref b) ZMQ_NOTHROW
{ {
@ -1547,12 +1541,11 @@ inline bool operator>=(socket_ref a, socket_ref b) ZMQ_NOTHROW
#ifdef ZMQ_CPP11 #ifdef ZMQ_CPP11
namespace std namespace std
{ {
template<> template<> struct hash<zmq::socket_ref>
struct hash<zmq::socket_ref>
{ {
size_t operator()(zmq::socket_ref sr) const ZMQ_NOTHROW size_t operator()(zmq::socket_ref sr) const ZMQ_NOTHROW
{ {
return hash<void*>()(sr.handle()); return hash<void *>()(sr.handle());
} }
}; };
} // namespace std } // namespace std
@ -1560,35 +1553,31 @@ struct hash<zmq::socket_ref>
namespace zmq namespace zmq
{ {
class socket_t : public detail::socket_base class socket_t : public detail::socket_base
{ {
friend class monitor_t; friend class monitor_t;
public: public:
socket_t() ZMQ_NOTHROW socket_t() ZMQ_NOTHROW : detail::socket_base(ZMQ_NULLPTR), ctxptr(ZMQ_NULLPTR) {}
: detail::socket_base(ZMQ_NULLPTR)
, ctxptr(ZMQ_NULLPTR)
{
}
socket_t(context_t &context_, int type_) socket_t(context_t &context_, int type_) :
: detail::socket_base(zmq_socket(static_cast<void*>(context_), type_)) detail::socket_base(zmq_socket(static_cast<void *>(context_), type_)),
, ctxptr(static_cast<void*>(context_)) ctxptr(static_cast<void *>(context_))
{ {
if (_handle == ZMQ_NULLPTR) if (_handle == ZMQ_NULLPTR)
throw error_t(); throw error_t();
} }
#ifdef ZMQ_CPP11 #ifdef ZMQ_CPP11
socket_t(context_t &context_, socket_type type_) socket_t(context_t &context_, socket_type type_) :
: socket_t(context_, static_cast<int>(type_)) socket_t(context_, static_cast<int>(type_))
{ {
} }
#endif #endif
#ifdef ZMQ_HAS_RVALUE_REFS #ifdef ZMQ_HAS_RVALUE_REFS
socket_t(socket_t &&rhs) ZMQ_NOTHROW : detail::socket_base(rhs._handle), ctxptr(rhs.ctxptr) socket_t(socket_t &&rhs) ZMQ_NOTHROW : detail::socket_base(rhs._handle),
ctxptr(rhs.ctxptr)
{ {
rhs._handle = ZMQ_NULLPTR; rhs._handle = ZMQ_NULLPTR;
rhs.ctxptr = ZMQ_NULLPTR; rhs.ctxptr = ZMQ_NULLPTR;
@ -1623,10 +1612,7 @@ class socket_t : public detail::socket_base
std::swap(ctxptr, other.ctxptr); std::swap(ctxptr, other.ctxptr);
} }
operator socket_ref() ZMQ_NOTHROW operator socket_ref() ZMQ_NOTHROW { return socket_ref(from_handle, _handle); }
{
return socket_ref(from_handle, _handle);
}
private: private:
void *ctxptr; void *ctxptr;
@ -1635,16 +1621,16 @@ class socket_t : public detail::socket_base
void operator=(const socket_t &) ZMQ_DELETED_FUNCTION; void operator=(const socket_t &) ZMQ_DELETED_FUNCTION;
// used by monitor_t // used by monitor_t
socket_t(void *context_, int type_) socket_t(void *context_, int type_) :
: detail::socket_base(zmq_socket(context_, type_)) detail::socket_base(zmq_socket(context_, type_)), ctxptr(context_)
, ctxptr(context_)
{ {
if (_handle == ZMQ_NULLPTR) if (_handle == ZMQ_NULLPTR)
throw error_t(); throw error_t();
} }
}; };
inline void swap(socket_t &a, socket_t &b) ZMQ_NOTHROW { inline void swap(socket_t &a, socket_t &b) ZMQ_NOTHROW
{
a.swap(b); a.swap(b);
} }
@ -1691,10 +1677,7 @@ class monitor_t
public: public:
monitor_t() : _socket(), _monitor_socket() {} monitor_t() : _socket(), _monitor_socket() {}
virtual ~monitor_t() virtual ~monitor_t() { close(); }
{
close();
}
#ifdef ZMQ_HAS_RVALUE_REFS #ifdef ZMQ_HAS_RVALUE_REFS
monitor_t(monitor_t &&rhs) ZMQ_NOTHROW : _socket(), _monitor_socket() monitor_t(monitor_t &&rhs) ZMQ_NOTHROW : _socket(), _monitor_socket()
@ -2024,8 +2007,7 @@ constexpr event_flags operator~(event_flags a) noexcept
struct no_user_data; struct no_user_data;
// layout compatible with zmq_poller_event_t // layout compatible with zmq_poller_event_t
template<class T = no_user_data> template<class T = no_user_data> struct poller_event
struct poller_event
{ {
socket_ref socket; socket_ref socket;
#ifdef _WIN32 #ifdef _WIN32
@ -2114,8 +2096,8 @@ template<typename T = no_user_data> class poller_t
void add_impl(zmq::socket_ref socket, event_flags events, T *user_data) void add_impl(zmq::socket_ref socket, event_flags events, T *user_data)
{ {
if (0 if (0
!= zmq_poller_add(poller_ptr.get(), socket.handle(), != zmq_poller_add(poller_ptr.get(), socket.handle(), user_data,
user_data, static_cast<short>(events))) { static_cast<short>(events))) {
throw error_t(); throw error_t();
} }
} }

86
zmq_addon.hpp
View File

@ -37,26 +37,23 @@
namespace zmq namespace zmq
{ {
#ifdef ZMQ_CPP11 #ifdef ZMQ_CPP11
namespace detail namespace detail
{ {
template<bool CheckN, class OutputIt> template<bool CheckN, class OutputIt>
recv_result_t recv_multipart_n(socket_ref s, OutputIt out, size_t n, recv_result_t
recv_flags flags) recv_multipart_n(socket_ref s, OutputIt out, size_t n, recv_flags flags)
{ {
size_t msg_count = 0; size_t msg_count = 0;
message_t msg; message_t msg;
while (true) while (true) {
{ if (CheckN) {
if (CheckN)
{
if (msg_count >= n) if (msg_count >= n)
throw std::runtime_error("Too many message parts in recv_multipart_n"); throw std::runtime_error(
"Too many message parts in recv_multipart_n");
} }
if (!s.recv(msg, flags)) if (!s.recv(msg, flags)) {
{
// zmq ensures atomic delivery of messages // zmq ensures atomic delivery of messages
assert(msg_count == 0); assert(msg_count == 0);
return {}; return {};
@ -84,9 +81,9 @@ recv_result_t recv_multipart_n(socket_ref s, OutputIt out, size_t n,
message parts. It is adviced to close this socket in that event. message parts. It is adviced to close this socket in that event.
*/ */
template<class OutputIt> template<class OutputIt>
ZMQ_NODISCARD ZMQ_NODISCARD recv_result_t recv_multipart(socket_ref s,
recv_result_t recv_multipart(socket_ref s, OutputIt out, OutputIt out,
recv_flags flags = recv_flags::none) recv_flags flags = recv_flags::none)
{ {
return detail::recv_multipart_n<false>(s, std::move(out), 0, flags); return detail::recv_multipart_n<false>(s, std::move(out), 0, flags);
} }
@ -106,9 +103,10 @@ recv_result_t recv_multipart(socket_ref s, OutputIt out,
message parts. It is adviced to close this socket in that event. message parts. It is adviced to close this socket in that event.
*/ */
template<class OutputIt> template<class OutputIt>
ZMQ_NODISCARD ZMQ_NODISCARD recv_result_t recv_multipart_n(socket_ref s,
recv_result_t recv_multipart_n(socket_ref s, OutputIt out, size_t n, OutputIt out,
recv_flags flags = recv_flags::none) size_t n,
recv_flags flags = recv_flags::none)
{ {
return detail::recv_multipart_n<true>(s, std::move(out), n, flags); return detail::recv_multipart_n<true>(s, std::move(out), n, flags);
} }
@ -126,25 +124,23 @@ recv_result_t recv_multipart_n(socket_ref s, OutputIt out, size_t n,
may have been only partially sent. It is adviced to close this socket in that event. may have been only partially sent. It is adviced to close this socket in that event.
*/ */
template<class Range, template<class Range,
typename = typename std::enable_if< typename = typename std::enable_if<
detail::is_range<Range>::value detail::is_range<Range>::value
&& (std::is_same<detail::range_value_t<Range>, message_t>::value && (std::is_same<detail::range_value_t<Range>, message_t>::value
|| detail::is_buffer<detail::range_value_t<Range>>::value) || detail::is_buffer<detail::range_value_t<Range>>::value)>::type>
>::type> send_result_t
send_result_t send_multipart(socket_ref s, Range&& msgs, send_multipart(socket_ref s, Range &&msgs, send_flags flags = send_flags::none)
send_flags flags = send_flags::none)
{ {
using std::begin; using std::begin;
using std::end; using std::end;
auto it = begin(msgs); auto it = begin(msgs);
const auto end_it = end(msgs); const auto end_it = end(msgs);
size_t msg_count = 0; size_t msg_count = 0;
while (it != end_it) while (it != end_it) {
{
const auto next = std::next(it); const auto next = std::next(it);
const auto msg_flags = flags | (next == end_it ? send_flags::none : send_flags::sndmore); const auto msg_flags =
if (!s.send(*it, msg_flags)) flags | (next == end_it ? send_flags::none : send_flags::sndmore);
{ if (!s.send(*it, msg_flags)) {
// zmq ensures atomic delivery of messages // zmq ensures atomic delivery of messages
assert(it == begin(msgs)); assert(it == begin(msgs));
return {}; return {};
@ -250,13 +246,13 @@ class multipart_t
bool more = true; bool more = true;
while (more) { while (more) {
message_t message; message_t message;
#ifdef ZMQ_CPP11 #ifdef ZMQ_CPP11
if (!socket.recv(message, static_cast<recv_flags>(flags))) if (!socket.recv(message, static_cast<recv_flags>(flags)))
return false; return false;
#else #else
if (!socket.recv(&message, flags)) if (!socket.recv(&message, flags))
return false; return false;
#endif #endif
more = message.more(); more = message.more();
add(std::move(message)); add(std::move(message));
} }
@ -271,14 +267,14 @@ class multipart_t
while (more) { while (more) {
message_t message = pop(); message_t message = pop();
more = size() > 0; more = size() > 0;
#ifdef ZMQ_CPP11 #ifdef ZMQ_CPP11
if (!socket.send(message, if (!socket.send(message, static_cast<send_flags>(
static_cast<send_flags>((more ? ZMQ_SNDMORE : 0) | flags))) (more ? ZMQ_SNDMORE : 0) | flags)))
return false; return false;
#else #else
if (!socket.send(message, (more ? ZMQ_SNDMORE : 0) | flags)) if (!socket.send(message, (more ? ZMQ_SNDMORE : 0) | flags))
return false; return false;
#endif #endif
} }
clear(); clear();
return true; return true;
@ -382,16 +378,10 @@ class multipart_t
} }
// get message part from front // get message part from front
const message_t &front() const message_t &front() { return m_parts.front(); }
{
return m_parts.front();
}
// get message part from back // get message part from back
const message_t &back() const message_t &back() { return m_parts.back(); }
{
return m_parts.back();
}
// Get pointer to a specific message part // Get pointer to a specific message part
const message_t *peek(size_t index) const { return &m_parts[index]; } const message_t *peek(size_t index) const { return &m_parts[index]; }
@ -508,9 +498,8 @@ class active_poller_t
{ {
auto it = decltype(handlers)::iterator{}; auto it = decltype(handlers)::iterator{};
auto inserted = bool{}; auto inserted = bool{};
std::tie(it, inserted) = std::tie(it, inserted) = handlers.emplace(
handlers.emplace(socket, socket, std::make_shared<handler_type>(std::move(handler)));
std::make_shared<handler_type>(std::move(handler)));
try { try {
base_poller.add(socket, events, base_poller.add(socket, events,
inserted && *(it->second) ? it->second.get() : nullptr); inserted && *(it->second) ? it->second.get() : nullptr);
@ -549,7 +538,8 @@ class active_poller_t
need_rebuild = false; need_rebuild = false;
} }
const auto count = base_poller.wait_all(poller_events, timeout); const auto count = base_poller.wait_all(poller_events, timeout);
std::for_each(poller_events.begin(), poller_events.begin() + static_cast<ptrdiff_t>(count), std::for_each(poller_events.begin(),
poller_events.begin() + static_cast<ptrdiff_t>(count),
[](decltype(base_poller)::event_type &event) { [](decltype(base_poller)::event_type &event) {
if (event.user_data != nullptr) if (event.user_data != nullptr)
(*event.user_data)(event.events); (*event.user_data)(event.events);