generic-library/cppzmq
1
0
Fork 0
mirror of https://github.com/zeromq/cppzmq.git synced 2024-12-13 10:52:57 +01:00
Code Issues Projects Releases Wiki Activity

Problem: whitespace style too restrictive.

Browse Source 
For header only library like cppzmq, whitespace style inherited from
libzmq is too restrictive.

Solution: relaxing whitespace before parens from always to in control
statements only, increased max column width from 80 to 85 and removing
requirement of whitespace after template keyword.
This commit is contained in:
Pawel Kurdybacha 2018-05-12 17:28:28 +01:00
parent 590cf711e5
commit ff3c221516
12 changed files with 932 additions and 993 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
.clang-format
View File

@ -26,14 +26,14 @@ AllowShortBlocksOnASingleLine: false
AllowAllParametersOfDeclarationOnNextLine: true AllowAllParametersOfDeclarationOnNextLine: true
AllowShortFunctionsOnASingleLine: InlineOnly AllowShortFunctionsOnASingleLine: InlineOnly
AlwaysBreakTemplateDeclarations: false AlwaysBreakTemplateDeclarations: false
ColumnLimit: 80 ColumnLimit: 85
MaxEmptyLinesToKeep: 2 MaxEmptyLinesToKeep: 2
KeepEmptyLinesAtTheStartOfBlocks: false KeepEmptyLinesAtTheStartOfBlocks: false
ContinuationIndentWidth: 2 ContinuationIndentWidth: 2
PointerAlignment: Right PointerAlignment: Right
ReflowComments: false ReflowComments: false
SpaceBeforeAssignmentOperators: true SpaceBeforeAssignmentOperators: true
SpaceBeforeParens: Always SpaceBeforeParens: ControlStatements
SpaceInEmptyParentheses: false SpaceInEmptyParentheses: false
SpacesInAngles: false SpacesInAngles: false
SpacesInParentheses: false SpacesInParentheses: false
@ -44,7 +44,7 @@ SortIncludes: false
FixNamespaceComments: false FixNamespaceComments: false
BreakBeforeBinaryOperators: NonAssignment BreakBeforeBinaryOperators: NonAssignment
SpaceAfterTemplateKeyword: true SpaceAfterTemplateKeyword: false
AlignAfterOpenBracket: Align AlignAfterOpenBracket: Align
AlignOperands: true AlignOperands: true
BreakConstructorInitializers: AfterColon BreakConstructorInitializers: AfterColon

2
demo/main.cpp
View File

@ -1,6 +1,6 @@
#include <zmq.hpp> #include <zmq.hpp>
int main (int argc, char **argv) int main(int argc, char **argv)
{ {
zmq::context_t context; zmq::context_t context;
return 0; return 0;

308
tests/active_poller.cpp
View File

@ -7,83 +7,83 @@
#include <array> #include <array>
#include <memory> #include <memory>
TEST (active_poller, create_destroy) TEST(active_poller, create_destroy)
{ {
zmq::active_poller_t active_poller; zmq::active_poller_t active_poller;
ASSERT_TRUE (active_poller.empty ()); ASSERT_TRUE(active_poller.empty());
} }
static_assert (!std::is_copy_constructible<zmq::active_poller_t>::value, static_assert(!std::is_copy_constructible<zmq::active_poller_t>::value,
"active_active_poller_t should not be copy-constructible"); "active_active_poller_t should not be copy-constructible");
static_assert (!std::is_copy_assignable<zmq::active_poller_t>::value, static_assert(!std::is_copy_assignable<zmq::active_poller_t>::value,
"active_active_poller_t should not be copy-assignable"); "active_active_poller_t should not be copy-assignable");
TEST (active_poller, move_construct_empty) TEST(active_poller, move_construct_empty)
{ {
zmq::active_poller_t a; zmq::active_poller_t a;
ASSERT_TRUE (a.empty ()); ASSERT_TRUE(a.empty());
zmq::active_poller_t b = std::move (a); zmq::active_poller_t b = std::move(a);
ASSERT_TRUE (b.empty ()); ASSERT_TRUE(b.empty());
ASSERT_EQ (0u, a.size ()); ASSERT_EQ(0u, a.size());
ASSERT_EQ (0u, b.size ()); ASSERT_EQ(0u, b.size());
} }
TEST (active_poller, move_assign_empty) TEST(active_poller, move_assign_empty)
{ {
zmq::active_poller_t a; zmq::active_poller_t a;
ASSERT_TRUE (a.empty ()); ASSERT_TRUE(a.empty());
zmq::active_poller_t b; zmq::active_poller_t b;
ASSERT_TRUE (b.empty ()); ASSERT_TRUE(b.empty());
b = std::move (a); b = std::move(a);
ASSERT_EQ (0u, a.size ()); ASSERT_EQ(0u, a.size());
ASSERT_EQ (0u, b.size ()); ASSERT_EQ(0u, b.size());
ASSERT_TRUE (a.empty ()); ASSERT_TRUE(a.empty());
ASSERT_TRUE (b.empty ()); ASSERT_TRUE(b.empty());
} }
TEST (active_poller, move_construct_non_empty) TEST(active_poller, move_construct_non_empty)
{ {
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 a; zmq::active_poller_t a;
a.add (socket, ZMQ_POLLIN, [](short) {}); a.add(socket, ZMQ_POLLIN, [](short) {});
ASSERT_FALSE (a.empty ()); ASSERT_FALSE(a.empty());
ASSERT_EQ (1u, a.size ()); ASSERT_EQ(1u, a.size());
zmq::active_poller_t b = std::move (a); zmq::active_poller_t b = std::move(a);
ASSERT_TRUE (a.empty ()); ASSERT_TRUE(a.empty());
ASSERT_EQ (0u, a.size ()); ASSERT_EQ(0u, a.size());
ASSERT_FALSE (b.empty ()); ASSERT_FALSE(b.empty());
ASSERT_EQ (1u, b.size ()); ASSERT_EQ(1u, b.size());
} }
TEST (active_poller, move_assign_non_empty) TEST(active_poller, move_assign_non_empty)
{ {
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 a; zmq::active_poller_t a;
a.add (socket, ZMQ_POLLIN, [](short) {}); a.add(socket, ZMQ_POLLIN, [](short) {});
ASSERT_FALSE (a.empty ()); ASSERT_FALSE(a.empty());
ASSERT_EQ (1u, a.size ()); ASSERT_EQ(1u, a.size());
zmq::active_poller_t b; zmq::active_poller_t b;
b = std::move (a); b = std::move(a);
ASSERT_TRUE (a.empty ()); ASSERT_TRUE(a.empty());
ASSERT_EQ (0u, a.size ()); ASSERT_EQ(0u, a.size());
ASSERT_FALSE (b.empty ()); ASSERT_FALSE(b.empty());
ASSERT_EQ (1u, b.size ()); ASSERT_EQ(1u, b.size());
} }
TEST (active_poller, add_handler) TEST(active_poller, add_handler)
{ {
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;
zmq::active_poller_t::handler_t handler; 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: /// checked by zmq_poller_add/modify in libzmq:
@ -93,56 +93,54 @@ TEST (active_poller, add_handler_invalid_events_type)
zmq::active_poller_t active_poller; zmq::active_poller_t active_poller;
zmq::active_poller_t::handler_t handler; zmq::active_poller_t::handler_t handler;
short invalid_events_type = 2 << 10; short invalid_events_type = 2 << 10;
ASSERT_NO_THROW (active_poller.add (socket, invalid_events_type, handler)); ASSERT_NO_THROW(active_poller.add(socket, invalid_events_type, handler));
ASSERT_FALSE (active_poller.empty ()); ASSERT_FALSE(active_poller.empty());
ASSERT_EQ (1u, active_poller.size ()); 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::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;
zmq::active_poller_t::handler_t handler; 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 /// \todo the actual error code should be checked
ASSERT_THROW (active_poller.add (socket, ZMQ_POLLIN, handler), ASSERT_THROW(active_poller.add(socket, ZMQ_POLLIN, handler), zmq::error_t);
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; zmq::active_poller_t active_poller;
/// \todo the actual error code should be checked /// \todo the actual error code should be checked
ASSERT_THROW (active_poller.wait (std::chrono::milliseconds{10}), ASSERT_THROW(active_poller.wait(std::chrono::milliseconds{10}), zmq::error_t);
zmq::error_t);
} }
TEST (active_poller, remove_unregistered_throws) TEST(active_poller, remove_unregistered_throws)
{ {
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;
/// \todo the actual error code should be checked /// \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::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_POLLIN, zmq::active_poller_t::handler_t{}); active_poller.add(socket, ZMQ_POLLIN, zmq::active_poller_t::handler_t{});
ASSERT_NO_THROW (active_poller.remove (socket)); 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::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_POLLIN, [](short) {}); active_poller.add(socket, ZMQ_POLLIN, [](short) {});
ASSERT_NO_THROW (active_poller.remove (socket)); ASSERT_NO_THROW(active_poller.remove(socket));
} }
namespace namespace
@ -155,26 +153,25 @@ struct server_client_setup : common_server_client_setup
}; };
} }
TEST (active_poller, poll_basic) TEST(active_poller, poll_basic)
{ {
server_client_setup s; server_client_setup s;
ASSERT_NO_THROW (s.client.send ("Hi")); ASSERT_NO_THROW(s.client.send("Hi"));
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_t handler = zmq::active_poller_t::handler_t handler = [&message_received](short events) {
[&message_received](short events) { ASSERT_TRUE(0 != (events & ZMQ_POLLIN));
ASSERT_TRUE (0 != (events & ZMQ_POLLIN));
message_received = true; message_received = true;
}; };
ASSERT_NO_THROW (active_poller.add (s.server, ZMQ_POLLIN, handler)); ASSERT_NO_THROW(active_poller.add(s.server, ZMQ_POLLIN, handler));
ASSERT_EQ (1, active_poller.wait (std::chrono::milliseconds{-1})); ASSERT_EQ(1, active_poller.wait(std::chrono::milliseconds{-1}));
ASSERT_TRUE (message_received); ASSERT_TRUE(message_received);
} }
/// \todo this contains multiple test cases that should be split up /// \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"; const std::string send_msg = "Hi";
@ -187,127 +184,125 @@ TEST (active_poller, client_server)
zmq::active_poller_t::handler_t handler = [&](short e) { zmq::active_poller_t::handler_t handler = [&](short e) {
if (0 != (e & ZMQ_POLLIN)) { if (0 != (e & ZMQ_POLLIN)) {
zmq::message_t zmq_msg; zmq::message_t zmq_msg;
ASSERT_NO_THROW (s.server.recv (&zmq_msg)); // get message ASSERT_NO_THROW(s.server.recv(&zmq_msg)); // get message
std::string recv_msg (zmq_msg.data<char> (), zmq_msg.size ()); std::string recv_msg(zmq_msg.data<char>(), zmq_msg.size());
ASSERT_EQ (send_msg, recv_msg); ASSERT_EQ(send_msg, recv_msg);
} else if (0 != (e & ~ZMQ_POLLOUT)) { } else if (0 != (e & ~ZMQ_POLLOUT)) {
ASSERT_TRUE (false) << "Unexpected event type " << events; ASSERT_TRUE(false) << "Unexpected event type " << events;
} }
events = e; 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 // 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(1, active_poller.wait(std::chrono::milliseconds{-1}));
ASSERT_EQ (events, ZMQ_POLLIN); ASSERT_EQ(events, ZMQ_POLLIN);
// Re-add server socket with pollout flag // Re-add server socket with pollout flag
ASSERT_NO_THROW (active_poller.remove (s.server)); ASSERT_NO_THROW(active_poller.remove(s.server));
ASSERT_NO_THROW ( ASSERT_NO_THROW(active_poller.add(s.server, ZMQ_POLLIN | ZMQ_POLLOUT, handler));
active_poller.add (s.server, ZMQ_POLLIN | ZMQ_POLLOUT, handler)); ASSERT_EQ(1, active_poller.wait(std::chrono::milliseconds{-1}));
ASSERT_EQ (1, active_poller.wait (std::chrono::milliseconds{-1})); ASSERT_EQ(events, ZMQ_POLLOUT);
ASSERT_EQ (events, ZMQ_POLLOUT);
} }
TEST (active_poller, add_invalid_socket_throws) TEST(active_poller, add_invalid_socket_throws)
{ {
zmq::context_t context; zmq::context_t context;
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)};
ASSERT_THROW ( ASSERT_THROW(active_poller.add(a, ZMQ_POLLIN, zmq::active_poller_t::handler_t{}),
active_poller.add (a, ZMQ_POLLIN, zmq::active_poller_t::handler_t{}),
zmq::error_t); zmq::error_t);
} }
TEST (active_poller, remove_invalid_socket_throws) TEST(active_poller, remove_invalid_socket_throws)
{ {
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;
ASSERT_NO_THROW (active_poller.add (socket, ZMQ_POLLIN, ASSERT_NO_THROW(
zmq::active_poller_t::handler_t{})); active_poller.add(socket, ZMQ_POLLIN, zmq::active_poller_t::handler_t{}));
ASSERT_EQ (1u, active_poller.size ()); ASSERT_EQ(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));
ASSERT_THROW (active_poller.remove (socket), zmq::error_t); ASSERT_THROW(active_poller.remove(socket), zmq::error_t);
ASSERT_EQ (1u, active_poller.size ()); 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; server_client_setup s;
ASSERT_NO_THROW (s.client.send ("Hi")); ASSERT_NO_THROW(s.client.send("Hi"));
zmq::active_poller_t active_poller; zmq::active_poller_t active_poller;
zmq::active_poller_t::handler_t handler; zmq::active_poller_t::handler_t handler;
ASSERT_NO_THROW (active_poller.add (s.server, ZMQ_POLLIN, 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::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;
ASSERT_THROW (active_poller.modify (socket, ZMQ_POLLIN), zmq::error_t); 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::context_t context;
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;
ASSERT_THROW (active_poller.modify (a, ZMQ_POLLIN), zmq::error_t); 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::context_t context;
zmq::socket_t a{context, zmq::socket_type::push}; zmq::socket_t a{context, zmq::socket_type::push};
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;
ASSERT_NO_THROW ( ASSERT_NO_THROW(
active_poller.add (a, ZMQ_POLLIN, zmq::active_poller_t::handler_t{})); active_poller.add(a, ZMQ_POLLIN, zmq::active_poller_t::handler_t{}));
ASSERT_THROW (active_poller.modify (b, ZMQ_POLLIN), zmq::error_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::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; zmq::active_poller_t active_poller;
ASSERT_NO_THROW ( ASSERT_NO_THROW(
active_poller.add (a, ZMQ_POLLIN, zmq::active_poller_t::handler_t{})); 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.modify(a, ZMQ_POLLIN | ZMQ_POLLOUT));
} }
TEST (active_poller, poll_client_server) TEST(active_poller, poll_client_server)
{ {
// Setup server and client // Setup server and client
server_client_setup s; server_client_setup s;
// Setup active_poller // Setup active_poller
zmq::active_poller_t 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 // client sends message
ASSERT_NO_THROW (s.client.send ("Hi")); ASSERT_NO_THROW(s.client.send("Hi"));
// wait for message and verify events // wait for message and verify events
ASSERT_NO_THROW (active_poller.wait (std::chrono::milliseconds{500})); ASSERT_NO_THROW(active_poller.wait(std::chrono::milliseconds{500}));
ASSERT_EQ (s.events, ZMQ_POLLIN); ASSERT_EQ(s.events, ZMQ_POLLIN);
// Modify server socket with pollout flag // Modify server socket with pollout flag
ASSERT_NO_THROW (active_poller.modify (s.server, 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(1, active_poller.wait(std::chrono::milliseconds{500}));
ASSERT_EQ (s.events, ZMQ_POLLIN | ZMQ_POLLOUT); ASSERT_EQ(s.events, ZMQ_POLLIN | ZMQ_POLLOUT);
} }
TEST (active_poller, wait_one_return) TEST(active_poller, wait_one_return)
{ {
// Setup server and client // Setup server and client
server_client_setup s; server_client_setup s;
@ -316,106 +311,105 @@ TEST (active_poller, wait_one_return)
// Setup active_poller // Setup active_poller
zmq::active_poller_t active_poller; zmq::active_poller_t active_poller;
ASSERT_NO_THROW ( ASSERT_NO_THROW(
active_poller.add (s.server, ZMQ_POLLIN, [&count](short) { ++count; })); active_poller.add(s.server, ZMQ_POLLIN, [&count](short) { ++count; }));
// client sends message // client sends message
ASSERT_NO_THROW (s.client.send ("Hi")); ASSERT_NO_THROW(s.client.send("Hi"));
// wait for message and verify events // wait for message and verify events
ASSERT_EQ (1, active_poller.wait (std::chrono::milliseconds{500})); ASSERT_EQ(1, active_poller.wait(std::chrono::milliseconds{500}));
ASSERT_EQ (1u, count); 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; server_client_setup s;
ASSERT_NO_THROW (s.client.send ("Hi")); ASSERT_NO_THROW(s.client.send("Hi"));
zmq::active_poller_t a; zmq::active_poller_t a;
zmq::active_poller_t::handler_t handler; zmq::active_poller_t::handler_t handler;
ASSERT_NO_THROW (a.add (s.server, ZMQ_POLLIN, handler)); ASSERT_NO_THROW(a.add(s.server, ZMQ_POLLIN, handler));
zmq::active_poller_t b{std::move (a)}; zmq::active_poller_t b{std::move(a)};
ASSERT_EQ (1u, b.size ()); ASSERT_EQ(1u, b.size());
/// \todo the actual error code should be checked /// \todo the actual error code should be checked
ASSERT_THROW (a.wait (std::chrono::milliseconds{10}), zmq::error_t); ASSERT_THROW(a.wait(std::chrono::milliseconds{10}), zmq::error_t);
ASSERT_TRUE (b.wait (std::chrono::milliseconds{-1})); 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; server_client_setup s;
ASSERT_NO_THROW (s.client.send ("Hi")); ASSERT_NO_THROW(s.client.send("Hi"));
zmq::active_poller_t a; zmq::active_poller_t a;
zmq::active_poller_t::handler_t handler; zmq::active_poller_t::handler_t handler;
ASSERT_NO_THROW (a.add (s.server, ZMQ_POLLIN, handler)); ASSERT_NO_THROW(a.add(s.server, ZMQ_POLLIN, handler));
zmq::active_poller_t b; zmq::active_poller_t b;
b = {std::move (a)}; b = {std::move(a)};
ASSERT_EQ (1u, b.size ()); ASSERT_EQ(1u, b.size());
/// \todo the actual error code should be checked /// \todo the actual error code should be checked
ASSERT_THROW (a.wait (std::chrono::milliseconds{10}), zmq::error_t); ASSERT_THROW(a.wait(std::chrono::milliseconds{10}), zmq::error_t);
ASSERT_TRUE (b.wait (std::chrono::milliseconds{-1})); 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 // Setup server and client
server_client_setup s; server_client_setup s;
int count = 0; int count = 0;
// Setup active_poller a // Setup active_poller a
zmq::active_poller_t a; zmq::active_poller_t a;
ASSERT_NO_THROW ( ASSERT_NO_THROW(a.add(s.server, ZMQ_POLLIN, [&count](short) { ++count; }));
a.add (s.server, ZMQ_POLLIN, [&count](short) { ++count; }));
// client sends message // 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 // wait for message and verify it is received
ASSERT_EQ (1, a.wait (std::chrono::milliseconds{500})); ASSERT_EQ(1, a.wait(std::chrono::milliseconds{500}));
ASSERT_EQ (1u, count); ASSERT_EQ(1u, count);
// Move construct active_poller b // 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 // 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 // wait for message and verify it is received
ASSERT_EQ (1, b.wait (std::chrono::milliseconds{500})); ASSERT_EQ(1, b.wait(std::chrono::milliseconds{500}));
ASSERT_EQ (2u, count); ASSERT_EQ(2u, count);
} }
TEST (active_poller, remove_from_handler) TEST(active_poller, remove_from_handler)
{ {
constexpr auto ITER_NO = 10; constexpr auto ITER_NO = 10;
// Setup servers and clients // Setup servers and clients
std::vector<server_client_setup> setup_list; std::vector<server_client_setup> setup_list;
for (auto i = 0; i < ITER_NO; ++i) for (auto i = 0; i < ITER_NO; ++i)
setup_list.emplace_back (server_client_setup{}); setup_list.emplace_back(server_client_setup{});
// Setup active_poller // Setup active_poller
zmq::active_poller_t active_poller; zmq::active_poller_t active_poller;
int count = 0; int count = 0;
for (auto i = 0; i < ITER_NO; ++i) { for (auto i = 0; i < ITER_NO; ++i) {
ASSERT_NO_THROW (active_poller.add ( ASSERT_NO_THROW(
setup_list[i].server, ZMQ_POLLIN, [&, i](short events) { active_poller.add(setup_list[i].server, ZMQ_POLLIN, [&, i](short events) {
ASSERT_EQ (events, ZMQ_POLLIN); ASSERT_EQ(events, ZMQ_POLLIN);
active_poller.remove (setup_list[ITER_NO - i - 1].server); active_poller.remove(setup_list[ITER_NO - i - 1].server);
ASSERT_EQ (ITER_NO - i - 1, active_poller.size ()); ASSERT_EQ(ITER_NO - i - 1, active_poller.size());
})); }));
++count; ++count;
} }
ASSERT_EQ (ITER_NO, active_poller.size ()); ASSERT_EQ(ITER_NO, active_poller.size());
// Clients send messages // Clients send messages
for (auto &s : setup_list) { for (auto &s : setup_list) {
ASSERT_NO_THROW (s.client.send ("Hi")); ASSERT_NO_THROW(s.client.send("Hi"));
} }
// Wait for all servers to receive a message // Wait for all servers to receive a message
for (auto &s : setup_list) { for (auto &s : setup_list) {
zmq::pollitem_t items[] = {{s.server, 0, ZMQ_POLLIN, 0}}; zmq::pollitem_t items[] = {{s.server, 0, ZMQ_POLLIN, 0}};
zmq::poll (&items[0], 1); zmq::poll(&items[0], 1);
} }
// Fire all handlers in one wait // Fire all handlers in one wait
ASSERT_EQ (ITER_NO, active_poller.wait (std::chrono::milliseconds{-1})); ASSERT_EQ(ITER_NO, active_poller.wait(std::chrono::milliseconds{-1}));
ASSERT_EQ (ITER_NO, count); ASSERT_EQ(ITER_NO, count);
} }
#endif #endif

8
tests/context.cpp
View File

@ -1,15 +1,15 @@
#include <gtest/gtest.h> #include <gtest/gtest.h>
#include <zmq.hpp> #include <zmq.hpp>
TEST (context, create_default_destroy) TEST(context, create_default_destroy)
{ {
zmq::context_t context; zmq::context_t context;
} }
TEST (context, create_close) TEST(context, create_close)
{ {
zmq::context_t context; zmq::context_t context;
context.close (); context.close();
ASSERT_EQ (NULL, (void *) context); ASSERT_EQ(NULL, (void *) context);
} }

6
tests/main.cpp
View File

@ -1,7 +1,7 @@
#include "gtest/gtest.h" #include "gtest/gtest.h"
int main (int argc, char **argv) int main(int argc, char **argv)
{ {
::testing::InitGoogleTest (&argc, argv); ::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS (); return RUN_ALL_TESTS();
} }

110
tests/message.cpp
View File

@ -2,119 +2,119 @@
#include <zmq.hpp> #include <zmq.hpp>
#if defined(ZMQ_CPP11) #if defined(ZMQ_CPP11)
static_assert (!std::is_copy_constructible<zmq::message_t>::value, static_assert(!std::is_copy_constructible<zmq::message_t>::value,
"message_t should not be copy-constructible"); "message_t should not be copy-constructible");
static_assert (!std::is_copy_assignable<zmq::message_t>::value, static_assert(!std::is_copy_assignable<zmq::message_t>::value,
"message_t should not be copy-assignable"); "message_t should not be copy-assignable");
#endif #endif
TEST (message, constructor_default) TEST(message, constructor_default)
{ {
const zmq::message_t message; const zmq::message_t message;
ASSERT_EQ (0u, message.size ()); ASSERT_EQ(0u, message.size());
} }
const char *const data = "Hi"; const char *const data = "Hi";
TEST (message, constructor_iterators) TEST(message, constructor_iterators)
{ {
const std::string hi (data); const std::string hi(data);
const zmq::message_t hi_msg (hi.begin (), hi.end ()); const zmq::message_t hi_msg(hi.begin(), hi.end());
ASSERT_EQ (2u, hi_msg.size ()); ASSERT_EQ(2u, hi_msg.size());
ASSERT_EQ (0, memcmp (data, hi_msg.data (), 2)); ASSERT_EQ(0, memcmp(data, hi_msg.data(), 2));
} }
TEST (message, constructor_pointer_size) TEST(message, constructor_pointer_size)
{ {
const std::string hi (data); const std::string hi(data);
const zmq::message_t hi_msg (hi.data (), hi.size ()); const zmq::message_t hi_msg(hi.data(), hi.size());
ASSERT_EQ (2u, hi_msg.size ()); ASSERT_EQ(2u, hi_msg.size());
ASSERT_EQ (0, memcmp (data, hi_msg.data (), 2)); 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)); const zmq::message_t hi_msg(data, strlen(data));
ASSERT_EQ (2u, hi_msg.size ()); ASSERT_EQ(2u, hi_msg.size());
ASSERT_EQ (0, memcmp (data, hi_msg.data (), 2)); ASSERT_EQ(0, memcmp(data, hi_msg.data(), 2));
} }
#if defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) #if defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11)
TEST (message, constructor_container) TEST(message, constructor_container)
{ {
const std::string hi (data); const std::string hi(data);
zmq::message_t hi_msg (hi); zmq::message_t hi_msg(hi);
ASSERT_EQ (2u, hi_msg.size ()); ASSERT_EQ(2u, hi_msg.size());
ASSERT_EQ (0, memcmp (data, hi_msg.data (), 2)); ASSERT_EQ(0, memcmp(data, hi_msg.data(), 2));
} }
#endif #endif
#ifdef ZMQ_HAS_RVALUE_REFS #ifdef ZMQ_HAS_RVALUE_REFS
TEST (message, constructor_move) 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) TEST(message, assign_move_empty_before)
{ {
zmq::message_t hi_msg; zmq::message_t hi_msg;
hi_msg = zmq::message_t (data, strlen (data)); hi_msg = zmq::message_t(data, strlen(data));
ASSERT_EQ (2u, hi_msg.size ()); ASSERT_EQ(2u, hi_msg.size());
ASSERT_EQ (0, memcmp (data, hi_msg.data (), 2)); ASSERT_EQ(0, memcmp(data, hi_msg.data(), 2));
} }
TEST (message, assign_move_empty_after) TEST(message, assign_move_empty_after)
{ {
zmq::message_t hi_msg (data, strlen (data)); zmq::message_t hi_msg(data, strlen(data));
hi_msg = zmq::message_t (); hi_msg = zmq::message_t();
ASSERT_EQ (0u, hi_msg.size ()); ASSERT_EQ(0u, hi_msg.size());
} }
TEST (message, assign_move_empty_before_and_after) TEST(message, assign_move_empty_before_and_after)
{ {
zmq::message_t hi_msg; zmq::message_t hi_msg;
hi_msg = zmq::message_t (); hi_msg = zmq::message_t();
ASSERT_EQ (0u, hi_msg.size ()); ASSERT_EQ(0u, hi_msg.size());
} }
#endif #endif
TEST (message, equality_self) TEST(message, equality_self)
{ {
const zmq::message_t hi_msg (data, strlen (data)); const zmq::message_t hi_msg(data, strlen(data));
ASSERT_EQ (hi_msg, hi_msg); 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_a(data, strlen(data));
const zmq::message_t hi_msg_b (data, strlen (data)); const zmq::message_t hi_msg_b(data, strlen(data));
ASSERT_EQ (hi_msg_a, hi_msg_b); 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_a;
const zmq::message_t msg_b; const zmq::message_t msg_b;
ASSERT_EQ (msg_a, 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_a("Hi", 2);
const zmq::message_t msg_b ("Hello", 5); const zmq::message_t msg_b("Hello", 5);
ASSERT_NE (msg_a, msg_b); 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_a("Hi", 2);
const zmq::message_t msg_b; const zmq::message_t msg_b;
ASSERT_NE (msg_a, 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_a;
const zmq::message_t msg_b ("Hi", 2); const zmq::message_t msg_b("Hi", 2);
ASSERT_NE (msg_a, msg_b); ASSERT_NE(msg_a, msg_b);
} }

230
tests/multipart.cpp
View File

@ -4,7 +4,7 @@
#ifdef ZMQ_HAS_RVALUE_REFS #ifdef ZMQ_HAS_RVALUE_REFS
/// \todo split this up into separate test cases /// \todo split this up into separate test cases
/// ///
TEST (multipart, legacy_test) TEST(multipart, legacy_test)
{ {
using namespace zmq; using namespace zmq;
@ -16,158 +16,158 @@ TEST (multipart, legacy_test)
message_t msg; message_t msg;
// Create two PAIR sockets and connect over inproc // Create two PAIR sockets and connect over inproc
context_t context (1); context_t context(1);
socket_t output (context, ZMQ_PAIR); socket_t output(context, ZMQ_PAIR);
socket_t input (context, ZMQ_PAIR); socket_t input(context, ZMQ_PAIR);
output.bind ("inproc://multipart.test"); output.bind("inproc://multipart.test");
input.connect ("inproc://multipart.test"); input.connect("inproc://multipart.test");
// Test send and receive of single-frame message // Test send and receive of single-frame message
multipart_t multipart; multipart_t multipart;
assert (multipart.empty ()); assert(multipart.empty());
multipart.push (message_t ("Hello", 5)); multipart.push(message_t("Hello", 5));
assert (multipart.size () == 1); assert(multipart.size() == 1);
ok = multipart.send (output); ok = multipart.send(output);
assert (multipart.empty ()); assert(multipart.empty());
assert (ok); assert(ok);
ok = multipart.recv (input); ok = multipart.recv(input);
assert (multipart.size () == 1); assert(multipart.size() == 1);
assert (ok); assert(ok);
msg = multipart.pop (); msg = multipart.pop();
assert (multipart.empty ()); assert(multipart.empty());
assert (std::string (msg.data<char> (), msg.size ()) == "Hello"); assert(std::string(msg.data<char>(), msg.size()) == "Hello");
// Test send and receive of multi-frame message // Test send and receive of multi-frame message
multipart.addstr ("A"); multipart.addstr("A");
multipart.addstr ("BB"); multipart.addstr("BB");
multipart.addstr ("CCC"); multipart.addstr("CCC");
assert (multipart.size () == 3); assert(multipart.size() == 3);
multipart_t copy = multipart.clone (); multipart_t copy = multipart.clone();
assert (copy.size () == 3); assert(copy.size() == 3);
ok = copy.send (output); ok = copy.send(output);
assert (copy.empty ()); assert(copy.empty());
assert (ok); assert(ok);
ok = copy.recv (input); ok = copy.recv(input);
assert (copy.size () == 3); assert(copy.size() == 3);
assert (ok); assert(ok);
assert (copy.equal (&multipart)); assert(copy.equal(&multipart));
multipart.clear (); multipart.clear();
assert (multipart.empty ()); assert(multipart.empty());
// Test message frame manipulation // Test message frame manipulation
multipart.add (message_t ("Frame5", 6)); multipart.add(message_t("Frame5", 6));
multipart.addstr ("Frame6"); multipart.addstr("Frame6");
multipart.addstr ("Frame7"); multipart.addstr("Frame7");
multipart.addtyp (8.0f); multipart.addtyp(8.0f);
multipart.addmem ("Frame9", 6); multipart.addmem("Frame9", 6);
multipart.push (message_t ("Frame4", 6)); multipart.push(message_t("Frame4", 6));
multipart.pushstr ("Frame3"); multipart.pushstr("Frame3");
multipart.pushstr ("Frame2"); multipart.pushstr("Frame2");
multipart.pushtyp (1.0f); multipart.pushtyp(1.0f);
multipart.pushmem ("Frame0", 6); multipart.pushmem("Frame0", 6);
assert (multipart.size () == 10); assert(multipart.size() == 10);
msg = multipart.remove (); msg = multipart.remove();
assert (multipart.size () == 9); assert(multipart.size() == 9);
assert (std::string (msg.data<char> (), msg.size ()) == "Frame9"); assert(std::string(msg.data<char>(), msg.size()) == "Frame9");
msg = multipart.pop (); msg = multipart.pop();
assert (multipart.size () == 8); assert(multipart.size() == 8);
assert (std::string (msg.data<char> (), msg.size ()) == "Frame0"); assert(std::string(msg.data<char>(), msg.size()) == "Frame0");
num = multipart.poptyp<float> (); num = multipart.poptyp<float>();
assert (multipart.size () == 7); assert(multipart.size() == 7);
assert (num == 1.0f); assert(num == 1.0f);
str = multipart.popstr (); str = multipart.popstr();
assert (multipart.size () == 6); assert(multipart.size() == 6);
assert (str == "Frame2"); assert(str == "Frame2");
str = multipart.popstr (); str = multipart.popstr();
assert (multipart.size () == 5); assert(multipart.size() == 5);
assert (str == "Frame3"); assert(str == "Frame3");
str = multipart.popstr (); str = multipart.popstr();
assert (multipart.size () == 4); assert(multipart.size() == 4);
assert (str == "Frame4"); assert(str == "Frame4");
str = multipart.popstr (); str = multipart.popstr();
assert (multipart.size () == 3); assert(multipart.size() == 3);
assert (str == "Frame5"); assert(str == "Frame5");
str = multipart.popstr (); str = multipart.popstr();
assert (multipart.size () == 2); assert(multipart.size() == 2);
assert (str == "Frame6"); assert(str == "Frame6");
str = multipart.popstr (); str = multipart.popstr();
assert (multipart.size () == 1); assert(multipart.size() == 1);
assert (str == "Frame7"); assert(str == "Frame7");
num = multipart.poptyp<float> (); num = multipart.poptyp<float>();
assert (multipart.empty ()); assert(multipart.empty());
assert (num == 8.0f); assert(num == 8.0f);
// Test message constructors and concatenation // Test message constructors and concatenation
multipart_t head ("One", 3); multipart_t head("One", 3);
head.addstr ("Two"); head.addstr("Two");
assert (head.size () == 2); assert(head.size() == 2);
multipart_t tail (std::string ("One-hundred")); multipart_t tail(std::string("One-hundred"));
tail.pushstr ("Ninety-nine"); tail.pushstr("Ninety-nine");
assert (tail.size () == 2); assert(tail.size() == 2);
multipart_t tmp (message_t ("Fifty", 5)); multipart_t tmp(message_t("Fifty", 5));
assert (tmp.size () == 1); assert(tmp.size() == 1);
multipart_t mid = multipart_t::create (49.0f); multipart_t mid = multipart_t::create(49.0f);
mid.append (std::move (tmp)); mid.append(std::move(tmp));
assert (mid.size () == 2); assert(mid.size() == 2);
assert (tmp.empty ()); assert(tmp.empty());
multipart_t merged (std::move (mid)); multipart_t merged(std::move(mid));
merged.prepend (std::move (head)); merged.prepend(std::move(head));
merged.append (std::move (tail)); merged.append(std::move(tail));
assert (merged.size () == 6); assert(merged.size() == 6);
assert (head.empty ()); assert(head.empty());
assert (tail.empty ()); assert(tail.empty());
ok = merged.send (output); ok = merged.send(output);
assert (merged.empty ()); assert(merged.empty());
assert (ok); assert(ok);
multipart_t received (input); multipart_t received(input);
assert (received.size () == 6); assert(received.size() == 6);
str = received.popstr (); str = received.popstr();
assert (received.size () == 5); assert(received.size() == 5);
assert (str == "One"); assert(str == "One");
str = received.popstr (); str = received.popstr();
assert (received.size () == 4); assert(received.size() == 4);
assert (str == "Two"); assert(str == "Two");
num = received.poptyp<float> (); num = received.poptyp<float>();
assert (received.size () == 3); assert(received.size() == 3);
assert (num == 49.0f); assert(num == 49.0f);
str = received.popstr (); str = received.popstr();
assert (received.size () == 2); assert(received.size() == 2);
assert (str == "Fifty"); assert(str == "Fifty");
str = received.popstr (); str = received.popstr();
assert (received.size () == 1); assert(received.size() == 1);
assert (str == "Ninety-nine"); assert(str == "Ninety-nine");
str = received.popstr (); str = received.popstr();
assert (received.empty ()); assert(received.empty());
assert (str == "One-hundred"); assert(str == "One-hundred");
} }
#endif #endif

188
tests/poller.cpp
View File

@ -5,68 +5,68 @@
#include <array> #include <array>
#include <memory> #include <memory>
TEST (poller, create_destroy) TEST(poller, create_destroy)
{ {
zmq::poller_t<> poller; zmq::poller_t<> poller;
} }
static_assert (!std::is_copy_constructible<zmq::poller_t<>>::value, static_assert(!std::is_copy_constructible<zmq::poller_t<>>::value,
"poller_t should not be copy-constructible"); "poller_t should not be copy-constructible");
static_assert (!std::is_copy_assignable<zmq::poller_t<>>::value, static_assert(!std::is_copy_assignable<zmq::poller_t<>>::value,
"poller_t should not be copy-assignable"); "poller_t should not be copy-assignable");
TEST (poller, move_construct_empty) TEST(poller, move_construct_empty)
{ {
zmq::poller_t<> a; zmq::poller_t<> a;
zmq::poller_t<> b = std::move (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<> a;
zmq::poller_t<> b; 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::context_t context;
zmq::socket_t socket{context, zmq::socket_type::router}; zmq::socket_t socket{context, zmq::socket_type::router};
zmq::poller_t<> a; zmq::poller_t<> a;
a.add (socket, ZMQ_POLLIN, nullptr); a.add(socket, ZMQ_POLLIN, nullptr);
zmq::poller_t<> b = std::move (a); zmq::poller_t<> b = std::move(a);
} }
TEST (poller, move_assign_non_empty) TEST(poller, move_assign_non_empty)
{ {
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::poller_t<> a; zmq::poller_t<> a;
a.add (socket, ZMQ_POLLIN, nullptr); a.add(socket, ZMQ_POLLIN, nullptr);
zmq::poller_t<> b; 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::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; 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::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; zmq::poller_t<> poller;
int i; 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: /// checked by zmq_poller_add/modify in libzmq:
@ -75,226 +75,222 @@ TEST (poller, add_handler_invalid_events_type)
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;
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::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; zmq::poller_t<> poller;
poller.add (socket, ZMQ_POLLIN, nullptr); poller.add(socket, ZMQ_POLLIN, nullptr);
/// \todo the actual error code should be checked /// \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; zmq::poller_t<> poller;
std::vector<zmq_poller_event_t> events; std::vector<zmq_poller_event_t> events;
/// \todo the actual error code should be checked /// \todo the actual error code should be checked
ASSERT_THROW (poller.wait_all (events, std::chrono::milliseconds{10}), ASSERT_THROW(poller.wait_all(events, std::chrono::milliseconds{10}),
zmq::error_t); zmq::error_t);
} }
TEST (poller, remove_unregistered_throws) TEST(poller, remove_unregistered_throws)
{ {
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::poller_t<> poller; zmq::poller_t<> poller;
/// \todo the actual error code should be checked /// \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::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; zmq::poller_t<> poller;
poller.add (socket, ZMQ_POLLIN, nullptr); poller.add(socket, ZMQ_POLLIN, nullptr);
ASSERT_NO_THROW (poller.remove (socket)); ASSERT_NO_THROW(poller.remove(socket));
} }
TEST (poller, remove_registered_non_empty) TEST(poller, remove_registered_non_empty)
{ {
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::poller_t<> poller; zmq::poller_t<> poller;
poller.add (socket, ZMQ_POLLIN, nullptr); poller.add(socket, ZMQ_POLLIN, nullptr);
ASSERT_NO_THROW (poller.remove (socket)); ASSERT_NO_THROW(poller.remove(socket));
} }
TEST (poller, poll_basic) TEST(poller, poll_basic)
{ {
common_server_client_setup s; common_server_client_setup s;
ASSERT_NO_THROW (s.client.send ("Hi")); ASSERT_NO_THROW(s.client.send("Hi"));
zmq::poller_t<int> poller; zmq::poller_t<int> poller;
std::vector<zmq_poller_event_t> events{1}; std::vector<zmq_poller_event_t> events{1};
int i = 0; int i = 0;
ASSERT_NO_THROW (poller.add (s.server, ZMQ_POLLIN, &i)); ASSERT_NO_THROW(poller.add(s.server, ZMQ_POLLIN, &i));
ASSERT_EQ (1, poller.wait_all (events, std::chrono::milliseconds{-1})); ASSERT_EQ(1, poller.wait_all(events, std::chrono::milliseconds{-1}));
ASSERT_EQ (s.server, events[0].socket); ASSERT_EQ(s.server, events[0].socket);
ASSERT_EQ (&i, events[0].user_data); ASSERT_EQ(&i, events[0].user_data);
} }
TEST (poller, add_invalid_socket_throws) TEST(poller, add_invalid_socket_throws)
{ {
zmq::context_t context; zmq::context_t context;
zmq::poller_t<> poller; zmq::poller_t<> 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)};
ASSERT_THROW (poller.add (a, ZMQ_POLLIN, nullptr), zmq::error_t); 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::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; zmq::poller_t<> poller;
ASSERT_NO_THROW (poller.add (socket, ZMQ_POLLIN, nullptr)); ASSERT_NO_THROW(poller.add(socket, ZMQ_POLLIN, nullptr));
std::vector<zmq::socket_t> sockets; std::vector<zmq::socket_t> sockets;
sockets.emplace_back (std::move (socket)); sockets.emplace_back(std::move(socket));
ASSERT_THROW (poller.remove (socket), zmq::error_t); ASSERT_THROW(poller.remove(socket), zmq::error_t);
ASSERT_NO_THROW (poller.remove (sockets[0])); ASSERT_NO_THROW(poller.remove(sockets[0]));
} }
TEST (poller, modify_empty_throws) TEST(poller, modify_empty_throws)
{ {
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;
ASSERT_THROW (poller.modify (socket, ZMQ_POLLIN), zmq::error_t); 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::context_t context;
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::poller_t<> poller; zmq::poller_t<> poller;
ASSERT_THROW (poller.modify (a, ZMQ_POLLIN), zmq::error_t); 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::context_t context;
zmq::socket_t a{context, zmq::socket_type::push}; zmq::socket_t a{context, zmq::socket_type::push};
zmq::socket_t b{context, zmq::socket_type::push}; zmq::socket_t b{context, zmq::socket_type::push};
zmq::poller_t<> poller; zmq::poller_t<> poller;
ASSERT_NO_THROW (poller.add (a, ZMQ_POLLIN, nullptr)); ASSERT_NO_THROW(poller.add(a, ZMQ_POLLIN, nullptr));
ASSERT_THROW (poller.modify (b, ZMQ_POLLIN), zmq::error_t); ASSERT_THROW(poller.modify(b, ZMQ_POLLIN), zmq::error_t);
} }
TEST (poller, modify_simple) TEST(poller, modify_simple)
{ {
zmq::context_t context; 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; zmq::poller_t<> poller;
ASSERT_NO_THROW (poller.add (a, ZMQ_POLLIN, nullptr)); 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 // Setup server and client
common_server_client_setup s; common_server_client_setup s;
// Setup poller // Setup poller
zmq::poller_t<> 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 // client sends message
ASSERT_NO_THROW (s.client.send ("Hi")); ASSERT_NO_THROW(s.client.send("Hi"));
// wait for message and verify events // wait for message and verify events
std::vector<zmq_poller_event_t> events (1); std::vector<zmq_poller_event_t> events(1);
ASSERT_EQ (1, poller.wait_all (events, std::chrono::milliseconds{500})); ASSERT_EQ(1, poller.wait_all(events, std::chrono::milliseconds{500}));
ASSERT_EQ (ZMQ_POLLIN, events[0].events); ASSERT_EQ(ZMQ_POLLIN, events[0].events);
// Modify server socket with pollout flag // Modify server socket with pollout flag
ASSERT_NO_THROW (poller.modify (s.server, ZMQ_POLLIN | ZMQ_POLLOUT)); ASSERT_NO_THROW(poller.modify(s.server, ZMQ_POLLIN | ZMQ_POLLOUT));
ASSERT_EQ (1, poller.wait_all (events, std::chrono::milliseconds{500})); ASSERT_EQ(1, poller.wait_all(events, std::chrono::milliseconds{500}));
ASSERT_EQ (ZMQ_POLLIN | ZMQ_POLLOUT, events[0].events); ASSERT_EQ(ZMQ_POLLIN | ZMQ_POLLOUT, events[0].events);
} }
TEST (poller, wait_one_return) TEST(poller, wait_one_return)
{ {
// Setup server and client // Setup server and client
common_server_client_setup s; common_server_client_setup s;
// Setup poller // Setup poller
zmq::poller_t<> 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 // client sends message
ASSERT_NO_THROW (s.client.send ("Hi")); ASSERT_NO_THROW(s.client.send("Hi"));
// wait for message and verify events // wait for message and verify events
std::vector<zmq_poller_event_t> events (1); std::vector<zmq_poller_event_t> events(1);
ASSERT_EQ (1, poller.wait_all (events, std::chrono::milliseconds{500})); 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; common_server_client_setup s;
ASSERT_NO_THROW (s.client.send ("Hi")); ASSERT_NO_THROW(s.client.send("Hi"));
zmq::poller_t<> a; zmq::poller_t<> a;
ASSERT_NO_THROW (a.add (s.server, ZMQ_POLLIN, nullptr)); ASSERT_NO_THROW(a.add(s.server, ZMQ_POLLIN, nullptr));
zmq::poller_t<> b{std::move (a)}; zmq::poller_t<> b{std::move(a)};
std::vector<zmq_poller_event_t> events (1); std::vector<zmq_poller_event_t> events(1);
/// \todo the actual error code should be checked /// \todo the actual error code should be checked
ASSERT_THROW (a.wait_all (events, std::chrono::milliseconds{10}), ASSERT_THROW(a.wait_all(events, std::chrono::milliseconds{10}), zmq::error_t);
zmq::error_t); ASSERT_EQ(1, b.wait_all(events, std::chrono::milliseconds{-1}));
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; common_server_client_setup s;
ASSERT_NO_THROW (s.client.send ("Hi")); ASSERT_NO_THROW(s.client.send("Hi"));
zmq::poller_t<> a; zmq::poller_t<> a;
ASSERT_NO_THROW (a.add (s.server, ZMQ_POLLIN, nullptr)); ASSERT_NO_THROW(a.add(s.server, ZMQ_POLLIN, nullptr));
zmq::poller_t<> b; zmq::poller_t<> b;
b = {std::move (a)}; b = {std::move(a)};
/// \todo the actual error code should be checked /// \todo the actual error code should be checked
std::vector<zmq_poller_event_t> events (1); std::vector<zmq_poller_event_t> events(1);
ASSERT_THROW (a.wait_all (events, std::chrono::milliseconds{10}), ASSERT_THROW(a.wait_all(events, std::chrono::milliseconds{10}), zmq::error_t);
zmq::error_t); ASSERT_EQ(1, b.wait_all(events, std::chrono::milliseconds{-1}));
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; constexpr auto ITER_NO = 10;
// Setup servers and clients // Setup servers and clients
std::vector<common_server_client_setup> setup_list; std::vector<common_server_client_setup> setup_list;
for (auto i = 0; i < ITER_NO; ++i) for (auto i = 0; i < ITER_NO; ++i)
setup_list.emplace_back (common_server_client_setup{}); setup_list.emplace_back(common_server_client_setup{});
// Setup poller // Setup poller
zmq::poller_t<> poller; zmq::poller_t<> poller;
for (auto i = 0; i < ITER_NO; ++i) { for (auto i = 0; i < ITER_NO; ++i) {
ASSERT_NO_THROW ( ASSERT_NO_THROW(poller.add(setup_list[i].server, ZMQ_POLLIN, nullptr));
poller.add (setup_list[i].server, ZMQ_POLLIN, nullptr));
} }
// Clients send messages // Clients send messages
for (auto &s : setup_list) { for (auto &s : setup_list) {
ASSERT_NO_THROW (s.client.send ("Hi")); ASSERT_NO_THROW(s.client.send("Hi"));
} }
// Wait for all servers to receive a message // Wait for all servers to receive a message
for (auto &s : setup_list) { for (auto &s : setup_list) {
zmq::pollitem_t items[] = {{s.server, 0, ZMQ_POLLIN, 0}}; zmq::pollitem_t items[] = {{s.server, 0, ZMQ_POLLIN, 0}};
zmq::poll (&items[0], 1); zmq::poll(&items[0], 1);
} }
// Fire all handlers in one wait // Fire all handlers in one wait
std::vector<zmq_poller_event_t> events (ITER_NO); std::vector<zmq_poller_event_t> events(ITER_NO);
ASSERT_EQ (ITER_NO, ASSERT_EQ(ITER_NO, poller.wait_all(events, std::chrono::milliseconds{-1}));
poller.wait_all (events, std::chrono::milliseconds{-1}));
} }
#endif #endif

8
tests/socket.cpp
View File

@ -1,16 +1,16 @@
#include <gtest/gtest.h> #include <gtest/gtest.h>
#include <zmq.hpp> #include <zmq.hpp>
TEST (socket, create_destroy) TEST(socket, create_destroy)
{ {
zmq::context_t context; zmq::context_t context;
zmq::socket_t socket (context, ZMQ_ROUTER); zmq::socket_t socket(context, ZMQ_ROUTER);
} }
#ifdef ZMQ_CPP11 #ifdef ZMQ_CPP11
TEST (socket, create_by_enum_destroy) TEST(socket, create_by_enum_destroy)
{ {
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);
} }
#endif #endif

22
tests/testutil.hpp
View File

@ -8,10 +8,11 @@
class loopback_ip4_binder class loopback_ip4_binder
{ {
public: public:
loopback_ip4_binder(zmq::socket_t &socket) { bind(socket); } loopback_ip4_binder(zmq::socket_t &socket) { bind(socket); }
std::string endpoint() { return endpoint_; } std::string endpoint() { return endpoint_; }
private:
private:
// Helper function used in constructor // Helper function used in constructor
// as Gtest allows ASSERT_* only in void returning functions // as Gtest allows ASSERT_* only in void returning functions
// and constructor/destructor are not. // and constructor/destructor are not.
@ -20,8 +21,8 @@ private:
ASSERT_NO_THROW(socket.bind("tcp://127.0.0.1:*")); ASSERT_NO_THROW(socket.bind("tcp://127.0.0.1:*"));
std::array<char, 100> endpoint{}; std::array<char, 100> endpoint{};
size_t endpoint_size = endpoint.size(); size_t endpoint_size = endpoint.size();
ASSERT_NO_THROW(socket.getsockopt(ZMQ_LAST_ENDPOINT, endpoint.data(), ASSERT_NO_THROW(
&endpoint_size)); socket.getsockopt(ZMQ_LAST_ENDPOINT, endpoint.data(), &endpoint_size));
ASSERT_TRUE(endpoint_size < endpoint.size()); ASSERT_TRUE(endpoint_size < endpoint.size());
endpoint_ = std::string{endpoint.data()}; endpoint_ = std::string{endpoint.data()};
} }
@ -30,20 +31,17 @@ private:
struct common_server_client_setup struct common_server_client_setup
{ {
common_server_client_setup () common_server_client_setup() { init(); }
{
init ();
}
void init() void init()
{ {
endpoint = loopback_ip4_binder {server}.endpoint (); endpoint = loopback_ip4_binder{server}.endpoint();
ASSERT_NO_THROW (client.connect (endpoint)); ASSERT_NO_THROW(client.connect(endpoint));
} }
zmq::context_t context; zmq::context_t context;
zmq::socket_t server {context, zmq::socket_type::server}; zmq::socket_t server{context, zmq::socket_type::server};
zmq::socket_t client {context, zmq::socket_type::client}; zmq::socket_t client{context, zmq::socket_type::client};
std::string endpoint; std::string endpoint;
}; };
#endif #endif

697
zmq.hpp
View File

File diff suppressed because it is too large Load Diff

282
zmq_addon.hpp
View File

@ -52,252 +52,246 @@ class multipart_t
typedef std::deque<message_t>::const_iterator const_iterator; typedef std::deque<message_t>::const_iterator const_iterator;
typedef std::deque<message_t>::reverse_iterator reverse_iterator; typedef std::deque<message_t>::reverse_iterator reverse_iterator;
typedef std::deque<message_t>::const_reverse_iterator typedef std::deque<message_t>::const_reverse_iterator const_reverse_iterator;
const_reverse_iterator;
// Default constructor // Default constructor
multipart_t () {} multipart_t() {}
// Construct from socket receive // Construct from socket receive
multipart_t (socket_t &socket) { recv (socket); } multipart_t(socket_t &socket) { recv(socket); }
// Construct from memory block // Construct from memory block
multipart_t (const void *src, size_t size) { addmem (src, size); } multipart_t(const void *src, size_t size) { addmem(src, size); }
// Construct from string // Construct from string
multipart_t (const std::string &string) { addstr (string); } multipart_t(const std::string &string) { addstr(string); }
// Construct from message part // Construct from message part
multipart_t (message_t &&message) { add (std::move (message)); } multipart_t(message_t &&message) { add(std::move(message)); }
// Move constructor // Move constructor
multipart_t (multipart_t &&other) { m_parts = std::move (other.m_parts); } multipart_t(multipart_t &&other) { m_parts = std::move(other.m_parts); }
// Move assignment operator // Move assignment operator
multipart_t &operator= (multipart_t &&other) multipart_t &operator=(multipart_t &&other)
{ {
m_parts = std::move (other.m_parts); m_parts = std::move(other.m_parts);
return *this; return *this;
} }
// Destructor // Destructor
virtual ~multipart_t () { clear (); } virtual ~multipart_t() { clear(); }
message_t &operator[] (size_t n) { return m_parts[n]; } message_t &operator[](size_t n) { return m_parts[n]; }
const message_t &operator[] (size_t n) const { return m_parts[n]; } const message_t &operator[](size_t n) const { return m_parts[n]; }
message_t &at (size_t n) { return m_parts.at (n); } message_t &at(size_t n) { return m_parts.at(n); }
const message_t &at (size_t n) const { return m_parts.at (n); } const message_t &at(size_t n) const { return m_parts.at(n); }
iterator begin () { return m_parts.begin (); } iterator begin() { return m_parts.begin(); }
const_iterator begin () const { return m_parts.begin (); } const_iterator begin() const { return m_parts.begin(); }
const_iterator cbegin () const { return m_parts.cbegin (); } const_iterator cbegin() const { return m_parts.cbegin(); }
reverse_iterator rbegin () { return m_parts.rbegin (); } reverse_iterator rbegin() { return m_parts.rbegin(); }
const_reverse_iterator rbegin () const { return m_parts.rbegin (); } const_reverse_iterator rbegin() const { return m_parts.rbegin(); }
iterator end () { return m_parts.end (); } iterator end() { return m_parts.end(); }
const_iterator end () const { return m_parts.end (); } const_iterator end() const { return m_parts.end(); }
const_iterator cend () const { return m_parts.cend (); } const_iterator cend() const { return m_parts.cend(); }
reverse_iterator rend () { return m_parts.rend (); } reverse_iterator rend() { return m_parts.rend(); }
const_reverse_iterator rend () const { return m_parts.rend (); } const_reverse_iterator rend() const { return m_parts.rend(); }
// Delete all parts // Delete all parts
void clear () { m_parts.clear (); } void clear() { m_parts.clear(); }
// Get number of parts // Get number of parts
size_t size () const { return m_parts.size (); } size_t size() const { return m_parts.size(); }
// Check if number of parts is zero // Check if number of parts is zero
bool empty () const { return m_parts.empty (); } bool empty() const { return m_parts.empty(); }
// Receive multipart message from socket // Receive multipart message from socket
bool recv (socket_t &socket, int flags = 0) bool recv(socket_t &socket, int flags = 0)
{ {
clear (); clear();
bool more = true; bool more = true;
while (more) { while (more) {
message_t message; message_t message;
if (!socket.recv (&message, flags)) if (!socket.recv(&message, flags))
return false; return false;
more = message.more (); more = message.more();
add (std::move (message)); add(std::move(message));
} }
return true; return true;
} }
// Send multipart message to socket // Send multipart message to socket
bool send (socket_t &socket, int flags = 0) bool send(socket_t &socket, int flags = 0)
{ {
flags &= ~(ZMQ_SNDMORE); flags &= ~(ZMQ_SNDMORE);
bool more = size () > 0; bool more = size() > 0;
while (more) { while (more) {
message_t message = pop (); message_t message = pop();
more = size () > 0; more = size() > 0;
if (!socket.send (message, (more ? ZMQ_SNDMORE : 0) | flags)) if (!socket.send(message, (more ? ZMQ_SNDMORE : 0) | flags))
return false; return false;
} }
clear (); clear();
return true; return true;
} }
// Concatenate other multipart to front // Concatenate other multipart to front
void prepend (multipart_t &&other) void prepend(multipart_t &&other)
{ {
while (!other.empty ()) while (!other.empty())
push (other.remove ()); push(other.remove());
} }
// Concatenate other multipart to back // Concatenate other multipart to back
void append (multipart_t &&other) void append(multipart_t &&other)
{ {
while (!other.empty ()) while (!other.empty())
add (other.pop ()); add(other.pop());
} }
// Push memory block to front // Push memory block to front
void pushmem (const void *src, size_t size) void pushmem(const void *src, size_t size)
{ {
m_parts.push_front (message_t (src, size)); m_parts.push_front(message_t(src, size));
} }
// Push memory block to back // Push memory block to back
void addmem (const void *src, size_t size) void addmem(const void *src, size_t size)
{ {
m_parts.push_back (message_t (src, size)); m_parts.push_back(message_t(src, size));
} }
// Push string to front // Push string to front
void pushstr (const std::string &string) void pushstr(const std::string &string)
{ {
m_parts.push_front (message_t (string.data (), string.size ())); m_parts.push_front(message_t(string.data(), string.size()));
} }
// Push string to back // Push string to back
void addstr (const std::string &string) void addstr(const std::string &string)
{ {
m_parts.push_back (message_t (string.data (), string.size ())); m_parts.push_back(message_t(string.data(), string.size()));
} }
// Push type (fixed-size) to front // Push type (fixed-size) to front
template <typename T> void pushtyp (const T &type) template<typename T> void pushtyp(const T &type)
{ {
static_assert (!std::is_same<T, std::string>::value, static_assert(!std::is_same<T, std::string>::value,
"Use pushstr() instead of pushtyp<std::string>()"); "Use pushstr() instead of pushtyp<std::string>()");
m_parts.push_front (message_t (&type, sizeof (type))); m_parts.push_front(message_t(&type, sizeof(type)));
} }
// Push type (fixed-size) to back // Push type (fixed-size) to back
template <typename T> void addtyp (const T &type) template<typename T> void addtyp(const T &type)
{ {
static_assert (!std::is_same<T, std::string>::value, static_assert(!std::is_same<T, std::string>::value,
"Use addstr() instead of addtyp<std::string>()"); "Use addstr() instead of addtyp<std::string>()");
m_parts.push_back (message_t (&type, sizeof (type))); m_parts.push_back(message_t(&type, sizeof(type)));
} }
// Push message part to front // Push message part to front
void push (message_t &&message) void push(message_t &&message) { m_parts.push_front(std::move(message)); }
{
m_parts.push_front (std::move (message));
}
// Push message part to back // Push message part to back
void add (message_t &&message) { m_parts.push_back (std::move (message)); } void add(message_t &&message) { m_parts.push_back(std::move(message)); }
// Pop string from front // Pop string from front
std::string popstr () std::string popstr()
{ {
std::string string (m_parts.front ().data<char> (), std::string string(m_parts.front().data<char>(), m_parts.front().size());
m_parts.front ().size ()); m_parts.pop_front();
m_parts.pop_front ();
return string; return string;
} }
// Pop type (fixed-size) from front // Pop type (fixed-size) from front
template <typename T> T poptyp () template<typename T> T poptyp()
{ {
static_assert (!std::is_same<T, std::string>::value, static_assert(!std::is_same<T, std::string>::value,
"Use popstr() instead of poptyp<std::string>()"); "Use popstr() instead of poptyp<std::string>()");
if (sizeof (T) != m_parts.front ().size ()) if (sizeof(T) != m_parts.front().size())
throw std::runtime_error ( throw std::runtime_error(
"Invalid type, size does not match the message size"); "Invalid type, size does not match the message size");
T type = *m_parts.front ().data<T> (); T type = *m_parts.front().data<T>();
m_parts.pop_front (); m_parts.pop_front();
return type; return type;
} }
// Pop message part from front // Pop message part from front
message_t pop () message_t pop()
{ {
message_t message = std::move (m_parts.front ()); message_t message = std::move(m_parts.front());
m_parts.pop_front (); m_parts.pop_front();
return message; return message;
} }
// Pop message part from back // Pop message part from back
message_t remove () message_t remove()
{ {
message_t message = std::move (m_parts.back ()); message_t message = std::move(m_parts.back());
m_parts.pop_back (); m_parts.pop_back();
return message; return message;
} }
// 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]; }
// Get a string copy of a specific message part // Get a string copy of a specific message part
std::string peekstr (size_t index) const std::string peekstr(size_t index) const
{ {
std::string string (m_parts[index].data<char> (), std::string string(m_parts[index].data<char>(), m_parts[index].size());
m_parts[index].size ());
return string; return string;
} }
// Peek type (fixed-size) from front // Peek type (fixed-size) from front
template <typename T> T peektyp (size_t index) const template<typename T> T peektyp(size_t index) const
{ {
static_assert (!std::is_same<T, std::string>::value, static_assert(!std::is_same<T, std::string>::value,
"Use peekstr() instead of peektyp<std::string>()"); "Use peekstr() instead of peektyp<std::string>()");
if (sizeof (T) != m_parts[index].size ()) if (sizeof(T) != m_parts[index].size())
throw std::runtime_error ( throw std::runtime_error(
"Invalid type, size does not match the message size"); "Invalid type, size does not match the message size");
T type = *m_parts[index].data<T> (); T type = *m_parts[index].data<T>();
return type; return type;
} }
// Create multipart from type (fixed-size) // Create multipart from type (fixed-size)
template <typename T> static multipart_t create (const T &type) template<typename T> static multipart_t create(const T &type)
{ {
multipart_t multipart; multipart_t multipart;
multipart.addtyp (type); multipart.addtyp(type);
return multipart; return multipart;
} }
// Copy multipart // Copy multipart
multipart_t clone () const multipart_t clone() const
{ {
multipart_t multipart; multipart_t multipart;
for (size_t i = 0; i < size (); i++) for (size_t i = 0; i < size(); i++)
multipart.addmem (m_parts[i].data (), m_parts[i].size ()); multipart.addmem(m_parts[i].data(), m_parts[i].size());
return multipart; return multipart;
} }
// Dump content to string // Dump content to string
std::string str () const std::string str() const
{ {
std::stringstream ss; std::stringstream ss;
for (size_t i = 0; i < m_parts.size (); i++) { for (size_t i = 0; i < m_parts.size(); i++) {
const unsigned char *data = m_parts[i].data<unsigned char> (); const unsigned char *data = m_parts[i].data<unsigned char>();
size_t size = m_parts[i].size (); size_t size = m_parts[i].size();
// Dump the message as text or binary // Dump the message as text or binary
bool isText = true; bool isText = true;
@ -307,121 +301,119 @@ class multipart_t
break; break;
} }
} }
ss << "\n[" << std::dec << std::setw (3) << std::setfill ('0') ss << "\n[" << std::dec << std::setw(3) << std::setfill('0') << size
<< size << "] "; << "] ";
if (size >= 1000) { if (size >= 1000) {
ss << "... (to big to print)"; ss << "... (to big to print)";
continue; continue;
} }
for (size_t j = 0; j < size; j++) { for (size_t j = 0; j < size; j++) {
if (isText) if (isText)
ss << static_cast<char> (data[j]); ss << static_cast<char>(data[j]);
else else
ss << std::hex << std::setw (2) << std::setfill ('0') ss << std::hex << std::setw(2) << std::setfill('0')
<< static_cast<short> (data[j]); << static_cast<short>(data[j]);
} }
} }
return ss.str (); return ss.str();
} }
// Check if equal to other multipart // Check if equal to other multipart
bool equal (const multipart_t *other) const bool equal(const multipart_t *other) const
{ {
if (size () != other->size ()) if (size() != other->size())
return false; return false;
for (size_t i = 0; i < size (); i++) for (size_t i = 0; i < size(); i++)
if (*peek (i) != *other->peek (i)) if (*peek(i) != *other->peek(i))
return false; return false;
return true; return true;
} }
private: private:
// Disable implicit copying (moving is more efficient) // Disable implicit copying (moving is more efficient)
multipart_t (const multipart_t &other) ZMQ_DELETED_FUNCTION; multipart_t(const multipart_t &other) ZMQ_DELETED_FUNCTION;
void operator= (const multipart_t &other) ZMQ_DELETED_FUNCTION; void operator=(const multipart_t &other) ZMQ_DELETED_FUNCTION;
}; // class multipart_t }; // class multipart_t
inline std::ostream &operator<< (std::ostream &os, const multipart_t &msg) inline std::ostream &operator<<(std::ostream &os, const multipart_t &msg)
{ {
return os << msg.str (); return os << msg.str();
} }
#endif // ZMQ_HAS_RVALUE_REFS #endif // ZMQ_HAS_RVALUE_REFS
#if defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) \ #if defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) && defined(ZMQ_HAVE_POLLER)
&& defined(ZMQ_HAVE_POLLER)
class active_poller_t class active_poller_t
{ {
public: public:
active_poller_t () = default; active_poller_t() = default;
~active_poller_t () = default; ~active_poller_t() = default;
active_poller_t (const active_poller_t &) = delete; active_poller_t(const active_poller_t &) = delete;
active_poller_t &operator= (const active_poller_t &) = delete; active_poller_t &operator=(const active_poller_t &) = delete;
active_poller_t (active_poller_t &&src) = default; active_poller_t(active_poller_t &&src) = default;
active_poller_t &operator= (active_poller_t &&src) = default; active_poller_t &operator=(active_poller_t &&src) = default;
using handler_t = std::function<void(short)>; using handler_t = std::function<void(short)>;
void add (zmq::socket_t &socket, short events, handler_t handler) void add(zmq::socket_t &socket, short events, handler_t handler)
{ {
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 (static_cast<void *> (socket), handlers.emplace(static_cast<void *>(socket),
std::make_shared<handler_t> (std::move (handler))); std::make_shared<handler_t>(std::move(handler)));
try { try {
base_poller.add (socket, events, base_poller.add(socket, events,
inserted && *(it->second) ? it->second.get () inserted && *(it->second) ? it->second.get() : nullptr);
: nullptr);
need_rebuild |= inserted; need_rebuild |= inserted;
} }
catch (const zmq::error_t &) { catch (const zmq::error_t &) {
// rollback // rollback
if (inserted) { if (inserted) {
handlers.erase (static_cast<void *> (socket)); handlers.erase(static_cast<void *>(socket));
} }
throw; throw;
} }
} }
void remove (zmq::socket_t &socket) void remove(zmq::socket_t &socket)
{ {
base_poller.remove (socket); base_poller.remove(socket);
handlers.erase (static_cast<void *> (socket)); handlers.erase(static_cast<void *>(socket));
need_rebuild = true; need_rebuild = true;
} }
void modify (zmq::socket_t &socket, short events) void modify(zmq::socket_t &socket, short events)
{ {
base_poller.modify (socket, events); base_poller.modify(socket, events);
} }
size_t wait (std::chrono::milliseconds timeout) size_t wait(std::chrono::milliseconds timeout)
{ {
if (need_rebuild) { if (need_rebuild) {
poller_events.resize (handlers.size ()); poller_events.resize(handlers.size());
poller_handlers.clear (); poller_handlers.clear();
poller_handlers.reserve (handlers.size ()); poller_handlers.reserve(handlers.size());
for (const auto &handler : handlers) { for (const auto &handler : handlers) {
poller_handlers.push_back (handler.second); poller_handlers.push_back(handler.second);
} }
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 () + count, std::for_each(poller_events.begin(), poller_events.begin() + count,
[](zmq_poller_event_t &event) { [](zmq_poller_event_t &event) {
if (event.user_data != NULL) if (event.user_data != NULL)
(*reinterpret_cast<handler_t *> ( (*reinterpret_cast<handler_t *>(event.user_data))(
event.user_data)) (event.events); event.events);
}); });
return count; return count;
} }
bool empty () const { return handlers.empty (); } bool empty() const { return handlers.empty(); }
size_t size () const { return handlers.size (); } size_t size() const { return handlers.size(); }
private: private:
bool need_rebuild{false}; bool need_rebuild{false};