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

Merge pull request #226 from kurdybacha/clang-format

Browse Source 
Problem: inconsistent code style
This commit is contained in:
Simon Giesecke 2018-05-11 23:21:45 +02:00 committed by GitHub
commit bc82352c95
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 1580 additions and 1540 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
.clang-format Normal file
View File

@ -0,0 +1,53 @@
BasedOnStyle: LLVM
IndentWidth: 4
UseTab: Never
BreakBeforeBraces: Custom
BraceWrapping:
AfterClass: true
AfterControlStatement: false
AfterEnum: true
AfterFunction: true
AfterNamespace: true
AfterObjCDeclaration: true
AfterStruct: true
AfterUnion: true
BeforeCatch: true
BeforeElse: false
IndentBraces: false
AlignConsecutiveAssignments: false
AlignConsecutiveDeclarations: false
AllowShortIfStatementsOnASingleLine: false
IndentCaseLabels: true
BinPackArguments: true
BinPackParameters: false
AlignTrailingComments: true
AllowShortBlocksOnASingleLine: false
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortFunctionsOnASingleLine: InlineOnly
AlwaysBreakTemplateDeclarations: false
ColumnLimit: 80
MaxEmptyLinesToKeep: 2
KeepEmptyLinesAtTheStartOfBlocks: false
ContinuationIndentWidth: 2
PointerAlignment: Right
ReflowComments: false
SpaceBeforeAssignmentOperators: true
SpaceBeforeParens: Always
SpaceInEmptyParentheses: false
SpacesInAngles: false
SpacesInParentheses: false
SpacesInSquareBrackets: false
Standard: Cpp11
SortIncludes: false
FixNamespaceComments: false
BreakBeforeBinaryOperators: NonAssignment
SpaceAfterTemplateKeyword: true
AlignAfterOpenBracket: Align
AlignOperands: true
BreakConstructorInitializers: AfterColon
ConstructorInitializerAllOnOneLineOrOnePerLine: true
SpaceAfterCStyleCast: true
BreakBeforeTernaryOperators: true

3
demo/main.cpp
View File

@ -1,8 +1,7 @@
#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;
} }

303
tests/active_poller.cpp
View File

@ -7,81 +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, "active_active_poller_t should not be copy-constructible"); static_assert (!std::is_copy_constructible<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-constructible");
static_assert (!std::is_copy_assignable<zmq::active_poller_t>::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; 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:
@ -91,86 +93,88 @@ 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), 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; 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}), 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::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
{
struct server_client_setup : common_server_client_setup struct server_client_setup : common_server_client_setup
{ {
zmq::active_poller_t::handler_t handler = [&](short e) { zmq::active_poller_t::handler_t handler = [&](short e) { events = e; };
events = e;
};
short events = 0; short events = 0;
}; };
} }
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 = [&message_received](short events) { zmq::active_poller_t::handler_t handler =
ASSERT_TRUE(0 != (events & ZMQ_POLLIN)); [&message_received](short events) {
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";
@ -183,47 +187,49 @@ 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>(), std::string recv_msg (zmq_msg.data<char> (), zmq_msg.size ());
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(active_poller.add(s.server, ZMQ_POLLIN | ZMQ_POLLOUT, handler)); ASSERT_NO_THROW (
ASSERT_EQ(1, active_poller.wait(std::chrono::milliseconds{-1})); active_poller.add (s.server, ZMQ_POLLIN | ZMQ_POLLOUT, handler));
ASSERT_EQ(events, ZMQ_POLLOUT); 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::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 (active_poller.add (a, ZMQ_POLLIN, zmq::active_poller_t::handler_t {}), ASSERT_THROW (
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, 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 ()); 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));
@ -231,75 +237,77 @@ TEST(active_poller, remove_invalid_socket_throws)
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 (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); 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 (active_poller.add (a, ZMQ_POLLIN, zmq::active_poller_t::handler_t {})); ASSERT_NO_THROW (
ASSERT_NO_THROW (active_poller.modify (a, ZMQ_POLLIN|ZMQ_POLLOUT)); 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 // 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;
@ -308,33 +316,32 @@ 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(active_poller.add(s.server, ZMQ_POLLIN, [&count](short) { ASSERT_NO_THROW (
++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"));
@ -343,38 +350,37 @@ TEST(active_poller, wait_on_move_assigned_active_poller)
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(a.add(s.server, ZMQ_POLLIN, [&count](short) { ASSERT_NO_THROW (
++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;
@ -387,28 +393,29 @@ TEST(active_poller, remove_from_handler)
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(setup_list[i].server, ZMQ_POLLIN, [&,i](short events) { ASSERT_NO_THROW (active_poller.add (
ASSERT_EQ(events, ZMQ_POLLIN); setup_list[i].server, ZMQ_POLLIN, [&, i](short events) {
active_poller.remove(setup_list[ITER_NO-i-1].server); ASSERT_EQ (events, ZMQ_POLLIN);
ASSERT_EQ(ITER_NO-i-1, active_poller.size()); active_poller.remove (setup_list[ITER_NO - i - 1].server);
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 ();
} }

36
tests/message.cpp
View File

@ -2,8 +2,10 @@
#include <zmq.hpp> #include <zmq.hpp>
#if defined(ZMQ_CPP11) #if defined(ZMQ_CPP11)
static_assert(!std::is_copy_constructible<zmq::message_t>::value, "message_t should not be copy-constructible"); static_assert (!std::is_copy_constructible<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-constructible");
static_assert (!std::is_copy_assignable<zmq::message_t>::value,
"message_t should not be copy-assignable");
#endif #endif
TEST (message, constructor_default) TEST (message, constructor_default)
@ -12,7 +14,7 @@ TEST (message, constructor_default)
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)
{ {
@ -30,7 +32,8 @@ TEST (message, constructor_pointer_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));
@ -49,7 +52,7 @@ TEST (message, constructor_container)
#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)
@ -63,50 +66,55 @@ TEST (message, assign_move_empty_before)
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);
} }

236
tests/multipart.cpp
View File

@ -4,168 +4,170 @@
#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;
bool ok = true; (void) ok; bool ok = true;
float num = 0; (void) num; (void) ok;
float num = 0;
(void) num;
std::string str = ""; std::string str = "";
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

178
tests/poller.cpp
View File

@ -5,66 +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, "poller_t should not be copy-constructible"); static_assert (!std::is_copy_constructible<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-constructible");
static_assert (!std::is_copy_assignable<zmq::poller_t<>>::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<> 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:
@ -73,83 +75,83 @@ 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}), 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::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), ASSERT_THROW (poller.add (a, ZMQ_POLLIN, nullptr), zmq::error_t);
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;
@ -158,96 +160,97 @@ TEST(poller, remove_invalid_socket_throws)
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}), zmq::error_t); ASSERT_THROW (a.wait_all (events, std::chrono::milliseconds{10}),
ASSERT_EQ (1, b.wait_all (events, std::chrono::milliseconds {-1})); 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; common_server_client_setup s;
ASSERT_NO_THROW (s.client.send ("Hi")); ASSERT_NO_THROW (s.client.send ("Hi"));
@ -256,12 +259,13 @@ TEST(poller, wait_on_move_assigned_poller)
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}), zmq::error_t); ASSERT_THROW (a.wait_all (events, std::chrono::milliseconds{10}),
ASSERT_EQ (1, b.wait_all (events, std::chrono::milliseconds {-1})); 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; constexpr auto ITER_NO = 10;
@ -273,22 +277,24 @@ TEST(poller, remove_from_handler)
// 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(poller.add(setup_list[i].server, ZMQ_POLLIN, nullptr)); ASSERT_NO_THROW (
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, poller.wait_all (events, std::chrono::milliseconds{-1})); ASSERT_EQ (ITER_NO,
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

767
zmq.hpp
View File

File diff suppressed because it is too large Load Diff

402
zmq_addon.hpp
View File

@ -31,8 +31,8 @@
#include <sstream> #include <sstream>
#include <stdexcept> #include <stdexcept>
namespace zmq { namespace zmq
{
#ifdef ZMQ_HAS_RVALUE_REFS #ifdef ZMQ_HAS_RVALUE_REFS
/* /*
@ -44,419 +44,343 @@ namespace zmq {
*/ */
class multipart_t class multipart_t
{ {
private: private:
std::deque<message_t> m_parts; std::deque<message_t> m_parts;
public: public:
typedef std::deque<message_t>::iterator iterator; typedef std::deque<message_t>::iterator iterator;
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 const_reverse_iterator; typedef std::deque<message_t>::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) multipart_t (socket_t &socket) { recv (socket); }
{
recv(socket);
}
// Construct from memory block // Construct from memory block
multipart_t(const void *src, size_t size) multipart_t (const void *src, size_t size) { addmem (src, size); }
{
addmem(src, size);
}
// Construct from string // Construct from string
multipart_t(const std::string& string) multipart_t (const std::string &string) { addstr (string); }
{
addstr(string);
}
// Construct from message part // Construct from message part
multipart_t(message_t&& message) multipart_t (message_t &&message) { add (std::move (message)); }
{
add(std::move(message));
}
// Move constructor // Move constructor
multipart_t(multipart_t&& other) multipart_t (multipart_t &&other) { m_parts = std::move (other.m_parts); }
{
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() virtual ~multipart_t () { clear (); }
{
clear();
}
message_t& operator[] (size_t n) message_t &operator[] (size_t n) { return m_parts[n]; }
{
return m_parts[n];
}
const message_t& operator[] (size_t n) const const message_t &operator[] (size_t n) const { return m_parts[n]; }
{
return m_parts[n];
}
message_t& at (size_t n) message_t &at (size_t n) { return m_parts.at (n); }
{
return m_parts.at(n);
}
const message_t& at (size_t n) const const message_t &at (size_t n) const { return m_parts.at (n); }
{
return m_parts.at(n);
}
iterator begin() iterator begin () { return m_parts.begin (); }
{
return m_parts.begin();
}
const_iterator begin() const const_iterator begin () const { return m_parts.begin (); }
{
return m_parts.begin();
}
const_iterator cbegin() const const_iterator cbegin () const { return m_parts.cbegin (); }
{
return m_parts.cbegin();
}
reverse_iterator rbegin() reverse_iterator rbegin () { return m_parts.rbegin (); }
{
return m_parts.rbegin();
}
const_reverse_iterator rbegin() const const_reverse_iterator rbegin () const { return m_parts.rbegin (); }
{
return m_parts.rbegin();
}
iterator end() iterator end () { return m_parts.end (); }
{
return m_parts.end();
}
const_iterator end() const const_iterator end () const { return m_parts.end (); }
{
return m_parts.end();
}
const_iterator cend() const const_iterator cend () const { return m_parts.cend (); }
{
return m_parts.cend();
}
reverse_iterator rend() reverse_iterator rend () { return m_parts.rend (); }
{
return m_parts.rend();
}
const_reverse_iterator rend() const const_reverse_iterator rend () const { return m_parts.rend (); }
{
return m_parts.rend();
}
// Delete all parts // Delete all parts
void clear() void clear () { m_parts.clear (); }
{
m_parts.clear();
}
// Get number of parts // Get number of parts
size_t size() const size_t size () const { return m_parts.size (); }
{
return m_parts.size();
}
// Check if number of parts is zero // Check if number of parts is zero
bool empty() const bool empty () const { return m_parts.empty (); }
{
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> template <typename T> void pushtyp (const T &type)
void pushtyp(const T& type)
{ {
static_assert(!std::is_same<T, std::string>::value, "Use pushstr() instead of pushtyp<std::string>()"); static_assert (!std::is_same<T, std::string>::value,
m_parts.push_front(message_t(&type, sizeof(type))); "Use pushstr() instead of pushtyp<std::string>()");
m_parts.push_front (message_t (&type, sizeof (type)));
} }
// Push type (fixed-size) to back // Push type (fixed-size) to back
template<typename T> template <typename T> void addtyp (const T &type)
void addtyp(const T& type)
{ {
static_assert(!std::is_same<T, std::string>::value, "Use addstr() instead of addtyp<std::string>()"); static_assert (!std::is_same<T, std::string>::value,
m_parts.push_back(message_t(&type, sizeof(type))); "Use addstr() instead of addtyp<std::string>()");
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) void add (message_t &&message) { m_parts.push_back (std::move (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>(), m_parts.front().size()); std::string string (m_parts.front ().data<char> (),
m_parts.pop_front(); m_parts.front ().size ());
m_parts.pop_front ();
return string; return string;
} }
// Pop type (fixed-size) from front // Pop type (fixed-size) from front
template<typename T> template <typename T> T poptyp ()
T poptyp()
{ {
static_assert(!std::is_same<T, std::string>::value, "Use popstr() instead of poptyp<std::string>()"); static_assert (!std::is_same<T, std::string>::value,
if (sizeof(T) != m_parts.front().size()) "Use popstr() instead of poptyp<std::string>()");
throw std::runtime_error("Invalid type, size does not match the message size"); if (sizeof (T) != m_parts.front ().size ())
T type = *m_parts.front().data<T>(); throw std::runtime_error (
m_parts.pop_front(); "Invalid type, size does not match the message size");
T type = *m_parts.front ().data<T> ();
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 const message_t *peek (size_t index) const { return &m_parts[index]; }
{
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>(), m_parts[index].size()); std::string string (m_parts[index].data<char> (),
m_parts[index].size ());
return string; return string;
} }
// Peek type (fixed-size) from front // Peek type (fixed-size) from front
template<typename T> template <typename T> T peektyp (size_t index) const
T peektyp(size_t index) const
{ {
static_assert(!std::is_same<T, std::string>::value, "Use peekstr() instead of peektyp<std::string>()"); static_assert (!std::is_same<T, std::string>::value,
if(sizeof(T) != m_parts[index].size()) "Use peekstr() instead of peektyp<std::string>()");
throw std::runtime_error("Invalid type, size does not match the message size"); if (sizeof (T) != m_parts[index].size ())
T type = *m_parts[index].data<T>(); throw std::runtime_error (
"Invalid type, size does not match the message size");
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> template <typename T> static multipart_t create (const T &type)
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;
for (size_t j = 0; j < size; j++) for (size_t j = 0; j < size; j++) {
{ if (data[j] < 32 || data[j] > 127) {
if (data[j] < 32 || data[j] > 127)
{
isText = false; isText = false;
break; break;
} }
} }
ss << "\n[" << std::dec << std::setw(3) << std::setfill('0') << size << "] "; ss << "\n[" << std::dec << std::setw (3) << std::setfill ('0')
if (size >= 1000) << size << "] ";
{ 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') << static_cast<short>(data[j]); ss << std::hex << std::setw (2) << std::setfill ('0')
<< 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) && defined(ZMQ_HAVE_POLLER) #if defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) \
class active_poller_t && defined(ZMQ_HAVE_POLLER)
{ 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) = handlers.emplace (static_cast<void*>(socket), std::make_shared<handler_t> (std::move (handler))); std::tie (it, inserted) =
try handlers.emplace (static_cast<void *> (socket),
{ std::make_shared<handler_t> (std::move (handler)));
base_poller.add (socket, events, inserted && *(it->second) ? it->second.get() : nullptr); try {
base_poller.add (socket, events,
inserted && *(it->second) ? it->second.get ()
: 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;
} }
@ -465,7 +389,7 @@ inline std::ostream& operator<<(std::ostream& os, const multipart_t& msg)
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;
} }
@ -487,33 +411,29 @@ inline std::ostream& operator<<(std::ostream& os, const multipart_t& msg)
} }
const int count = base_poller.wait_all (poller_events, timeout); const int count = base_poller.wait_all (poller_events, timeout);
if (count != 0) { if (count != 0) {
std::for_each (poller_events.begin (), poller_events.begin () + count, std::for_each (poller_events.begin (),
[](zmq_poller_event_t& event) { poller_events.begin () + count,
[](zmq_poller_event_t &event) {
if (event.user_data != NULL) if (event.user_data != NULL)
(*reinterpret_cast<handler_t*> (event.user_data)) (event.events); (*reinterpret_cast<handler_t *> (
event.user_data)) (event.events);
}); });
} }
return count; return count;
} }
bool empty () const bool empty () const { return handlers.empty (); }
{
return handlers.empty ();
}
size_t size () const size_t size () const { return handlers.size (); }
{
return handlers.size ();
}
private: private:
bool need_rebuild {false}; bool need_rebuild{false};
poller_t<handler_t> base_poller {}; poller_t<handler_t> base_poller{};
std::unordered_map<void*, std::shared_ptr<handler_t>> handlers {}; std::unordered_map<void *, std::shared_ptr<handler_t>> handlers{};
std::vector<zmq_poller_event_t> poller_events {}; std::vector<zmq_poller_event_t> poller_events{};
std::vector<std::shared_ptr<handler_t>> poller_handlers {}; std::vector<std::shared_ptr<handler_t>> poller_handlers{};
}; // class active_poller_t }; // class active_poller_t
#endif // defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) && defined(ZMQ_HAVE_POLLER) #endif // defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) && defined(ZMQ_HAVE_POLLER)