generic-library/cppzmq
1
0
Fork 0
mirror of https://github.com/zeromq/cppzmq.git synced 2025-06-07 23:15:03 +02:00
Code Issues Projects Releases Wiki Activity

Reformat all files with clang-format

Browse Source
This commit is contained in:
Simon Giesecke 2020-01-26 10:09:20 +01:00
parent 47969cfdcf
commit b6c79eb0c8
13 changed files with 358 additions and 338 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

81
tests/active_poller.cpp
View File

@ -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,7 +234,9 @@ 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(
active_poller.add(a, zmq::event_flags::pollin, zmq::active_poller_t::
handler_type{}),
const zmq::error_t&); const zmq::error_t&);
} }
@ -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,7 +423,8 @@ 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](
zmq::event_flags events) {
CHECK(events == zmq::event_flags::pollin); CHECK(events == zmq::event_flags::pollin);
active_poller.remove(setup_list[ITER_NO - i - 1].server); active_poller.remove(setup_list[ITER_NO - i - 1].server);
CHECK((ITER_NO - i - 1) == active_poller.size()); CHECK((ITER_NO - i - 1) == active_poller.size());

3
tests/message.cpp
View File

@ -36,7 +36,8 @@ TEST_CASE("message swap", "[message]")
} }
#endif #endif
namespace { namespace
{
const char *const data = "Hi"; const char *const data = "Hi";
} }

29
tests/monitor.cpp
View File

@ -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;
@ -102,9 +97,10 @@ 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)) {
} }
}); });

29
tests/poller.cpp
View File

@ -9,7 +9,8 @@
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>), "");
@ -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]")
@ -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}));
} }

59
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,8 +83,7 @@ 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!"));
@ -96,8 +92,7 @@ TEST_CASE("recv_multipart_n test", "[recv_multipart]")
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!"));
@ -106,8 +101,7 @@ TEST_CASE("recv_multipart_n test", "[recv_multipart]")
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 &);
} }
} }

37
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,8 +76,7 @@ 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");
@ -88,8 +84,7 @@ TEST_CASE("send_multipart test", "[send_multipart]")
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);
@ -111,14 +106,16 @@ TEST_CASE("send_multipart test", "[send_multipart]")
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

18
tests/socket.cpp
View File

@ -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;

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;

154
zmq.hpp
View File

@ -27,15 +27,19 @@
#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) \
|| (defined(_MSC_VER) && _MSC_VER >= 1900)
#define ZMQ_CPP11 #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) \
&& _HAS_CXX17 \
== 1) // _HAS_CXX14 might not be defined when using C++17 on MSVC
#define ZMQ_CPP14 #define ZMQ_CPP14
#endif #endif
#if (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) #if (defined(__cplusplus) && __cplusplus >= 201703L) \
|| (defined(_HAS_CXX17) && _HAS_CXX17 == 1)
#define ZMQ_CPP17 #define ZMQ_CPP17
#endif #endif
@ -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
{ {
@ -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);
} }
@ -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())
{ {
} }
@ -1007,13 +997,10 @@ inline const_buffer buffer(const const_buffer& cb, size_t n) noexcept
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,8 +1168,7 @@ 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
@ -1209,7 +1195,6 @@ namespace literals
namespace detail namespace detail
{ {
class socket_base class socket_base
{ {
public: public:
@ -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)
{ {
@ -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)
{ {
@ -1400,7 +1387,8 @@ public:
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{
(std::min)(static_cast<size_t>(nbytes), buf.size()),
static_cast<size_t>(nbytes)}; static_cast<size_t>(nbytes)};
} }
if (zmq_errno() == EAGAIN) if (zmq_errno() == EAGAIN)
@ -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);
@ -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
@ -1547,8 +1541,7 @@ 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
{ {
@ -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();
} }
} }

64
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,8 +81,8 @@ 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,8 +103,9 @@ 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,
size_t n,
recv_flags flags = recv_flags::none) 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);
@ -129,22 +127,20 @@ 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 {};
@ -272,8 +268,8 @@ class multipart_t
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))
@ -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);