diff --git a/demo/main.cpp b/demo/main.cpp index 68c4813..b66baa3 100644 --- a/demo/main.cpp +++ b/demo/main.cpp @@ -1,8 +1,7 @@ #include -int main(int argc, char** argv) +int main (int argc, char **argv) { zmq::context_t context; - return 0; } diff --git a/tests/active_poller.cpp b/tests/active_poller.cpp index 1a01ebb..ef7bf67 100644 --- a/tests/active_poller.cpp +++ b/tests/active_poller.cpp @@ -7,83 +7,85 @@ #include #include -TEST(active_poller, create_destroy) +TEST (active_poller, create_destroy) { zmq::active_poller_t active_poller; - ASSERT_TRUE(active_poller.empty ()); + ASSERT_TRUE (active_poller.empty ()); } -static_assert(!std::is_copy_constructible::value, "active_active_poller_t should not be copy-constructible"); -static_assert(!std::is_copy_assignable::value, "active_active_poller_t should not be copy-assignable"); +static_assert (!std::is_copy_constructible::value, + "active_active_poller_t should not be copy-constructible"); +static_assert (!std::is_copy_assignable::value, + "active_active_poller_t should not be copy-assignable"); -TEST(active_poller, move_construct_empty) +TEST (active_poller, move_construct_empty) { zmq::active_poller_t a; - ASSERT_TRUE(a.empty ()); + ASSERT_TRUE (a.empty ()); zmq::active_poller_t b = std::move (a); - ASSERT_TRUE(b.empty ()); - ASSERT_EQ(0u, a.size ()); - ASSERT_EQ(0u, b.size ()); + ASSERT_TRUE (b.empty ()); + ASSERT_EQ (0u, a.size ()); + ASSERT_EQ (0u, b.size ()); } -TEST(active_poller, move_assign_empty) +TEST (active_poller, move_assign_empty) { zmq::active_poller_t a; - ASSERT_TRUE(a.empty()); + ASSERT_TRUE (a.empty ()); zmq::active_poller_t b; - ASSERT_TRUE(b.empty()); - b = std::move(a); - ASSERT_EQ(0u, a.size ()); - ASSERT_EQ(0u, b.size ()); - ASSERT_TRUE(a.empty()); - ASSERT_TRUE(b.empty()); + ASSERT_TRUE (b.empty ()); + b = std::move (a); + ASSERT_EQ (0u, a.size ()); + ASSERT_EQ (0u, b.size ()); + ASSERT_TRUE (a.empty ()); + ASSERT_TRUE (b.empty ()); } -TEST(active_poller, move_construct_non_empty) +TEST (active_poller, move_construct_non_empty) { zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::router}; zmq::active_poller_t a; - a.add(socket, ZMQ_POLLIN, [](short) {}); - ASSERT_FALSE(a.empty ()); - ASSERT_EQ(1u, a.size ()); + a.add (socket, ZMQ_POLLIN, [](short) {}); + ASSERT_FALSE (a.empty ()); + ASSERT_EQ (1u, a.size ()); zmq::active_poller_t b = std::move (a); - ASSERT_TRUE(a.empty ()); - ASSERT_EQ(0u, a.size ()); - ASSERT_FALSE(b.empty ()); - ASSERT_EQ(1u, b.size ()); + ASSERT_TRUE (a.empty ()); + ASSERT_EQ (0u, a.size ()); + ASSERT_FALSE (b.empty ()); + ASSERT_EQ (1u, b.size ()); } -TEST(active_poller, move_assign_non_empty) +TEST (active_poller, move_assign_non_empty) { zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::router}; zmq::active_poller_t a; - a.add(socket, ZMQ_POLLIN, [](short) {}); - ASSERT_FALSE(a.empty()); - ASSERT_EQ(1u, a.size ()); + a.add (socket, ZMQ_POLLIN, [](short) {}); + ASSERT_FALSE (a.empty ()); + ASSERT_EQ (1u, a.size ()); zmq::active_poller_t b; - b = std::move(a); - ASSERT_TRUE(a.empty ()); - ASSERT_EQ(0u, a.size ()); - ASSERT_FALSE(b.empty ()); - ASSERT_EQ(1u, b.size ()); + b = std::move (a); + ASSERT_TRUE (a.empty ()); + ASSERT_EQ (0u, a.size ()); + ASSERT_FALSE (b.empty ()); + ASSERT_EQ (1u, b.size ()); } -TEST(active_poller, add_handler) +TEST (active_poller, add_handler) { zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::router}; zmq::active_poller_t active_poller; zmq::active_poller_t::handler_t handler; - ASSERT_NO_THROW(active_poller.add(socket, ZMQ_POLLIN, handler)); + ASSERT_NO_THROW (active_poller.add (socket, ZMQ_POLLIN, handler)); } -TEST(active_poller, add_handler_invalid_events_type) +TEST (active_poller, add_handler_invalid_events_type) { - /// \todo is it good that this is accepted? should probably already be + /// \todo is it good that this is accepted? should probably already be /// checked by zmq_poller_add/modify in libzmq: /// https://github.com/zeromq/libzmq/issues/3088 zmq::context_t context; @@ -91,86 +93,88 @@ TEST(active_poller, add_handler_invalid_events_type) zmq::active_poller_t active_poller; zmq::active_poller_t::handler_t handler; short invalid_events_type = 2 << 10; - ASSERT_NO_THROW(active_poller.add(socket, invalid_events_type, handler)); - ASSERT_FALSE(active_poller.empty ()); - ASSERT_EQ(1u, active_poller.size ()); + ASSERT_NO_THROW (active_poller.add (socket, invalid_events_type, handler)); + ASSERT_FALSE (active_poller.empty ()); + ASSERT_EQ (1u, active_poller.size ()); } -TEST(active_poller, add_handler_twice_throws) +TEST (active_poller, add_handler_twice_throws) { zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::router}; zmq::active_poller_t active_poller; zmq::active_poller_t::handler_t handler; - active_poller.add(socket, ZMQ_POLLIN, handler); + active_poller.add (socket, ZMQ_POLLIN, handler); /// \todo the actual error code should be checked - ASSERT_THROW(active_poller.add(socket, ZMQ_POLLIN, handler), zmq::error_t); + ASSERT_THROW (active_poller.add (socket, ZMQ_POLLIN, handler), + zmq::error_t); } -TEST(active_poller, wait_with_no_handlers_throws) +TEST (active_poller, wait_with_no_handlers_throws) { zmq::active_poller_t active_poller; /// \todo the actual error code should be checked - ASSERT_THROW(active_poller.wait(std::chrono::milliseconds{10}), zmq::error_t); + ASSERT_THROW (active_poller.wait (std::chrono::milliseconds{10}), + zmq::error_t); } -TEST(active_poller, remove_unregistered_throws) +TEST (active_poller, remove_unregistered_throws) { zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::router}; zmq::active_poller_t active_poller; /// \todo the actual error code should be checked - ASSERT_THROW(active_poller.remove(socket), zmq::error_t); + ASSERT_THROW (active_poller.remove (socket), zmq::error_t); } -TEST(active_poller, remove_registered_empty) +TEST (active_poller, remove_registered_empty) { zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::router}; zmq::active_poller_t active_poller; - active_poller.add(socket, ZMQ_POLLIN, zmq::active_poller_t::handler_t{}); - ASSERT_NO_THROW(active_poller.remove(socket)); + active_poller.add (socket, ZMQ_POLLIN, zmq::active_poller_t::handler_t{}); + ASSERT_NO_THROW (active_poller.remove (socket)); } -TEST(active_poller, remove_registered_non_empty) +TEST (active_poller, remove_registered_non_empty) { zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::router}; zmq::active_poller_t active_poller; - active_poller.add(socket, ZMQ_POLLIN, [](short) {}); - ASSERT_NO_THROW(active_poller.remove(socket)); + active_poller.add (socket, ZMQ_POLLIN, [](short) {}); + ASSERT_NO_THROW (active_poller.remove (socket)); } -namespace { +namespace +{ struct server_client_setup : common_server_client_setup { - zmq::active_poller_t::handler_t handler = [&](short e) { - events = e; - }; + zmq::active_poller_t::handler_t handler = [&](short e) { events = e; }; short events = 0; }; } -TEST(active_poller, poll_basic) +TEST (active_poller, poll_basic) { server_client_setup s; - ASSERT_NO_THROW(s.client.send("Hi")); + ASSERT_NO_THROW (s.client.send ("Hi")); zmq::active_poller_t active_poller; bool message_received = false; - zmq::active_poller_t::handler_t handler = [&message_received](short events) { - ASSERT_TRUE(0 != (events & ZMQ_POLLIN)); - message_received = true; - }; - ASSERT_NO_THROW(active_poller.add(s.server, ZMQ_POLLIN, handler)); - ASSERT_EQ(1, active_poller.wait(std::chrono::milliseconds{-1})); - ASSERT_TRUE(message_received); + zmq::active_poller_t::handler_t handler = + [&message_received](short events) { + ASSERT_TRUE (0 != (events & ZMQ_POLLIN)); + message_received = true; + }; + ASSERT_NO_THROW (active_poller.add (s.server, ZMQ_POLLIN, handler)); + ASSERT_EQ (1, active_poller.wait (std::chrono::milliseconds{-1})); + ASSERT_TRUE (message_received); } /// \todo this contains multiple test cases that should be split up -TEST(active_poller, client_server) +TEST (active_poller, client_server) { const std::string send_msg = "Hi"; @@ -183,47 +187,49 @@ TEST(active_poller, client_server) zmq::active_poller_t::handler_t handler = [&](short e) { if (0 != (e & ZMQ_POLLIN)) { zmq::message_t zmq_msg; - ASSERT_NO_THROW(s.server.recv(&zmq_msg)); // get message - std::string recv_msg(zmq_msg.data(), - zmq_msg.size()); - ASSERT_EQ(send_msg, recv_msg); + ASSERT_NO_THROW (s.server.recv (&zmq_msg)); // get message + std::string recv_msg (zmq_msg.data (), zmq_msg.size ()); + ASSERT_EQ (send_msg, recv_msg); } else if (0 != (e & ~ZMQ_POLLOUT)) { - ASSERT_TRUE(false) << "Unexpected event type " << events; + ASSERT_TRUE (false) << "Unexpected event type " << events; } events = e; }; - ASSERT_NO_THROW(active_poller.add(s.server, ZMQ_POLLIN, handler)); + ASSERT_NO_THROW (active_poller.add (s.server, ZMQ_POLLIN, handler)); // client sends message - ASSERT_NO_THROW(s.client.send(send_msg)); + ASSERT_NO_THROW (s.client.send (send_msg)); - ASSERT_EQ(1, active_poller.wait(std::chrono::milliseconds{-1})); - ASSERT_EQ(events, ZMQ_POLLIN); + ASSERT_EQ (1, active_poller.wait (std::chrono::milliseconds{-1})); + ASSERT_EQ (events, ZMQ_POLLIN); // Re-add server socket with pollout flag - ASSERT_NO_THROW(active_poller.remove(s.server)); - ASSERT_NO_THROW(active_poller.add(s.server, ZMQ_POLLIN | ZMQ_POLLOUT, handler)); - ASSERT_EQ(1, active_poller.wait(std::chrono::milliseconds{-1})); - ASSERT_EQ(events, ZMQ_POLLOUT); + ASSERT_NO_THROW (active_poller.remove (s.server)); + ASSERT_NO_THROW ( + active_poller.add (s.server, ZMQ_POLLIN | ZMQ_POLLOUT, handler)); + ASSERT_EQ (1, active_poller.wait (std::chrono::milliseconds{-1})); + ASSERT_EQ (events, ZMQ_POLLOUT); } -TEST(active_poller, add_invalid_socket_throws) +TEST (active_poller, add_invalid_socket_throws) { zmq::context_t context; zmq::active_poller_t active_poller; - zmq::socket_t a {context, zmq::socket_type::router}; - zmq::socket_t b {std::move (a)}; - ASSERT_THROW (active_poller.add (a, ZMQ_POLLIN, zmq::active_poller_t::handler_t {}), - zmq::error_t); + zmq::socket_t a{context, zmq::socket_type::router}; + zmq::socket_t b{std::move (a)}; + ASSERT_THROW ( + active_poller.add (a, ZMQ_POLLIN, zmq::active_poller_t::handler_t{}), + zmq::error_t); } -TEST(active_poller, remove_invalid_socket_throws) +TEST (active_poller, remove_invalid_socket_throws) { 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; - ASSERT_NO_THROW (active_poller.add (socket, ZMQ_POLLIN, zmq::active_poller_t::handler_t {})); + ASSERT_NO_THROW (active_poller.add (socket, ZMQ_POLLIN, + zmq::active_poller_t::handler_t{})); ASSERT_EQ (1u, active_poller.size ()); std::vector sockets; sockets.emplace_back (std::move (socket)); @@ -231,75 +237,77 @@ TEST(active_poller, remove_invalid_socket_throws) ASSERT_EQ (1u, active_poller.size ()); } -TEST(active_poller, wait_on_added_empty_handler) +TEST (active_poller, wait_on_added_empty_handler) { server_client_setup s; ASSERT_NO_THROW (s.client.send ("Hi")); zmq::active_poller_t active_poller; zmq::active_poller_t::handler_t handler; ASSERT_NO_THROW (active_poller.add (s.server, ZMQ_POLLIN, handler)); - ASSERT_NO_THROW (active_poller.wait (std::chrono::milliseconds {-1})); + ASSERT_NO_THROW (active_poller.wait (std::chrono::milliseconds{-1})); } -TEST(active_poller, modify_empty_throws) +TEST (active_poller, modify_empty_throws) { 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; ASSERT_THROW (active_poller.modify (socket, ZMQ_POLLIN), zmq::error_t); } -TEST(active_poller, modify_invalid_socket_throws) +TEST (active_poller, modify_invalid_socket_throws) { zmq::context_t context; - zmq::socket_t a {context, zmq::socket_type::push}; - zmq::socket_t b {std::move (a)}; + zmq::socket_t a{context, zmq::socket_type::push}; + zmq::socket_t b{std::move (a)}; zmq::active_poller_t active_poller; ASSERT_THROW (active_poller.modify (a, ZMQ_POLLIN), zmq::error_t); } -TEST(active_poller, modify_not_added_throws) +TEST (active_poller, modify_not_added_throws) { zmq::context_t context; - zmq::socket_t a {context, zmq::socket_type::push}; - zmq::socket_t b {context, zmq::socket_type::push}; + zmq::socket_t a{context, zmq::socket_type::push}; + zmq::socket_t b{context, zmq::socket_type::push}; zmq::active_poller_t active_poller; - ASSERT_NO_THROW (active_poller.add (a, ZMQ_POLLIN, zmq::active_poller_t::handler_t {})); + ASSERT_NO_THROW ( + active_poller.add (a, ZMQ_POLLIN, zmq::active_poller_t::handler_t{})); ASSERT_THROW (active_poller.modify (b, ZMQ_POLLIN), zmq::error_t); } -TEST(active_poller, modify_simple) +TEST (active_poller, modify_simple) { zmq::context_t context; - zmq::socket_t a {context, zmq::socket_type::push}; + zmq::socket_t a{context, zmq::socket_type::push}; zmq::active_poller_t active_poller; - ASSERT_NO_THROW (active_poller.add (a, ZMQ_POLLIN, zmq::active_poller_t::handler_t {})); - ASSERT_NO_THROW (active_poller.modify (a, ZMQ_POLLIN|ZMQ_POLLOUT)); + ASSERT_NO_THROW ( + active_poller.add (a, ZMQ_POLLIN, zmq::active_poller_t::handler_t{})); + ASSERT_NO_THROW (active_poller.modify (a, ZMQ_POLLIN | ZMQ_POLLOUT)); } -TEST(active_poller, poll_client_server) +TEST (active_poller, poll_client_server) { // Setup server and client server_client_setup s; // Setup active_poller zmq::active_poller_t active_poller; - ASSERT_NO_THROW(active_poller.add(s.server, ZMQ_POLLIN, s.handler)); + ASSERT_NO_THROW (active_poller.add (s.server, ZMQ_POLLIN, s.handler)); // client sends message - ASSERT_NO_THROW(s.client.send("Hi")); + ASSERT_NO_THROW (s.client.send ("Hi")); // wait for message and verify events - ASSERT_NO_THROW(active_poller.wait(std::chrono::milliseconds{500})); - ASSERT_EQ(s.events, ZMQ_POLLIN); + ASSERT_NO_THROW (active_poller.wait (std::chrono::milliseconds{500})); + ASSERT_EQ (s.events, ZMQ_POLLIN); // Modify server socket with pollout flag - ASSERT_NO_THROW(active_poller.modify(s.server, ZMQ_POLLIN | ZMQ_POLLOUT)); - ASSERT_EQ(1, active_poller.wait(std::chrono::milliseconds{500})); - ASSERT_EQ(s.events, ZMQ_POLLIN | ZMQ_POLLOUT); + ASSERT_NO_THROW (active_poller.modify (s.server, ZMQ_POLLIN | ZMQ_POLLOUT)); + ASSERT_EQ (1, active_poller.wait (std::chrono::milliseconds{500})); + ASSERT_EQ (s.events, ZMQ_POLLIN | ZMQ_POLLOUT); } -TEST(active_poller, wait_one_return) +TEST (active_poller, wait_one_return) { // Setup server and client server_client_setup s; @@ -308,33 +316,32 @@ TEST(active_poller, wait_one_return) // Setup active_poller zmq::active_poller_t active_poller; - ASSERT_NO_THROW(active_poller.add(s.server, ZMQ_POLLIN, [&count](short) { - ++count; - })); + ASSERT_NO_THROW ( + active_poller.add (s.server, ZMQ_POLLIN, [&count](short) { ++count; })); // client sends message - ASSERT_NO_THROW(s.client.send("Hi")); + ASSERT_NO_THROW (s.client.send ("Hi")); // wait for message and verify events - ASSERT_EQ(1, active_poller.wait(std::chrono::milliseconds{500})); - ASSERT_EQ(1u, count); + ASSERT_EQ (1, active_poller.wait (std::chrono::milliseconds{500})); + ASSERT_EQ (1u, count); } -TEST(active_poller, wait_on_move_constructed_active_poller) +TEST (active_poller, wait_on_move_constructed_active_poller) { server_client_setup s; ASSERT_NO_THROW (s.client.send ("Hi")); zmq::active_poller_t a; zmq::active_poller_t::handler_t handler; ASSERT_NO_THROW (a.add (s.server, ZMQ_POLLIN, handler)); - zmq::active_poller_t b {std::move (a)}; - ASSERT_EQ(1u, b.size ()); + zmq::active_poller_t b{std::move (a)}; + ASSERT_EQ (1u, b.size ()); /// \todo the actual error code should be checked - ASSERT_THROW(a.wait(std::chrono::milliseconds{10}), zmq::error_t); - ASSERT_TRUE (b.wait (std::chrono::milliseconds {-1})); + ASSERT_THROW (a.wait (std::chrono::milliseconds{10}), zmq::error_t); + ASSERT_TRUE (b.wait (std::chrono::milliseconds{-1})); } -TEST(active_poller, wait_on_move_assigned_active_poller) +TEST (active_poller, wait_on_move_assigned_active_poller) { server_client_setup s; ASSERT_NO_THROW (s.client.send ("Hi")); @@ -343,38 +350,37 @@ TEST(active_poller, wait_on_move_assigned_active_poller) ASSERT_NO_THROW (a.add (s.server, ZMQ_POLLIN, handler)); zmq::active_poller_t b; b = {std::move (a)}; - ASSERT_EQ(1u, b.size ()); + ASSERT_EQ (1u, b.size ()); /// \todo the actual error code should be checked - ASSERT_THROW(a.wait(std::chrono::milliseconds{10}), zmq::error_t); - ASSERT_TRUE (b.wait (std::chrono::milliseconds {-1})); + ASSERT_THROW (a.wait (std::chrono::milliseconds{10}), zmq::error_t); + ASSERT_TRUE (b.wait (std::chrono::milliseconds{-1})); } -TEST(active_poller, received_on_move_constructed_active_poller) +TEST (active_poller, received_on_move_constructed_active_poller) { // Setup server and client server_client_setup s; int count = 0; // Setup active_poller a zmq::active_poller_t a; - ASSERT_NO_THROW(a.add(s.server, ZMQ_POLLIN, [&count](short) { - ++count; - })); + ASSERT_NO_THROW ( + a.add (s.server, ZMQ_POLLIN, [&count](short) { ++count; })); // client sends message - ASSERT_NO_THROW(s.client.send("Hi")); + ASSERT_NO_THROW (s.client.send ("Hi")); // wait for message and verify it is received - ASSERT_EQ(1, a.wait(std::chrono::milliseconds{500})); - ASSERT_EQ(1u, count); + ASSERT_EQ (1, a.wait (std::chrono::milliseconds{500})); + ASSERT_EQ (1u, count); // Move construct active_poller b - zmq::active_poller_t b{std::move(a)}; + zmq::active_poller_t b{std::move (a)}; // client sends message again - ASSERT_NO_THROW(s.client.send("Hi")); + ASSERT_NO_THROW (s.client.send ("Hi")); // wait for message and verify it is received - ASSERT_EQ(1, b.wait(std::chrono::milliseconds{500})); - ASSERT_EQ(2u, count); + ASSERT_EQ (1, b.wait (std::chrono::milliseconds{500})); + ASSERT_EQ (2u, count); } -TEST(active_poller, remove_from_handler) +TEST (active_poller, remove_from_handler) { constexpr auto ITER_NO = 10; @@ -387,28 +393,29 @@ TEST(active_poller, remove_from_handler) zmq::active_poller_t active_poller; int count = 0; for (auto i = 0; i < ITER_NO; ++i) { - ASSERT_NO_THROW(active_poller.add(setup_list[i].server, ZMQ_POLLIN, [&,i](short events) { - ASSERT_EQ(events, ZMQ_POLLIN); - active_poller.remove(setup_list[ITER_NO-i-1].server); - ASSERT_EQ(ITER_NO-i-1, active_poller.size()); - })); + ASSERT_NO_THROW (active_poller.add ( + setup_list[i].server, ZMQ_POLLIN, [&, i](short events) { + ASSERT_EQ (events, ZMQ_POLLIN); + active_poller.remove (setup_list[ITER_NO - i - 1].server); + ASSERT_EQ (ITER_NO - i - 1, active_poller.size ()); + })); ++count; } - ASSERT_EQ(ITER_NO, active_poller.size()); + ASSERT_EQ (ITER_NO, active_poller.size ()); // Clients send messages - for (auto & s : setup_list) { - ASSERT_NO_THROW(s.client.send("Hi")); + for (auto &s : setup_list) { + ASSERT_NO_THROW (s.client.send ("Hi")); } // Wait for all servers to receive a message - for (auto & s : setup_list) { - zmq::pollitem_t items [] = { { s.server, 0, ZMQ_POLLIN, 0 } }; - zmq::poll (&items [0], 1); + for (auto &s : setup_list) { + zmq::pollitem_t items[] = {{s.server, 0, ZMQ_POLLIN, 0}}; + zmq::poll (&items[0], 1); } // Fire all handlers in one wait - ASSERT_EQ(ITER_NO, active_poller.wait (std::chrono::milliseconds{-1})); - ASSERT_EQ(ITER_NO, count); + ASSERT_EQ (ITER_NO, active_poller.wait (std::chrono::milliseconds{-1})); + ASSERT_EQ (ITER_NO, count); } #endif diff --git a/tests/context.cpp b/tests/context.cpp index 3039c33..a3faf0a 100644 --- a/tests/context.cpp +++ b/tests/context.cpp @@ -1,15 +1,15 @@ #include #include -TEST(context, create_default_destroy) +TEST (context, create_default_destroy) { zmq::context_t context; } -TEST(context, create_close) +TEST (context, create_close) { zmq::context_t context; - context.close(); - - ASSERT_EQ(NULL, (void*)context); + context.close (); + + ASSERT_EQ (NULL, (void *) context); } diff --git a/tests/main.cpp b/tests/main.cpp index 08fb839..232f8d8 100644 --- a/tests/main.cpp +++ b/tests/main.cpp @@ -1,7 +1,7 @@ #include "gtest/gtest.h" -int main(int argc, char** argv) +int main (int argc, char **argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); + ::testing::InitGoogleTest (&argc, argv); + return RUN_ALL_TESTS (); } diff --git a/tests/message.cpp b/tests/message.cpp index ac892ac..727bec0 100644 --- a/tests/message.cpp +++ b/tests/message.cpp @@ -2,8 +2,10 @@ #include #if defined(ZMQ_CPP11) -static_assert(!std::is_copy_constructible::value, "message_t should not be copy-constructible"); -static_assert(!std::is_copy_assignable::value, "message_t should not be copy-assignable"); +static_assert (!std::is_copy_constructible::value, + "message_t should not be copy-constructible"); +static_assert (!std::is_copy_assignable::value, + "message_t should not be copy-assignable"); #endif TEST (message, constructor_default) @@ -12,7 +14,7 @@ TEST (message, constructor_default) ASSERT_EQ (0u, message.size ()); } -const char* const data = "Hi"; +const char *const data = "Hi"; TEST (message, constructor_iterators) { @@ -30,7 +32,8 @@ TEST (message, constructor_pointer_size) ASSERT_EQ (0, memcmp (data, hi_msg.data (), 2)); } -TEST (message, constructor_char_array) { +TEST (message, constructor_char_array) +{ const zmq::message_t hi_msg (data, strlen (data)); ASSERT_EQ (2u, hi_msg.size ()); ASSERT_EQ (0, memcmp (data, hi_msg.data (), 2)); @@ -49,7 +52,7 @@ TEST (message, constructor_container) #ifdef ZMQ_HAS_RVALUE_REFS TEST (message, constructor_move) { - zmq::message_t hi_msg (zmq::message_t(data, strlen (data))); + zmq::message_t hi_msg (zmq::message_t (data, strlen (data))); } TEST (message, assign_move_empty_before) @@ -63,50 +66,55 @@ TEST (message, assign_move_empty_before) TEST (message, assign_move_empty_after) { zmq::message_t hi_msg (data, strlen (data)); - hi_msg = zmq::message_t(); + hi_msg = zmq::message_t (); ASSERT_EQ (0u, hi_msg.size ()); } TEST (message, assign_move_empty_before_and_after) { zmq::message_t hi_msg; - hi_msg = zmq::message_t(); + hi_msg = zmq::message_t (); ASSERT_EQ (0u, hi_msg.size ()); } #endif -TEST (message, equality_self) { +TEST (message, equality_self) +{ const zmq::message_t hi_msg (data, strlen (data)); ASSERT_EQ (hi_msg, hi_msg); } -TEST (message, equality_equal) { +TEST (message, equality_equal) +{ const zmq::message_t hi_msg_a (data, strlen (data)); const zmq::message_t hi_msg_b (data, strlen (data)); ASSERT_EQ (hi_msg_a, hi_msg_b); } -TEST (message, equality_equal_empty) { +TEST (message, equality_equal_empty) +{ const zmq::message_t msg_a; const zmq::message_t msg_b; ASSERT_EQ (msg_a, msg_b); } -TEST (message, equality_non_equal) { +TEST (message, equality_non_equal) +{ const zmq::message_t msg_a ("Hi", 2); const zmq::message_t msg_b ("Hello", 5); ASSERT_NE (msg_a, msg_b); } -TEST (message, equality_non_equal_rhs_empty) { +TEST (message, equality_non_equal_rhs_empty) +{ const zmq::message_t msg_a ("Hi", 2); const zmq::message_t msg_b; ASSERT_NE (msg_a, msg_b); } -TEST (message, equality_non_equal_lhs_empty) { +TEST (message, equality_non_equal_lhs_empty) +{ const zmq::message_t msg_a; const zmq::message_t msg_b ("Hi", 2); ASSERT_NE (msg_a, msg_b); } - diff --git a/tests/multipart.cpp b/tests/multipart.cpp index 0c279e9..491c4cd 100644 --- a/tests/multipart.cpp +++ b/tests/multipart.cpp @@ -4,168 +4,170 @@ #ifdef ZMQ_HAS_RVALUE_REFS /// \todo split this up into separate test cases /// -TEST(multipart, legacy_test) +TEST (multipart, legacy_test) { using namespace zmq; - - bool ok = true; (void) ok; - float num = 0; (void) num; + + bool ok = true; + (void) ok; + float num = 0; + (void) num; std::string str = ""; message_t msg; // Create two PAIR sockets and connect over inproc - context_t context(1); - socket_t output(context, ZMQ_PAIR); - socket_t input(context, ZMQ_PAIR); - output.bind("inproc://multipart.test"); - input.connect("inproc://multipart.test"); + context_t context (1); + socket_t output (context, ZMQ_PAIR); + socket_t input (context, ZMQ_PAIR); + output.bind ("inproc://multipart.test"); + input.connect ("inproc://multipart.test"); // Test send and receive of single-frame message multipart_t multipart; - assert(multipart.empty()); + assert (multipart.empty ()); - multipart.push(message_t("Hello", 5)); - assert(multipart.size() == 1); + multipart.push (message_t ("Hello", 5)); + assert (multipart.size () == 1); - ok = multipart.send(output); - assert(multipart.empty()); - assert(ok); + ok = multipart.send (output); + assert (multipart.empty ()); + assert (ok); - ok = multipart.recv(input); - assert(multipart.size() == 1); - assert(ok); + ok = multipart.recv (input); + assert (multipart.size () == 1); + assert (ok); - msg = multipart.pop(); - assert(multipart.empty()); - assert(std::string(msg.data(), msg.size()) == "Hello"); + msg = multipart.pop (); + assert (multipart.empty ()); + assert (std::string (msg.data (), msg.size ()) == "Hello"); // Test send and receive of multi-frame message - multipart.addstr("A"); - multipart.addstr("BB"); - multipart.addstr("CCC"); - assert(multipart.size() == 3); + multipart.addstr ("A"); + multipart.addstr ("BB"); + multipart.addstr ("CCC"); + assert (multipart.size () == 3); - multipart_t copy = multipart.clone(); - assert(copy.size() == 3); + multipart_t copy = multipart.clone (); + assert (copy.size () == 3); - ok = copy.send(output); - assert(copy.empty()); - assert(ok); + ok = copy.send (output); + assert (copy.empty ()); + assert (ok); - ok = copy.recv(input); - assert(copy.size() == 3); - assert(ok); - assert(copy.equal(&multipart)); + ok = copy.recv (input); + assert (copy.size () == 3); + assert (ok); + assert (copy.equal (&multipart)); - multipart.clear(); - assert(multipart.empty()); + multipart.clear (); + assert (multipart.empty ()); // Test message frame manipulation - multipart.add(message_t("Frame5", 6)); - multipart.addstr("Frame6"); - multipart.addstr("Frame7"); - multipart.addtyp(8.0f); - multipart.addmem("Frame9", 6); - multipart.push(message_t("Frame4", 6)); - multipart.pushstr("Frame3"); - multipart.pushstr("Frame2"); - multipart.pushtyp(1.0f); - multipart.pushmem("Frame0", 6); - assert(multipart.size() == 10); + multipart.add (message_t ("Frame5", 6)); + multipart.addstr ("Frame6"); + multipart.addstr ("Frame7"); + multipart.addtyp (8.0f); + multipart.addmem ("Frame9", 6); + multipart.push (message_t ("Frame4", 6)); + multipart.pushstr ("Frame3"); + multipart.pushstr ("Frame2"); + multipart.pushtyp (1.0f); + multipart.pushmem ("Frame0", 6); + assert (multipart.size () == 10); - msg = multipart.remove(); - assert(multipart.size() == 9); - assert(std::string(msg.data(), msg.size()) == "Frame9"); + msg = multipart.remove (); + assert (multipart.size () == 9); + assert (std::string (msg.data (), msg.size ()) == "Frame9"); - msg = multipart.pop(); - assert(multipart.size() == 8); - assert(std::string(msg.data(), msg.size()) == "Frame0"); + msg = multipart.pop (); + assert (multipart.size () == 8); + assert (std::string (msg.data (), msg.size ()) == "Frame0"); - num = multipart.poptyp(); - assert(multipart.size() == 7); - assert(num == 1.0f); + num = multipart.poptyp (); + assert (multipart.size () == 7); + assert (num == 1.0f); - str = multipart.popstr(); - assert(multipart.size() == 6); - assert(str == "Frame2"); + str = multipart.popstr (); + assert (multipart.size () == 6); + assert (str == "Frame2"); - str = multipart.popstr(); - assert(multipart.size() == 5); - assert(str == "Frame3"); + str = multipart.popstr (); + assert (multipart.size () == 5); + assert (str == "Frame3"); - str = multipart.popstr(); - assert(multipart.size() == 4); - assert(str == "Frame4"); + str = multipart.popstr (); + assert (multipart.size () == 4); + assert (str == "Frame4"); - str = multipart.popstr(); - assert(multipart.size() == 3); - assert(str == "Frame5"); + str = multipart.popstr (); + assert (multipart.size () == 3); + assert (str == "Frame5"); - str = multipart.popstr(); - assert(multipart.size() == 2); - assert(str == "Frame6"); + str = multipart.popstr (); + assert (multipart.size () == 2); + assert (str == "Frame6"); - str = multipart.popstr(); - assert(multipart.size() == 1); - assert(str == "Frame7"); + str = multipart.popstr (); + assert (multipart.size () == 1); + assert (str == "Frame7"); - num = multipart.poptyp(); - assert(multipart.empty()); - assert(num == 8.0f); + num = multipart.poptyp (); + assert (multipart.empty ()); + assert (num == 8.0f); // Test message constructors and concatenation - multipart_t head("One", 3); - head.addstr("Two"); - assert(head.size() == 2); + multipart_t head ("One", 3); + head.addstr ("Two"); + assert (head.size () == 2); - multipart_t tail(std::string("One-hundred")); - tail.pushstr("Ninety-nine"); - assert(tail.size() == 2); + multipart_t tail (std::string ("One-hundred")); + tail.pushstr ("Ninety-nine"); + assert (tail.size () == 2); - multipart_t tmp(message_t("Fifty", 5)); - assert(tmp.size() == 1); + multipart_t tmp (message_t ("Fifty", 5)); + assert (tmp.size () == 1); - multipart_t mid = multipart_t::create(49.0f); - mid.append(std::move(tmp)); - assert(mid.size() == 2); - assert(tmp.empty()); + multipart_t mid = multipart_t::create (49.0f); + mid.append (std::move (tmp)); + assert (mid.size () == 2); + assert (tmp.empty ()); - multipart_t merged(std::move(mid)); - merged.prepend(std::move(head)); - merged.append(std::move(tail)); - assert(merged.size() == 6); - assert(head.empty()); - assert(tail.empty()); + multipart_t merged (std::move (mid)); + merged.prepend (std::move (head)); + merged.append (std::move (tail)); + assert (merged.size () == 6); + assert (head.empty ()); + assert (tail.empty ()); - ok = merged.send(output); - assert(merged.empty()); - assert(ok); + ok = merged.send (output); + assert (merged.empty ()); + assert (ok); - multipart_t received(input); - assert(received.size() == 6); + multipart_t received (input); + assert (received.size () == 6); - str = received.popstr(); - assert(received.size() == 5); - assert(str == "One"); + str = received.popstr (); + assert (received.size () == 5); + assert (str == "One"); - str = received.popstr(); - assert(received.size() == 4); - assert(str == "Two"); + str = received.popstr (); + assert (received.size () == 4); + assert (str == "Two"); - num = received.poptyp(); - assert(received.size() == 3); - assert(num == 49.0f); + num = received.poptyp (); + assert (received.size () == 3); + assert (num == 49.0f); - str = received.popstr(); - assert(received.size() == 2); - assert(str == "Fifty"); + str = received.popstr (); + assert (received.size () == 2); + assert (str == "Fifty"); - str = received.popstr(); - assert(received.size() == 1); - assert(str == "Ninety-nine"); + str = received.popstr (); + assert (received.size () == 1); + assert (str == "Ninety-nine"); - str = received.popstr(); - assert(received.empty()); - assert(str == "One-hundred"); + str = received.popstr (); + assert (received.empty ()); + assert (str == "One-hundred"); } #endif diff --git a/tests/poller.cpp b/tests/poller.cpp index a777be3..326b12e 100644 --- a/tests/poller.cpp +++ b/tests/poller.cpp @@ -5,151 +5,153 @@ #include #include -TEST(poller, create_destroy) +TEST (poller, create_destroy) { zmq::poller_t<> poller; } -static_assert(!std::is_copy_constructible>::value, "poller_t should not be copy-constructible"); -static_assert(!std::is_copy_assignable>::value, "poller_t should not be copy-assignable"); +static_assert (!std::is_copy_constructible>::value, + "poller_t should not be copy-constructible"); +static_assert (!std::is_copy_assignable>::value, + "poller_t should not be copy-assignable"); -TEST(poller, move_construct_empty) +TEST (poller, move_construct_empty) { zmq::poller_t<> a; zmq::poller_t<> b = std::move (a); } -TEST(poller, move_assign_empty) +TEST (poller, move_assign_empty) { zmq::poller_t<> a; zmq::poller_t<> b; - b = std::move(a); + b = std::move (a); } -TEST(poller, move_construct_non_empty) +TEST (poller, move_construct_non_empty) { zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::router}; zmq::poller_t<> a; - a.add(socket, ZMQ_POLLIN, nullptr); + a.add (socket, ZMQ_POLLIN, nullptr); zmq::poller_t<> b = std::move (a); } -TEST(poller, move_assign_non_empty) +TEST (poller, move_assign_non_empty) { zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::router}; zmq::poller_t<> a; - a.add(socket, ZMQ_POLLIN, nullptr); + a.add (socket, ZMQ_POLLIN, nullptr); zmq::poller_t<> b; - b = std::move(a); + b = std::move (a); } -TEST(poller, add_nullptr) +TEST (poller, add_nullptr) { zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::router}; zmq::poller_t<> poller; - ASSERT_NO_THROW(poller.add(socket, ZMQ_POLLIN, nullptr)); + ASSERT_NO_THROW (poller.add (socket, ZMQ_POLLIN, nullptr)); } -TEST(poller, add_non_nullptr) +TEST (poller, add_non_nullptr) { zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::router}; zmq::poller_t<> poller; int i; - ASSERT_NO_THROW(poller.add(socket, ZMQ_POLLIN, &i)); + ASSERT_NO_THROW (poller.add (socket, ZMQ_POLLIN, &i)); } -TEST(poller, add_handler_invalid_events_type) +TEST (poller, add_handler_invalid_events_type) { - /// \todo is it good that this is accepted? should probably already be + /// \todo is it good that this is accepted? should probably already be /// checked by zmq_poller_add/modify in libzmq: /// https://github.com/zeromq/libzmq/issues/3088 zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::router}; zmq::poller_t<> poller; short invalid_events_type = 2 << 10; - ASSERT_NO_THROW(poller.add(socket, invalid_events_type, nullptr)); + ASSERT_NO_THROW (poller.add (socket, invalid_events_type, nullptr)); } -TEST(poller, add_handler_twice_throws) +TEST (poller, add_handler_twice_throws) { zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::router}; zmq::poller_t<> poller; - poller.add(socket, ZMQ_POLLIN, nullptr); + poller.add (socket, ZMQ_POLLIN, nullptr); /// \todo the actual error code should be checked - ASSERT_THROW(poller.add(socket, ZMQ_POLLIN, nullptr), zmq::error_t); + ASSERT_THROW (poller.add (socket, ZMQ_POLLIN, nullptr), zmq::error_t); } -TEST(poller, wait_with_no_handlers_throws) +TEST (poller, wait_with_no_handlers_throws) { zmq::poller_t<> poller; std::vector events; /// \todo the actual error code should be checked - ASSERT_THROW(poller.wait_all(events, std::chrono::milliseconds{10}), zmq::error_t); + ASSERT_THROW (poller.wait_all (events, std::chrono::milliseconds{10}), + zmq::error_t); } -TEST(poller, remove_unregistered_throws) +TEST (poller, remove_unregistered_throws) { zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::router}; zmq::poller_t<> poller; /// \todo the actual error code should be checked - ASSERT_THROW(poller.remove(socket), zmq::error_t); + ASSERT_THROW (poller.remove (socket), zmq::error_t); } -TEST(poller, remove_registered_empty) +TEST (poller, remove_registered_empty) { zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::router}; zmq::poller_t<> poller; - poller.add(socket, ZMQ_POLLIN, nullptr); - ASSERT_NO_THROW(poller.remove(socket)); + poller.add (socket, ZMQ_POLLIN, nullptr); + ASSERT_NO_THROW (poller.remove (socket)); } -TEST(poller, remove_registered_non_empty) +TEST (poller, remove_registered_non_empty) { zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::router}; zmq::poller_t<> poller; - poller.add(socket, ZMQ_POLLIN, nullptr); - ASSERT_NO_THROW(poller.remove(socket)); + poller.add (socket, ZMQ_POLLIN, nullptr); + ASSERT_NO_THROW (poller.remove (socket)); } -TEST(poller, poll_basic) +TEST (poller, poll_basic) { common_server_client_setup s; - ASSERT_NO_THROW(s.client.send("Hi")); + ASSERT_NO_THROW (s.client.send ("Hi")); zmq::poller_t poller; std::vector events{1}; int i = 0; - ASSERT_NO_THROW(poller.add(s.server, ZMQ_POLLIN, &i)); - ASSERT_EQ(1, poller.wait_all(events, std::chrono::milliseconds{-1})); - ASSERT_EQ(s.server, events[0].socket); - ASSERT_EQ(&i, events[0].user_data); + ASSERT_NO_THROW (poller.add (s.server, ZMQ_POLLIN, &i)); + ASSERT_EQ (1, poller.wait_all (events, std::chrono::milliseconds{-1})); + ASSERT_EQ (s.server, events[0].socket); + ASSERT_EQ (&i, events[0].user_data); } -TEST(poller, add_invalid_socket_throws) +TEST (poller, add_invalid_socket_throws) { zmq::context_t context; zmq::poller_t<> poller; - zmq::socket_t a {context, zmq::socket_type::router}; - zmq::socket_t b {std::move (a)}; - ASSERT_THROW (poller.add (a, ZMQ_POLLIN, nullptr), - zmq::error_t); + zmq::socket_t a{context, zmq::socket_type::router}; + zmq::socket_t b{std::move (a)}; + ASSERT_THROW (poller.add (a, ZMQ_POLLIN, nullptr), zmq::error_t); } -TEST(poller, remove_invalid_socket_throws) +TEST (poller, remove_invalid_socket_throws) { zmq::context_t context; - zmq::socket_t socket {context, zmq::socket_type::router}; + zmq::socket_t socket{context, zmq::socket_type::router}; zmq::poller_t<> poller; ASSERT_NO_THROW (poller.add (socket, ZMQ_POLLIN, nullptr)); std::vector sockets; @@ -158,96 +160,97 @@ TEST(poller, remove_invalid_socket_throws) ASSERT_NO_THROW (poller.remove (sockets[0])); } -TEST(poller, modify_empty_throws) +TEST (poller, modify_empty_throws) { 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; ASSERT_THROW (poller.modify (socket, ZMQ_POLLIN), zmq::error_t); } -TEST(poller, modify_invalid_socket_throws) +TEST (poller, modify_invalid_socket_throws) { zmq::context_t context; - zmq::socket_t a {context, zmq::socket_type::push}; - zmq::socket_t b {std::move (a)}; + zmq::socket_t a{context, zmq::socket_type::push}; + zmq::socket_t b{std::move (a)}; zmq::poller_t<> poller; ASSERT_THROW (poller.modify (a, ZMQ_POLLIN), zmq::error_t); } -TEST(poller, modify_not_added_throws) +TEST (poller, modify_not_added_throws) { zmq::context_t context; - zmq::socket_t a {context, zmq::socket_type::push}; - zmq::socket_t b {context, zmq::socket_type::push}; + zmq::socket_t a{context, zmq::socket_type::push}; + zmq::socket_t b{context, zmq::socket_type::push}; zmq::poller_t<> poller; ASSERT_NO_THROW (poller.add (a, ZMQ_POLLIN, nullptr)); ASSERT_THROW (poller.modify (b, ZMQ_POLLIN), zmq::error_t); } -TEST(poller, modify_simple) +TEST (poller, modify_simple) { zmq::context_t context; - zmq::socket_t a {context, zmq::socket_type::push}; + zmq::socket_t a{context, zmq::socket_type::push}; zmq::poller_t<> poller; ASSERT_NO_THROW (poller.add (a, ZMQ_POLLIN, nullptr)); - ASSERT_NO_THROW (poller.modify (a, ZMQ_POLLIN|ZMQ_POLLOUT)); + ASSERT_NO_THROW (poller.modify (a, ZMQ_POLLIN | ZMQ_POLLOUT)); } -TEST(poller, poll_client_server) +TEST (poller, poll_client_server) { // Setup server and client common_server_client_setup s; // Setup poller zmq::poller_t<> poller; - ASSERT_NO_THROW(poller.add(s.server, ZMQ_POLLIN, s.server)); + ASSERT_NO_THROW (poller.add (s.server, ZMQ_POLLIN, s.server)); // client sends message - ASSERT_NO_THROW(s.client.send("Hi")); + ASSERT_NO_THROW (s.client.send ("Hi")); // wait for message and verify events - std::vector events(1); - ASSERT_EQ(1, poller.wait_all(events, std::chrono::milliseconds{500})); - ASSERT_EQ(ZMQ_POLLIN, events[0].events); + std::vector events (1); + ASSERT_EQ (1, poller.wait_all (events, std::chrono::milliseconds{500})); + ASSERT_EQ (ZMQ_POLLIN, events[0].events); // Modify server socket with pollout flag - ASSERT_NO_THROW(poller.modify(s.server, ZMQ_POLLIN | ZMQ_POLLOUT)); - ASSERT_EQ(1, poller.wait_all(events, std::chrono::milliseconds{500})); - ASSERT_EQ(ZMQ_POLLIN | ZMQ_POLLOUT, events[0].events); + ASSERT_NO_THROW (poller.modify (s.server, ZMQ_POLLIN | ZMQ_POLLOUT)); + ASSERT_EQ (1, poller.wait_all (events, std::chrono::milliseconds{500})); + ASSERT_EQ (ZMQ_POLLIN | ZMQ_POLLOUT, events[0].events); } -TEST(poller, wait_one_return) +TEST (poller, wait_one_return) { // Setup server and client common_server_client_setup s; // Setup poller zmq::poller_t<> poller; - ASSERT_NO_THROW(poller.add(s.server, ZMQ_POLLIN, nullptr)); + ASSERT_NO_THROW (poller.add (s.server, ZMQ_POLLIN, nullptr)); // client sends message - ASSERT_NO_THROW(s.client.send("Hi")); + ASSERT_NO_THROW (s.client.send ("Hi")); // wait for message and verify events - std::vector events(1); - ASSERT_EQ(1, poller.wait_all(events, std::chrono::milliseconds{500})); + std::vector events (1); + ASSERT_EQ (1, poller.wait_all (events, std::chrono::milliseconds{500})); } -TEST(poller, wait_on_move_constructed_poller) +TEST (poller, wait_on_move_constructed_poller) { common_server_client_setup s; ASSERT_NO_THROW (s.client.send ("Hi")); zmq::poller_t<> a; ASSERT_NO_THROW (a.add (s.server, ZMQ_POLLIN, nullptr)); - zmq::poller_t<> b {std::move (a)}; - std::vector events(1); + zmq::poller_t<> b{std::move (a)}; + std::vector events (1); /// \todo the actual error code should be checked - ASSERT_THROW(a.wait_all (events, std::chrono::milliseconds{10}), zmq::error_t); - ASSERT_EQ (1, b.wait_all (events, std::chrono::milliseconds {-1})); + ASSERT_THROW (a.wait_all (events, std::chrono::milliseconds{10}), + zmq::error_t); + ASSERT_EQ (1, b.wait_all (events, std::chrono::milliseconds{-1})); } -TEST(poller, wait_on_move_assigned_poller) +TEST (poller, wait_on_move_assigned_poller) { common_server_client_setup s; ASSERT_NO_THROW (s.client.send ("Hi")); @@ -256,12 +259,13 @@ TEST(poller, wait_on_move_assigned_poller) zmq::poller_t<> b; b = {std::move (a)}; /// \todo the actual error code should be checked - std::vector events(1); - ASSERT_THROW(a.wait_all (events, std::chrono::milliseconds{10}), zmq::error_t); - ASSERT_EQ (1, b.wait_all (events, std::chrono::milliseconds {-1})); + std::vector events (1); + ASSERT_THROW (a.wait_all (events, std::chrono::milliseconds{10}), + zmq::error_t); + ASSERT_EQ (1, b.wait_all (events, std::chrono::milliseconds{-1})); } -TEST(poller, remove_from_handler) +TEST (poller, remove_from_handler) { constexpr auto ITER_NO = 10; @@ -273,22 +277,24 @@ TEST(poller, remove_from_handler) // Setup poller zmq::poller_t<> poller; for (auto i = 0; i < ITER_NO; ++i) { - ASSERT_NO_THROW(poller.add(setup_list[i].server, ZMQ_POLLIN, nullptr)); + ASSERT_NO_THROW ( + poller.add (setup_list[i].server, ZMQ_POLLIN, nullptr)); } // Clients send messages - for (auto & s : setup_list) { - ASSERT_NO_THROW(s.client.send("Hi")); + for (auto &s : setup_list) { + ASSERT_NO_THROW (s.client.send ("Hi")); } // Wait for all servers to receive a message - for (auto & s : setup_list) { - zmq::pollitem_t items [] = { { s.server, 0, ZMQ_POLLIN, 0 } }; - zmq::poll (&items [0], 1); + for (auto &s : setup_list) { + zmq::pollitem_t items[] = {{s.server, 0, ZMQ_POLLIN, 0}}; + zmq::poll (&items[0], 1); } // Fire all handlers in one wait - std::vector events(ITER_NO); - ASSERT_EQ(ITER_NO, poller.wait_all (events, std::chrono::milliseconds{-1})); + std::vector events (ITER_NO); + ASSERT_EQ (ITER_NO, + poller.wait_all (events, std::chrono::milliseconds{-1})); } #endif diff --git a/tests/socket.cpp b/tests/socket.cpp index a0397a1..24b5c91 100644 --- a/tests/socket.cpp +++ b/tests/socket.cpp @@ -1,16 +1,16 @@ #include #include -TEST(socket, create_destroy) +TEST (socket, create_destroy) { zmq::context_t context; - zmq::socket_t socket(context, ZMQ_ROUTER); + zmq::socket_t socket (context, ZMQ_ROUTER); } #ifdef ZMQ_CPP11 -TEST(socket, create_by_enum_destroy) +TEST (socket, create_by_enum_destroy) { zmq::context_t context; - zmq::socket_t socket(context, zmq::socket_type::router); + zmq::socket_t socket (context, zmq::socket_type::router); } #endif diff --git a/zmq.hpp b/zmq.hpp index 983d0ff..837a73e 100644 --- a/zmq.hpp +++ b/zmq.hpp @@ -27,25 +27,25 @@ #define __ZMQ_HPP_INCLUDED__ #if (__cplusplus >= 201402L) - #define ZMQ_DEPRECATED(msg) [[deprecated(msg)]] +#define ZMQ_DEPRECATED(msg) [[deprecated (msg)]] #elif defined(_MSC_VER) - #define ZMQ_DEPRECATED(msg) __declspec(deprecated(msg)) +#define ZMQ_DEPRECATED(msg) __declspec(deprecated (msg)) #elif defined(__GNUC__) - #define ZMQ_DEPRECATED(msg) __attribute__((deprecated(msg))) +#define ZMQ_DEPRECATED(msg) __attribute__ ((deprecated (msg))) #endif #if (__cplusplus >= 201103L) - #define ZMQ_CPP11 - #define ZMQ_NOTHROW noexcept - #define ZMQ_EXPLICIT explicit +#define ZMQ_CPP11 +#define ZMQ_NOTHROW noexcept +#define ZMQ_EXPLICIT explicit #elif (defined(_MSC_VER) && (_MSC_VER >= 1900)) - #define ZMQ_CPP11 - #define ZMQ_NOTHROW noexcept - #define ZMQ_EXPLICIT explicit +#define ZMQ_CPP11 +#define ZMQ_NOTHROW noexcept +#define ZMQ_EXPLICIT explicit #else - #define ZMQ_CPP03 - #define ZMQ_NOTHROW - #define ZMQ_EXPLICIT +#define ZMQ_CPP03 +#define ZMQ_NOTHROW +#define ZMQ_EXPLICIT #endif #include @@ -66,1025 +66,1070 @@ #define CPPZMQ_VERSION_MINOR 3 #define CPPZMQ_VERSION_PATCH 0 -#define CPPZMQ_VERSION \ - ZMQ_MAKE_VERSION (CPPZMQ_VERSION_MAJOR, CPPZMQ_VERSION_MINOR, CPPZMQ_VERSION_PATCH) +#define CPPZMQ_VERSION \ + ZMQ_MAKE_VERSION (CPPZMQ_VERSION_MAJOR, CPPZMQ_VERSION_MINOR, \ + CPPZMQ_VERSION_PATCH) #ifdef ZMQ_CPP11 - #include - #include - #include - #include - #include +#include +#include +#include +#include +#include #endif // Detect whether the compiler supports C++11 rvalue references. -#if (defined(__GNUC__) && (__GNUC__ > 4 || \ - (__GNUC__ == 4 && __GNUC_MINOR__ > 2)) && \ - defined(__GXX_EXPERIMENTAL_CXX0X__)) - #define ZMQ_HAS_RVALUE_REFS - #define ZMQ_DELETED_FUNCTION = delete +#if (defined(__GNUC__) \ + && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 2)) \ + && defined(__GXX_EXPERIMENTAL_CXX0X__)) +#define ZMQ_HAS_RVALUE_REFS +#define ZMQ_DELETED_FUNCTION = delete #elif defined(__clang__) - #if __has_feature(cxx_rvalue_references) - #define ZMQ_HAS_RVALUE_REFS - #endif +#if __has_feature(cxx_rvalue_references) +#define ZMQ_HAS_RVALUE_REFS +#endif - #if __has_feature(cxx_deleted_functions) - #define ZMQ_DELETED_FUNCTION = delete - #else - #define ZMQ_DELETED_FUNCTION - #endif -#elif defined(_MSC_VER) && (_MSC_VER >= 1900) - #define ZMQ_HAS_RVALUE_REFS - #define ZMQ_DELETED_FUNCTION = delete -#elif defined(_MSC_VER) && (_MSC_VER >= 1600) - #define ZMQ_HAS_RVALUE_REFS - #define ZMQ_DELETED_FUNCTION +#if __has_feature(cxx_deleted_functions) +#define ZMQ_DELETED_FUNCTION = delete #else - #define ZMQ_DELETED_FUNCTION +#define ZMQ_DELETED_FUNCTION +#endif +#elif defined(_MSC_VER) && (_MSC_VER >= 1900) +#define ZMQ_HAS_RVALUE_REFS +#define ZMQ_DELETED_FUNCTION = delete +#elif defined(_MSC_VER) && (_MSC_VER >= 1600) +#define ZMQ_HAS_RVALUE_REFS +#define ZMQ_DELETED_FUNCTION +#else +#define ZMQ_DELETED_FUNCTION #endif #if ZMQ_VERSION >= ZMQ_MAKE_VERSION(3, 3, 0) - #define ZMQ_NEW_MONITOR_EVENT_LAYOUT +#define ZMQ_NEW_MONITOR_EVENT_LAYOUT #endif #if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 1, 0) - #define ZMQ_HAS_PROXY_STEERABLE +#define ZMQ_HAS_PROXY_STEERABLE /* Socket event data */ -typedef struct { - uint16_t event; // id of the event as bitfield - int32_t value ; // value is either error code, fd or reconnect interval +typedef struct +{ + uint16_t event; // id of the event as bitfield + int32_t value; // value is either error code, fd or reconnect interval } zmq_event_t; #endif // Avoid using deprecated message receive function when possible #if ZMQ_VERSION < ZMQ_MAKE_VERSION(3, 2, 0) -# define zmq_msg_recv(msg, socket, flags) zmq_recvmsg(socket, msg, flags) +#define zmq_msg_recv(msg, socket, flags) zmq_recvmsg (socket, msg, flags) #endif // In order to prevent unused variable warnings when building in non-debug // mode use this macro to make assertions. #ifndef NDEBUG -# define ZMQ_ASSERT(expression) assert(expression) +#define ZMQ_ASSERT(expression) assert (expression) #else -# define ZMQ_ASSERT(expression) (void)(expression) +#define ZMQ_ASSERT(expression) (void) (expression) #endif namespace zmq { +typedef zmq_free_fn free_fn; +typedef zmq_pollitem_t pollitem_t; - typedef zmq_free_fn free_fn; - typedef zmq_pollitem_t pollitem_t; - - class error_t : public std::exception - { - public: - - error_t () : errnum (zmq_errno ()) {} +class error_t : public std::exception +{ + public: + error_t () : errnum (zmq_errno ()) {} #ifdef ZMQ_CPP11 - virtual const char *what () const noexcept - { - return zmq_strerror (errnum); - } + virtual const char *what () const noexcept { return zmq_strerror (errnum); } #else - virtual const char *what() const throw () - { - return zmq_strerror(errnum); - } + virtual const char *what () const throw () { return zmq_strerror (errnum); } #endif - int num () const - { - return errnum; - } + int num () const { return errnum; } - private: + private: + int errnum; +}; - int errnum; - }; +inline int +poll (zmq_pollitem_t const *items_, size_t nitems_, long timeout_ = -1) +{ + int rc = zmq_poll (const_cast (items_), + static_cast (nitems_), timeout_); + if (rc < 0) + throw error_t (); + return rc; +} - inline int poll (zmq_pollitem_t const* items_, size_t nitems_, long timeout_ = -1) +#ifdef ZMQ_CPP11 +inline int poll (zmq_pollitem_t const *items, + size_t nitems, + std::chrono::milliseconds timeout) +{ + return poll (items, nitems, static_cast (timeout.count ())); +} + +inline int poll (std::vector const &items, + std::chrono::milliseconds timeout) +{ + return poll (items.data (), items.size (), + static_cast (timeout.count ())); +} + +inline int poll (std::vector const &items, long timeout_ = -1) +{ + return poll (items.data (), items.size (), timeout_); +} +#endif + + +inline void proxy (void *frontend, void *backend, void *capture) +{ + int rc = zmq_proxy (frontend, backend, capture); + if (rc != 0) + throw error_t (); +} + +#ifdef ZMQ_HAS_PROXY_STEERABLE +inline void +proxy_steerable (void *frontend, void *backend, void *capture, void *control) +{ + int rc = zmq_proxy_steerable (frontend, backend, capture, control); + if (rc != 0) + throw error_t (); +} +#endif + +inline void version (int *major_, int *minor_, int *patch_) +{ + zmq_version (major_, minor_, patch_); +} + +#ifdef ZMQ_CPP11 +inline std::tuple version () +{ + std::tuple v; + zmq_version (&std::get<0> (v), &std::get<1> (v), &std::get<2> (v)); + return v; +} +#endif + +class message_t +{ + friend class socket_t; + + public: + inline message_t () { - int rc = zmq_poll (const_cast(items_), static_cast(nitems_), timeout_); - if (rc < 0) + int rc = zmq_msg_init (&msg); + if (rc != 0) throw error_t (); + } + + inline explicit message_t (size_t size_) + { + int rc = zmq_msg_init_size (&msg, size_); + if (rc != 0) + throw error_t (); + } + + template message_t (I first, I last) : msg () + { + typedef typename std::iterator_traits::difference_type size_type; + typedef typename std::iterator_traits::value_type value_t; + + size_type const size_ = std::distance (first, last) * sizeof (value_t); + int const rc = zmq_msg_init_size (&msg, size_); + if (rc != 0) + throw error_t (); + value_t *dest = data (); + while (first != last) { + *dest = *first; + ++dest; + ++first; + } + } + + inline message_t (const void *data_, size_t size_) + { + int rc = zmq_msg_init_size (&msg, size_); + if (rc != 0) + throw error_t (); + memcpy (data (), data_, size_); + } + + inline message_t (void *data_, + size_t size_, + free_fn *ffn_, + void *hint_ = NULL) + { + int rc = zmq_msg_init_data (&msg, data_, size_, ffn_, hint_); + if (rc != 0) + throw error_t (); + } + +#if defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) + template + message_t (const T &msg_) : message_t (std::begin (msg_), std::end (msg_)) + { + } +#endif + +#ifdef ZMQ_HAS_RVALUE_REFS + inline message_t (message_t &&rhs) : msg (rhs.msg) + { + int rc = zmq_msg_init (&rhs.msg); + if (rc != 0) + throw error_t (); + } + + inline message_t &operator= (message_t &&rhs) ZMQ_NOTHROW + { + std::swap (msg, rhs.msg); + return *this; + } +#endif + + inline ~message_t () ZMQ_NOTHROW + { + int rc = zmq_msg_close (&msg); + ZMQ_ASSERT (rc == 0); + } + + inline void rebuild () + { + int rc = zmq_msg_close (&msg); + if (rc != 0) + throw error_t (); + rc = zmq_msg_init (&msg); + if (rc != 0) + throw error_t (); + } + + inline void rebuild (size_t size_) + { + int rc = zmq_msg_close (&msg); + if (rc != 0) + throw error_t (); + rc = zmq_msg_init_size (&msg, size_); + if (rc != 0) + throw error_t (); + } + + inline void rebuild (const void *data_, size_t size_) + { + int rc = zmq_msg_close (&msg); + if (rc != 0) + throw error_t (); + rc = zmq_msg_init_size (&msg, size_); + if (rc != 0) + throw error_t (); + memcpy (data (), data_, size_); + } + + inline void + rebuild (void *data_, size_t size_, free_fn *ffn_, void *hint_ = NULL) + { + int rc = zmq_msg_close (&msg); + if (rc != 0) + throw error_t (); + rc = zmq_msg_init_data (&msg, data_, size_, ffn_, hint_); + if (rc != 0) + throw error_t (); + } + + inline void move (message_t const *msg_) + { + int rc = zmq_msg_move (&msg, const_cast (&(msg_->msg))); + if (rc != 0) + throw error_t (); + } + + inline void copy (message_t const *msg_) + { + int rc = zmq_msg_copy (&msg, const_cast (&(msg_->msg))); + if (rc != 0) + throw error_t (); + } + + inline bool more () const ZMQ_NOTHROW + { + int rc = zmq_msg_more (const_cast (&msg)); + return rc != 0; + } + + inline void *data () ZMQ_NOTHROW { return zmq_msg_data (&msg); } + + inline const void *data () const ZMQ_NOTHROW + { + return zmq_msg_data (const_cast (&msg)); + } + + inline size_t size () const ZMQ_NOTHROW + { + return zmq_msg_size (const_cast (&msg)); + } + + template T *data () ZMQ_NOTHROW + { + return static_cast (data ()); + } + + template T const *data () const ZMQ_NOTHROW + { + return static_cast (data ()); + } + + ZMQ_DEPRECATED ("from 4.3.0, use operator== instead") + inline bool equal (const message_t *other) const ZMQ_NOTHROW + { + return *this == *other; + } + + inline bool operator== (const message_t &other) const ZMQ_NOTHROW + { + const size_t my_size = size (); + return my_size == other.size () + && 0 == memcmp (data (), other.data (), my_size); + } + + inline bool operator!= (const message_t &other) const ZMQ_NOTHROW + { + return !(*this == other); + } + +#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 1, 0) + inline const char *gets (const char *property_) + { + const char *value = zmq_msg_gets (&msg, property_); + if (value == NULL) + throw error_t (); + return value; + } +#endif + /** Dump content to string. Ascii chars are readable, the rest is printed as hex. + * Probably ridiculously slow. + */ + inline std::string str () const + { + // Partly mutuated from the same method in zmq::multipart_t + std::stringstream os; + + const unsigned char *msg_data = this->data (); + unsigned char byte; + size_t size = this->size (); + int is_ascii[2] = {0, 0}; + + os << "zmq::message_t [size " << std::dec << std::setw (3) + << std::setfill ('0') << size << "] ("; + // Totally arbitrary + if (size >= 1000) { + os << "... too big to print)"; + } else { + while (size--) { + byte = *msg_data++; + + is_ascii[1] = (byte >= 33 && byte < 127); + if (is_ascii[1] != is_ascii[0]) + os << " "; // Separate text/non text + + if (is_ascii[1]) { + os << byte; + } else { + os << std::hex << std::uppercase << std::setw (2) + << std::setfill ('0') << static_cast (byte); + } + is_ascii[0] = is_ascii[1]; + } + os << ")"; + } + return os.str (); + } + + private: + // The underlying message + zmq_msg_t msg; + + // Disable implicit message copying, so that users won't use shared + // messages (less efficient) without being aware of the fact. + message_t (const message_t &) ZMQ_DELETED_FUNCTION; + void operator= (const message_t &) ZMQ_DELETED_FUNCTION; +}; + +class context_t +{ + friend class socket_t; + + public: + inline context_t () + { + ptr = zmq_ctx_new (); + if (ptr == NULL) + throw error_t (); + } + + + inline explicit context_t (int io_threads_, + int max_sockets_ = ZMQ_MAX_SOCKETS_DFLT) + { + ptr = zmq_ctx_new (); + if (ptr == NULL) + throw error_t (); + + int rc = zmq_ctx_set (ptr, ZMQ_IO_THREADS, io_threads_); + ZMQ_ASSERT (rc == 0); + + rc = zmq_ctx_set (ptr, ZMQ_MAX_SOCKETS, max_sockets_); + ZMQ_ASSERT (rc == 0); + } + +#ifdef ZMQ_HAS_RVALUE_REFS + inline context_t (context_t &&rhs) ZMQ_NOTHROW : ptr (rhs.ptr) + { + rhs.ptr = NULL; + } + inline context_t &operator= (context_t &&rhs) ZMQ_NOTHROW + { + std::swap (ptr, rhs.ptr); + return *this; + } +#endif + + inline int setctxopt (int option_, int optval_) + { + int rc = zmq_ctx_set (ptr, option_, optval_); + ZMQ_ASSERT (rc == 0); return rc; } - #ifdef ZMQ_CPP11 - inline int poll(zmq_pollitem_t const* items, size_t nitems, std::chrono::milliseconds timeout) + inline int getctxopt (int option_) { return zmq_ctx_get (ptr, option_); } + + inline ~context_t () ZMQ_NOTHROW { close (); } + + inline void close () ZMQ_NOTHROW { - return poll(items, nitems, static_cast(timeout.count())); + if (ptr == NULL) + return; + + int rc = zmq_ctx_destroy (ptr); + ZMQ_ASSERT (rc == 0); + ptr = NULL; } - inline int poll(std::vector const& items, std::chrono::milliseconds timeout) + // Be careful with this, it's probably only useful for + // using the C api together with an existing C++ api. + // Normally you should never need to use this. + inline ZMQ_EXPLICIT operator void * () ZMQ_NOTHROW { return ptr; } + + inline ZMQ_EXPLICIT operator void const * () const ZMQ_NOTHROW { - return poll(items.data(), items.size(), static_cast(timeout.count())); + return ptr; } - inline int poll(std::vector const& items, long timeout_ = -1) - { - return poll(items.data(), items.size(), timeout_); - } - #endif + inline operator bool () const ZMQ_NOTHROW { return ptr != NULL; } + private: + void *ptr; + context_t (const context_t &) ZMQ_DELETED_FUNCTION; + void operator= (const context_t &) ZMQ_DELETED_FUNCTION; +}; - inline void proxy (void *frontend, void *backend, void *capture) - { - int rc = zmq_proxy (frontend, backend, capture); - if (rc != 0) - throw error_t (); - } - -#ifdef ZMQ_HAS_PROXY_STEERABLE - inline void proxy_steerable (void *frontend, void *backend, void *capture, void *control) - { - int rc = zmq_proxy_steerable (frontend, backend, capture, control); - if (rc != 0) - throw error_t (); - } -#endif - - inline void version (int *major_, int *minor_, int *patch_) - { - zmq_version (major_, minor_, patch_); - } - - #ifdef ZMQ_CPP11 - inline std::tuple version() - { - std::tuple v; - zmq_version(&std::get<0>(v), &std::get<1>(v), &std::get<2>(v) ); - return v; - } - #endif - - class message_t - { - friend class socket_t; - - public: - - inline message_t () - { - int rc = zmq_msg_init (&msg); - if (rc != 0) - throw error_t (); - } - - inline explicit message_t (size_t size_) - { - int rc = zmq_msg_init_size (&msg, size_); - if (rc != 0) - throw error_t (); - } - - template message_t(I first, I last): - msg() - { - typedef typename std::iterator_traits::difference_type size_type; - typedef typename std::iterator_traits::value_type value_t; - - size_type const size_ = std::distance(first, last)*sizeof(value_t); - int const rc = zmq_msg_init_size (&msg, size_); - if (rc != 0) - throw error_t (); - value_t* dest = data(); - while (first != last) - { - *dest = *first; - ++dest; ++first; - } - } - - inline message_t (const void *data_, size_t size_) - { - int rc = zmq_msg_init_size (&msg, size_); - if (rc != 0) - throw error_t (); - memcpy(data(), data_, size_); - } - - inline message_t (void *data_, size_t size_, free_fn *ffn_, - void *hint_ = NULL) - { - int rc = zmq_msg_init_data (&msg, data_, size_, ffn_, hint_); - if (rc != 0) - throw error_t (); - } - -#if defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) - template message_t (const T &msg_) - : message_t (std::begin (msg_), std::end (msg_)) - {} -#endif - -#ifdef ZMQ_HAS_RVALUE_REFS - inline message_t (message_t &&rhs): msg (rhs.msg) - { - int rc = zmq_msg_init (&rhs.msg); - if (rc != 0) - throw error_t (); - } - - inline message_t &operator = (message_t &&rhs) ZMQ_NOTHROW - { - std::swap (msg, rhs.msg); - return *this; - } -#endif - - inline ~message_t () ZMQ_NOTHROW - { - int rc = zmq_msg_close (&msg); - ZMQ_ASSERT (rc == 0); - } - - inline void rebuild () - { - int rc = zmq_msg_close (&msg); - if (rc != 0) - throw error_t (); - rc = zmq_msg_init (&msg); - if (rc != 0) - throw error_t (); - } - - inline void rebuild (size_t size_) - { - int rc = zmq_msg_close (&msg); - if (rc != 0) - throw error_t (); - rc = zmq_msg_init_size (&msg, size_); - if (rc != 0) - throw error_t (); - } - - inline void rebuild (const void *data_, size_t size_) - { - int rc = zmq_msg_close (&msg); - if (rc != 0) - throw error_t (); - rc = zmq_msg_init_size (&msg, size_); - if (rc != 0) - throw error_t (); - memcpy(data(), data_, size_); - } - - inline void rebuild (void *data_, size_t size_, free_fn *ffn_, - void *hint_ = NULL) - { - int rc = zmq_msg_close (&msg); - if (rc != 0) - throw error_t (); - rc = zmq_msg_init_data (&msg, data_, size_, ffn_, hint_); - if (rc != 0) - throw error_t (); - } - - inline void move (message_t const *msg_) - { - int rc = zmq_msg_move (&msg, const_cast(&(msg_->msg))); - if (rc != 0) - throw error_t (); - } - - inline void copy (message_t const *msg_) - { - int rc = zmq_msg_copy (&msg, const_cast(&(msg_->msg))); - if (rc != 0) - throw error_t (); - } - - inline bool more () const ZMQ_NOTHROW - { - int rc = zmq_msg_more (const_cast(&msg) ); - return rc != 0; - } - - inline void *data () ZMQ_NOTHROW - { - return zmq_msg_data (&msg); - } - - inline const void* data () const ZMQ_NOTHROW - { - return zmq_msg_data (const_cast(&msg)); - } - - inline size_t size () const ZMQ_NOTHROW - { - return zmq_msg_size (const_cast(&msg)); - } - - template T* data() ZMQ_NOTHROW - { - return static_cast( data() ); - } - - template T const* data() const ZMQ_NOTHROW - { - return static_cast( data() ); - } - - ZMQ_DEPRECATED("from 4.3.0, use operator== instead") - inline bool equal(const message_t* other) const ZMQ_NOTHROW - { - return *this == *other; - } - - inline bool operator==(const message_t &other) const ZMQ_NOTHROW - { - const size_t my_size = size (); - return my_size == other.size () && 0 == memcmp (data (), other.data (), my_size); - } - - inline bool operator!=(const message_t &other) const ZMQ_NOTHROW - { - return !(*this == other); - } - -#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 1, 0) - inline const char* gets(const char *property_) - { - const char* value = zmq_msg_gets (&msg, property_); - if (value == NULL) - throw error_t (); - return value; - } -#endif - /** Dump content to string. Ascii chars are readable, the rest is printed as hex. - * Probably ridiculously slow. - */ - inline std::string str() const - { - // Partly mutuated from the same method in zmq::multipart_t - std::stringstream os; - - const unsigned char* msg_data = this->data(); - unsigned char byte; - size_t size = this->size(); - int is_ascii[2] = {0, 0}; - - os << "zmq::message_t [size " << std::dec << std::setw(3) << std::setfill('0') << size << "] ("; - // Totally arbitrary - if (size >= 1000) { - os << "... too big to print)"; - } else { - while (size--) { - byte = *msg_data++; - - is_ascii[1] = (byte >= 33 && byte < 127); - if (is_ascii[1] != is_ascii[0]) - os << " "; // Separate text/non text - - if (is_ascii[1]) { - os << byte; - } else { - os << std::hex << std::uppercase << std::setw(2) << std::setfill('0') << static_cast(byte); - } - is_ascii[0] = is_ascii[1]; - } - os << ")"; - } - return os.str(); - } - - private: - // The underlying message - zmq_msg_t msg; - - // Disable implicit message copying, so that users won't use shared - // messages (less efficient) without being aware of the fact. - message_t (const message_t&) ZMQ_DELETED_FUNCTION; - void operator = (const message_t&) ZMQ_DELETED_FUNCTION; - }; - - class context_t - { - friend class socket_t; - - public: - inline context_t () - { - ptr = zmq_ctx_new (); - if (ptr == NULL) - throw error_t (); - } - - - inline explicit context_t (int io_threads_, int max_sockets_ = ZMQ_MAX_SOCKETS_DFLT) - { - ptr = zmq_ctx_new (); - if (ptr == NULL) - throw error_t (); - - int rc = zmq_ctx_set (ptr, ZMQ_IO_THREADS, io_threads_); - ZMQ_ASSERT (rc == 0); - - rc = zmq_ctx_set (ptr, ZMQ_MAX_SOCKETS, max_sockets_); - ZMQ_ASSERT (rc == 0); - } - -#ifdef ZMQ_HAS_RVALUE_REFS - inline context_t (context_t &&rhs) ZMQ_NOTHROW : ptr (rhs.ptr) - { - rhs.ptr = NULL; - } - inline context_t &operator = (context_t &&rhs) ZMQ_NOTHROW - { - std::swap (ptr, rhs.ptr); - return *this; - } -#endif - - inline int setctxopt(int option_, int optval_) - { - int rc = zmq_ctx_set (ptr, option_, optval_); - ZMQ_ASSERT (rc == 0); - return rc; - } - - inline int getctxopt(int option_) - { - return zmq_ctx_get (ptr, option_); - } - - inline ~context_t () ZMQ_NOTHROW - { - close(); - } - - inline void close() ZMQ_NOTHROW - { - if (ptr == NULL) - return; - - int rc = zmq_ctx_destroy (ptr); - ZMQ_ASSERT (rc == 0); - ptr = NULL; - } - - // Be careful with this, it's probably only useful for - // using the C api together with an existing C++ api. - // Normally you should never need to use this. - inline ZMQ_EXPLICIT operator void* () ZMQ_NOTHROW - { - return ptr; - } - - inline ZMQ_EXPLICIT operator void const* () const ZMQ_NOTHROW - { - return ptr; - } - - inline operator bool() const ZMQ_NOTHROW - { - return ptr != NULL; - } - private: - - void *ptr; - - context_t (const context_t&) ZMQ_DELETED_FUNCTION; - void operator = (const context_t&) ZMQ_DELETED_FUNCTION; - }; - - #ifdef ZMQ_CPP11 - enum class socket_type: int - { - req = ZMQ_REQ, - rep = ZMQ_REP, - dealer = ZMQ_DEALER, - router = ZMQ_ROUTER, - pub = ZMQ_PUB, - sub = ZMQ_SUB, - xpub = ZMQ_XPUB, - xsub = ZMQ_XSUB, - push = ZMQ_PUSH, - pull = ZMQ_PULL, +#ifdef ZMQ_CPP11 +enum class socket_type : int +{ + req = ZMQ_REQ, + rep = ZMQ_REP, + dealer = ZMQ_DEALER, + router = ZMQ_ROUTER, + pub = ZMQ_PUB, + sub = ZMQ_SUB, + xpub = ZMQ_XPUB, + xsub = ZMQ_XSUB, + push = ZMQ_PUSH, + pull = ZMQ_PULL, #ifdef ZMQ_BUILD_DRAFT_API - server = ZMQ_SERVER, - client = ZMQ_CLIENT, + server = ZMQ_SERVER, + client = ZMQ_CLIENT, #endif #if ZMQ_VERSION_MAJOR >= 4 - stream = ZMQ_STREAM, + stream = ZMQ_STREAM, +#endif + pair = ZMQ_PAIR +}; #endif - pair = ZMQ_PAIR - }; - #endif - class socket_t +class socket_t +{ + friend class monitor_t; + + public: + inline socket_t (context_t &context_, int type_) { init (context_, type_); } + +#ifdef ZMQ_CPP11 + inline socket_t (context_t &context_, socket_type type_) { - friend class monitor_t; - public: - inline socket_t(context_t& context_, int type_) - { - init(context_, type_); - } - - #ifdef ZMQ_CPP11 - inline socket_t(context_t& context_, socket_type type_) - { - init(context_, static_cast(type_)); - } - #endif + init (context_, static_cast (type_)); + } +#endif #ifdef ZMQ_HAS_RVALUE_REFS - inline socket_t(socket_t&& rhs) ZMQ_NOTHROW : - ptr(rhs.ptr), - ctxptr(rhs.ctxptr) - { - rhs.ptr = NULL; - rhs.ctxptr = NULL; - } - inline socket_t& operator=(socket_t&& rhs) ZMQ_NOTHROW - { - std::swap(ptr, rhs.ptr); - return *this; - } + inline socket_t (socket_t &&rhs) ZMQ_NOTHROW : ptr (rhs.ptr), + ctxptr (rhs.ctxptr) + { + rhs.ptr = NULL; + rhs.ctxptr = NULL; + } + inline socket_t &operator= (socket_t &&rhs) ZMQ_NOTHROW + { + std::swap (ptr, rhs.ptr); + return *this; + } #endif - inline ~socket_t () ZMQ_NOTHROW - { - close(); - } + inline ~socket_t () ZMQ_NOTHROW { close (); } - inline operator void* () ZMQ_NOTHROW - { - return ptr; - } + inline operator void * () ZMQ_NOTHROW { return ptr; } - inline operator void const* () const ZMQ_NOTHROW - { - return ptr; - } + inline operator void const * () const ZMQ_NOTHROW { return ptr; } - inline void close() ZMQ_NOTHROW - { - if(ptr == NULL) - // already closed - return ; - int rc = zmq_close (ptr); - ZMQ_ASSERT (rc == 0); - ptr = 0 ; - } + inline void close () ZMQ_NOTHROW + { + if (ptr == NULL) + // already closed + return; + int rc = zmq_close (ptr); + ZMQ_ASSERT (rc == 0); + ptr = 0; + } - template void setsockopt(int option_, T const& optval) - { - setsockopt(option_, &optval, sizeof(T) ); - } + template void setsockopt (int option_, T const &optval) + { + setsockopt (option_, &optval, sizeof (T)); + } - inline void setsockopt (int option_, const void *optval_, - size_t optvallen_) - { - int rc = zmq_setsockopt (ptr, option_, optval_, optvallen_); - if (rc != 0) - throw error_t (); - } - - inline void getsockopt (int option_, void *optval_, - size_t *optvallen_) const - { - int rc = zmq_getsockopt (ptr, option_, optval_, optvallen_); - if (rc != 0) - throw error_t (); - } - - template T getsockopt(int option_) const - { - T optval; - size_t optlen = sizeof(T); - getsockopt(option_, &optval, &optlen ); - return optval; - } - - inline void bind(std::string const& addr) - { - bind(addr.c_str()); - } - - inline void bind (const char *addr_) - { - int rc = zmq_bind (ptr, addr_); - if (rc != 0) - throw error_t (); - } - - inline void unbind(std::string const& addr) - { - unbind(addr.c_str()); - } - - inline void unbind (const char *addr_) - { - int rc = zmq_unbind (ptr, addr_); - if (rc != 0) - throw error_t (); - } - - inline void connect(std::string const& addr) - { - connect(addr.c_str()); - } - - inline void connect (const char *addr_) - { - int rc = zmq_connect (ptr, addr_); - if (rc != 0) - throw error_t (); - } - - inline void disconnect(std::string const& addr) - { - disconnect(addr.c_str()); - } - - inline void disconnect (const char *addr_) - { - int rc = zmq_disconnect (ptr, addr_); - if (rc != 0) - throw error_t (); - } - - inline bool connected() const ZMQ_NOTHROW - { - return(ptr != NULL); - } - - inline size_t send (const void *buf_, size_t len_, int flags_ = 0) - { - int nbytes = zmq_send (ptr, buf_, len_, flags_); - if (nbytes >= 0) - return (size_t) nbytes; - if (zmq_errno () == EAGAIN) - return 0; + inline void setsockopt (int option_, const void *optval_, size_t optvallen_) + { + int rc = zmq_setsockopt (ptr, option_, optval_, optvallen_); + if (rc != 0) throw error_t (); - } + } - inline bool send (message_t &msg_, int flags_ = 0) - { - int nbytes = zmq_msg_send (&(msg_.msg), ptr, flags_); - if (nbytes >= 0) - return true; - if (zmq_errno () == EAGAIN) - return false; + inline void + getsockopt (int option_, void *optval_, size_t *optvallen_) const + { + int rc = zmq_getsockopt (ptr, option_, optval_, optvallen_); + if (rc != 0) throw error_t (); - } + } - template bool send(I first, I last, int flags_=0) - { - zmq::message_t msg(first, last); - return send(msg, flags_); - } + template T getsockopt (int option_) const + { + T optval; + size_t optlen = sizeof (T); + getsockopt (option_, &optval, &optlen); + return optval; + } + + inline void bind (std::string const &addr) { bind (addr.c_str ()); } + + inline void bind (const char *addr_) + { + int rc = zmq_bind (ptr, addr_); + if (rc != 0) + throw error_t (); + } + + inline void unbind (std::string const &addr) { unbind (addr.c_str ()); } + + inline void unbind (const char *addr_) + { + int rc = zmq_unbind (ptr, addr_); + if (rc != 0) + throw error_t (); + } + + inline void connect (std::string const &addr) { connect (addr.c_str ()); } + + inline void connect (const char *addr_) + { + int rc = zmq_connect (ptr, addr_); + if (rc != 0) + throw error_t (); + } + + inline void disconnect (std::string const &addr) + { + disconnect (addr.c_str ()); + } + + inline void disconnect (const char *addr_) + { + int rc = zmq_disconnect (ptr, addr_); + if (rc != 0) + throw error_t (); + } + + inline bool connected () const ZMQ_NOTHROW { return (ptr != NULL); } + + inline size_t send (const void *buf_, size_t len_, int flags_ = 0) + { + int nbytes = zmq_send (ptr, buf_, len_, flags_); + if (nbytes >= 0) + return (size_t) nbytes; + if (zmq_errno () == EAGAIN) + return 0; + throw error_t (); + } + + inline bool send (message_t &msg_, int flags_ = 0) + { + int nbytes = zmq_msg_send (&(msg_.msg), ptr, flags_); + if (nbytes >= 0) + return true; + if (zmq_errno () == EAGAIN) + return false; + throw error_t (); + } + + template bool send (I first, I last, int flags_ = 0) + { + zmq::message_t msg (first, last); + return send (msg, flags_); + } #ifdef ZMQ_HAS_RVALUE_REFS - inline bool send (message_t &&msg_, int flags_ = 0) - { - return send(msg_, flags_); - } + inline bool send (message_t &&msg_, int flags_ = 0) + { + return send (msg_, flags_); + } #endif - inline size_t recv (void *buf_, size_t len_, int flags_ = 0) - { - int nbytes = zmq_recv (ptr, buf_, len_, flags_); - if (nbytes >= 0) - return (size_t) nbytes; - if (zmq_errno () == EAGAIN) - return 0; - throw error_t (); - } - - inline bool recv (message_t *msg_, int flags_ = 0) - { - int nbytes = zmq_msg_recv (&(msg_->msg), ptr, flags_); - if (nbytes >= 0) - return true; - if (zmq_errno () == EAGAIN) - return false; - throw error_t (); - } - - private: - inline void init(context_t& context_, int type_) - { - ctxptr = context_.ptr; - ptr = zmq_socket (context_.ptr, type_ ); - if (ptr == NULL) - throw error_t (); - } - - void *ptr; - void *ctxptr; - - socket_t (const socket_t&) ZMQ_DELETED_FUNCTION; - void operator = (const socket_t&) ZMQ_DELETED_FUNCTION; - }; - - class monitor_t + inline size_t recv (void *buf_, size_t len_, int flags_ = 0) { - public: - monitor_t() : socketPtr(NULL), monitor_socket(NULL) {} + int nbytes = zmq_recv (ptr, buf_, len_, flags_); + if (nbytes >= 0) + return (size_t) nbytes; + if (zmq_errno () == EAGAIN) + return 0; + throw error_t (); + } - virtual ~monitor_t() - { - if (socketPtr) - zmq_socket_monitor(socketPtr, NULL, 0); + inline bool recv (message_t *msg_, int flags_ = 0) + { + int nbytes = zmq_msg_recv (&(msg_->msg), ptr, flags_); + if (nbytes >= 0) + return true; + if (zmq_errno () == EAGAIN) + return false; + throw error_t (); + } - if (monitor_socket) + private: + inline void init (context_t &context_, int type_) + { + ctxptr = context_.ptr; + ptr = zmq_socket (context_.ptr, type_); + if (ptr == NULL) + throw error_t (); + } + + void *ptr; + void *ctxptr; + + socket_t (const socket_t &) ZMQ_DELETED_FUNCTION; + void operator= (const socket_t &) ZMQ_DELETED_FUNCTION; +}; + +class monitor_t +{ + public: + monitor_t () : socketPtr (NULL), monitor_socket (NULL) {} + + virtual ~monitor_t () + { + if (socketPtr) + zmq_socket_monitor (socketPtr, NULL, 0); + + if (monitor_socket) zmq_close (monitor_socket); - - } + } #ifdef ZMQ_HAS_RVALUE_REFS - monitor_t(monitor_t&& rhs) ZMQ_NOTHROW : - socketPtr(rhs.socketPtr), - monitor_socket(rhs.monitor_socket) - { - rhs.socketPtr = NULL; - rhs.monitor_socket = NULL; - } + monitor_t (monitor_t &&rhs) ZMQ_NOTHROW + : socketPtr (rhs.socketPtr), + monitor_socket (rhs.monitor_socket) + { + rhs.socketPtr = NULL; + rhs.monitor_socket = NULL; + } - socket_t& operator=(socket_t&& rhs) ZMQ_DELETED_FUNCTION ; + socket_t &operator= (socket_t &&rhs) ZMQ_DELETED_FUNCTION; #endif + void monitor (socket_t &socket, + std::string const &addr, + int events = ZMQ_EVENT_ALL) + { + monitor (socket, addr.c_str (), events); + } - void monitor(socket_t &socket, std::string const& addr, int events = ZMQ_EVENT_ALL) - { - monitor(socket, addr.c_str(), events); + void + monitor (socket_t &socket, const char *addr_, int events = ZMQ_EVENT_ALL) + { + init (socket, addr_, events); + while (true) { + check_event (-1); } + } - void monitor(socket_t &socket, const char *addr_, int events = ZMQ_EVENT_ALL) - { - init (socket, addr_, events) ; - while(true) - { - check_event(-1) ; - } - } + void + init (socket_t &socket, std::string const &addr, int events = ZMQ_EVENT_ALL) + { + init (socket, addr.c_str (), events); + } - void init(socket_t &socket, std::string const& addr, int events = ZMQ_EVENT_ALL) - { - init(socket, addr.c_str(), events); - } + void init (socket_t &socket, const char *addr_, int events = ZMQ_EVENT_ALL) + { + int rc = zmq_socket_monitor (socket.ptr, addr_, events); + if (rc != 0) + throw error_t (); - void init(socket_t &socket, const char *addr_, int events = ZMQ_EVENT_ALL) - { - int rc = zmq_socket_monitor(socket.ptr, addr_, events); - if (rc != 0) - throw error_t (); + socketPtr = socket.ptr; + monitor_socket = zmq_socket (socket.ctxptr, ZMQ_PAIR); + assert (monitor_socket); - socketPtr = socket.ptr; - monitor_socket = zmq_socket (socket.ctxptr, ZMQ_PAIR); - assert (monitor_socket); + rc = zmq_connect (monitor_socket, addr_); + assert (rc == 0); - rc = zmq_connect (monitor_socket, addr_); - assert (rc == 0); + on_monitor_started (); + } - on_monitor_started(); - } + bool check_event (int timeout = 0) + { + assert (monitor_socket); - bool check_event(int timeout = 0) - { - assert (monitor_socket); + zmq_msg_t eventMsg; + zmq_msg_init (&eventMsg); - zmq_msg_t eventMsg; - zmq_msg_init (&eventMsg); + zmq::pollitem_t items[] = { + {monitor_socket, 0, ZMQ_POLLIN, 0}, + }; - zmq::pollitem_t items [] = { - { monitor_socket, 0, ZMQ_POLLIN, 0 }, - }; + zmq::poll (&items[0], 1, timeout); - zmq::poll (&items [0], 1, timeout); - - if (items [0].revents & ZMQ_POLLIN) - { - int rc = zmq_msg_recv (&eventMsg, monitor_socket, 0); - if (rc == -1 && zmq_errno() == ETERM) - return false; - assert (rc != -1); - - } - else - { - zmq_msg_close (&eventMsg); + if (items[0].revents & ZMQ_POLLIN) { + int rc = zmq_msg_recv (&eventMsg, monitor_socket, 0); + if (rc == -1 && zmq_errno () == ETERM) return false; - } + assert (rc != -1); + + } else { + zmq_msg_close (&eventMsg); + return false; + } #if ZMQ_VERSION_MAJOR >= 4 - const char* data = static_cast(zmq_msg_data(&eventMsg)); - zmq_event_t msgEvent; - memcpy(&msgEvent.event, data, sizeof(uint16_t)); data += sizeof(uint16_t); - memcpy(&msgEvent.value, data, sizeof(int32_t)); - zmq_event_t* event = &msgEvent; + const char *data = static_cast (zmq_msg_data (&eventMsg)); + zmq_event_t msgEvent; + memcpy (&msgEvent.event, data, sizeof (uint16_t)); + data += sizeof (uint16_t); + memcpy (&msgEvent.value, data, sizeof (int32_t)); + zmq_event_t *event = &msgEvent; #else - zmq_event_t* event = static_cast(zmq_msg_data(&eventMsg)); + zmq_event_t *event = + static_cast (zmq_msg_data (&eventMsg)); #endif #ifdef ZMQ_NEW_MONITOR_EVENT_LAYOUT - zmq_msg_t addrMsg; - zmq_msg_init (&addrMsg); - int rc = zmq_msg_recv (&addrMsg, monitor_socket, 0); - if (rc == -1 && zmq_errno() == ETERM) - { - zmq_msg_close (&eventMsg); - return false; - } + zmq_msg_t addrMsg; + zmq_msg_init (&addrMsg); + int rc = zmq_msg_recv (&addrMsg, monitor_socket, 0); + if (rc == -1 && zmq_errno () == ETERM) { + zmq_msg_close (&eventMsg); + return false; + } - assert (rc != -1); - const char* str = static_cast(zmq_msg_data (&addrMsg)); - std::string address(str, str + zmq_msg_size(&addrMsg)); - zmq_msg_close (&addrMsg); + assert (rc != -1); + const char *str = static_cast (zmq_msg_data (&addrMsg)); + std::string address (str, str + zmq_msg_size (&addrMsg)); + zmq_msg_close (&addrMsg); #else - // Bit of a hack, but all events in the zmq_event_t union have the same layout so this will work for all event types. - std::string address = event->data.connected.addr; + // Bit of a hack, but all events in the zmq_event_t union have the same layout so this will work for all event types. + std::string address = event->data.connected.addr; #endif #ifdef ZMQ_EVENT_MONITOR_STOPPED - if (event->event == ZMQ_EVENT_MONITOR_STOPPED) - { - zmq_msg_close (&eventMsg); - return true; - } + if (event->event == ZMQ_EVENT_MONITOR_STOPPED) { + zmq_msg_close (&eventMsg); + return true; + } #endif - switch (event->event) { + switch (event->event) { case ZMQ_EVENT_CONNECTED: - on_event_connected(*event, address.c_str()); + on_event_connected (*event, address.c_str ()); break; case ZMQ_EVENT_CONNECT_DELAYED: - on_event_connect_delayed(*event, address.c_str()); + on_event_connect_delayed (*event, address.c_str ()); break; case ZMQ_EVENT_CONNECT_RETRIED: - on_event_connect_retried(*event, address.c_str()); + on_event_connect_retried (*event, address.c_str ()); break; case ZMQ_EVENT_LISTENING: - on_event_listening(*event, address.c_str()); + on_event_listening (*event, address.c_str ()); break; case ZMQ_EVENT_BIND_FAILED: - on_event_bind_failed(*event, address.c_str()); + on_event_bind_failed (*event, address.c_str ()); break; case ZMQ_EVENT_ACCEPTED: - on_event_accepted(*event, address.c_str()); + on_event_accepted (*event, address.c_str ()); break; case ZMQ_EVENT_ACCEPT_FAILED: - on_event_accept_failed(*event, address.c_str()); + on_event_accept_failed (*event, address.c_str ()); break; case ZMQ_EVENT_CLOSED: - on_event_closed(*event, address.c_str()); + on_event_closed (*event, address.c_str ()); break; case ZMQ_EVENT_CLOSE_FAILED: - on_event_close_failed(*event, address.c_str()); + on_event_close_failed (*event, address.c_str ()); break; case ZMQ_EVENT_DISCONNECTED: - on_event_disconnected(*event, address.c_str()); + on_event_disconnected (*event, address.c_str ()); break; #ifdef ZMQ_BUILD_DRAFT_API #if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 3) case ZMQ_EVENT_HANDSHAKE_FAILED_NO_DETAIL: - on_event_handshake_failed_no_detail(*event, address.c_str()); + on_event_handshake_failed_no_detail (*event, address.c_str ()); break; case ZMQ_EVENT_HANDSHAKE_FAILED_PROTOCOL: - on_event_handshake_failed_protocol(*event, address.c_str()); + on_event_handshake_failed_protocol (*event, address.c_str ()); break; case ZMQ_EVENT_HANDSHAKE_FAILED_AUTH: - on_event_handshake_failed_auth(*event, address.c_str()); + on_event_handshake_failed_auth (*event, address.c_str ()); break; case ZMQ_EVENT_HANDSHAKE_SUCCEEDED: - on_event_handshake_succeeded(*event, address.c_str()); + on_event_handshake_succeeded (*event, address.c_str ()); break; #elif ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 1) case ZMQ_EVENT_HANDSHAKE_FAILED: - on_event_handshake_failed(*event, address.c_str()); + on_event_handshake_failed (*event, address.c_str ()); break; case ZMQ_EVENT_HANDSHAKE_SUCCEED: - on_event_handshake_succeed(*event, address.c_str()); + on_event_handshake_succeed (*event, address.c_str ()); break; #endif #endif default: - on_event_unknown(*event, address.c_str()); + on_event_unknown (*event, address.c_str ()); break; - } - zmq_msg_close (&eventMsg); - - return true ; } + zmq_msg_close (&eventMsg); + + return true; + } #ifdef ZMQ_EVENT_MONITOR_STOPPED - void abort() - { - if (socketPtr) - zmq_socket_monitor(socketPtr, NULL, 0); - - if (monitor_socket) - zmq_close (monitor_socket); - - socketPtr = NULL; - monitor_socket = NULL; - } -#endif - virtual void on_monitor_started() {} - virtual void on_event_connected(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; } - virtual void on_event_connect_delayed(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; } - virtual void on_event_connect_retried(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; } - virtual void on_event_listening(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; } - virtual void on_event_bind_failed(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; } - virtual void on_event_accepted(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; } - virtual void on_event_accept_failed(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; } - virtual void on_event_closed(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; } - virtual void on_event_close_failed(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; } - virtual void on_event_disconnected(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; } -#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 3) - virtual void on_event_handshake_failed_no_detail(const zmq_event_t &event_, const char* addr_) { (void) event_; (void) addr_; } - virtual void on_event_handshake_failed_protocol(const zmq_event_t &event_, const char* addr_) { (void) event_; (void) addr_; } - virtual void on_event_handshake_failed_auth(const zmq_event_t &event_, const char* addr_) { (void) event_; (void) addr_; } - virtual void on_event_handshake_succeeded(const zmq_event_t &event_, const char* addr_) { (void) event_; (void) addr_; } -#elif ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 1) - virtual void on_event_handshake_failed(const zmq_event_t &event_, const char* addr_) { (void) event_; (void) addr_; } - virtual void on_event_handshake_succeed(const zmq_event_t &event_, const char* addr_) { (void) event_; (void) addr_; } -#endif - virtual void on_event_unknown(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; } - private: - - monitor_t (const monitor_t&) ZMQ_DELETED_FUNCTION; - void operator = (const monitor_t&) ZMQ_DELETED_FUNCTION; - - void* socketPtr; - void *monitor_socket ; - }; - -#if defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) && defined(ZMQ_HAVE_POLLER) - template - class poller_t + void abort () { - public: - void add (zmq::socket_t &socket, short events, T *user_data) - { - if (0 != zmq_poller_add (poller_ptr.get (), static_cast(socket), user_data, events)) - { - throw error_t (); - } - } - - void remove (zmq::socket_t &socket) - { - if (0 != zmq_poller_remove (poller_ptr.get (), static_cast(socket))) - { - throw error_t (); - } - } + if (socketPtr) + zmq_socket_monitor (socketPtr, NULL, 0); - void modify (zmq::socket_t &socket, short events) - { - if (0 != zmq_poller_modify (poller_ptr.get (), static_cast(socket), events)) - { - throw error_t (); - } - } - - int wait_all (std::vector &poller_events, const std::chrono::microseconds timeout) - { - int rc = zmq_poller_wait_all (poller_ptr.get (), poller_events.data (), - static_cast (poller_events.size ()), - static_cast(timeout.count ())); - if (rc > 0) - return rc; + if (monitor_socket) + zmq_close (monitor_socket); -#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 3) - if (zmq_errno () == EAGAIN) -#else - if (zmq_errno () == ETIMEDOUT) + socketPtr = NULL; + monitor_socket = NULL; + } #endif - return 0; + virtual void on_monitor_started () {} + virtual void on_event_connected (const zmq_event_t &event_, + const char *addr_) + { + (void) event_; + (void) addr_; + } + virtual void on_event_connect_delayed (const zmq_event_t &event_, + const char *addr_) + { + (void) event_; + (void) addr_; + } + virtual void on_event_connect_retried (const zmq_event_t &event_, + const char *addr_) + { + (void) event_; + (void) addr_; + } + virtual void on_event_listening (const zmq_event_t &event_, + const char *addr_) + { + (void) event_; + (void) addr_; + } + virtual void on_event_bind_failed (const zmq_event_t &event_, + const char *addr_) + { + (void) event_; + (void) addr_; + } + virtual void on_event_accepted (const zmq_event_t &event_, + const char *addr_) + { + (void) event_; + (void) addr_; + } + virtual void on_event_accept_failed (const zmq_event_t &event_, + const char *addr_) + { + (void) event_; + (void) addr_; + } + virtual void on_event_closed (const zmq_event_t &event_, const char *addr_) + { + (void) event_; + (void) addr_; + } + virtual void on_event_close_failed (const zmq_event_t &event_, + const char *addr_) + { + (void) event_; + (void) addr_; + } + virtual void on_event_disconnected (const zmq_event_t &event_, + const char *addr_) + { + (void) event_; + (void) addr_; + } +#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 3) + virtual void on_event_handshake_failed_no_detail (const zmq_event_t &event_, + const char *addr_) + { + (void) event_; + (void) addr_; + } + virtual void on_event_handshake_failed_protocol (const zmq_event_t &event_, + const char *addr_) + { + (void) event_; + (void) addr_; + } + virtual void on_event_handshake_failed_auth (const zmq_event_t &event_, + const char *addr_) + { + (void) event_; + (void) addr_; + } + virtual void on_event_handshake_succeeded (const zmq_event_t &event_, + const char *addr_) + { + (void) event_; + (void) addr_; + } +#elif ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 1) + virtual void on_event_handshake_failed (const zmq_event_t &event_, + const char *addr_) + { + (void) event_; + (void) addr_; + } + virtual void on_event_handshake_succeed (const zmq_event_t &event_, + const char *addr_) + { + (void) event_; + (void) addr_; + } +#endif + virtual void on_event_unknown (const zmq_event_t &event_, const char *addr_) + { + (void) event_; + (void) addr_; + } + private: + monitor_t (const monitor_t &) ZMQ_DELETED_FUNCTION; + void operator= (const monitor_t &) ZMQ_DELETED_FUNCTION; + + void *socketPtr; + void *monitor_socket; +}; + +#if defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) \ + && defined(ZMQ_HAVE_POLLER) +template class poller_t +{ + public: + void add (zmq::socket_t &socket, short events, T *user_data) + { + if (0 + != zmq_poller_add (poller_ptr.get (), static_cast (socket), + user_data, events)) { throw error_t (); } - private: - std::unique_ptr> poller_ptr - { - []() { - auto poller_new = zmq_poller_new (); - if (poller_new) - return poller_new; - throw error_t (); - }(), - [](void *ptr) { - int rc = zmq_poller_destroy (&ptr); - ZMQ_ASSERT (rc == 0); - } - }; - }; + } + + void remove (zmq::socket_t &socket) + { + if (0 + != zmq_poller_remove (poller_ptr.get (), + static_cast (socket))) { + throw error_t (); + } + } + + void modify (zmq::socket_t &socket, short events) + { + if (0 + != zmq_poller_modify (poller_ptr.get (), + static_cast (socket), events)) { + throw error_t (); + } + } + + int wait_all (std::vector &poller_events, + const std::chrono::microseconds timeout) + { + int rc = zmq_poller_wait_all (poller_ptr.get (), poller_events.data (), + static_cast (poller_events.size ()), + static_cast (timeout.count ())); + if (rc > 0) + return rc; + +#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 3) + if (zmq_errno () == EAGAIN) +#else + if (zmq_errno () == ETIMEDOUT) +#endif + return 0; + + throw error_t (); + } + + private: + std::unique_ptr> poller_ptr{ + []() { + auto poller_new = zmq_poller_new (); + if (poller_new) + return poller_new; + throw error_t (); + }(), + [](void *ptr) { + int rc = zmq_poller_destroy (&ptr); + ZMQ_ASSERT (rc == 0); + }}; +}; #endif // defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) && defined(ZMQ_HAVE_POLLER) -inline std::ostream& operator<<(std::ostream& os, const message_t& msg) +inline std::ostream &operator<< (std::ostream &os, const message_t &msg) { - return os << msg.str(); + return os << msg.str (); } -} // namespace zmq +} // namespace zmq -#endif // __ZMQ_HPP_INCLUDED__ +#endif // __ZMQ_HPP_INCLUDED__