mirror of
https://github.com/zeromq/cppzmq.git
synced 2025-04-06 10:55:59 +02:00
Merge pull request #228 from kurdybacha/clang-format
Problem: whitespace style too restrictive.
This commit is contained in:
Luca Boccassi
GitHub
commit
f81accd6b1
@ -26,14 +26,14 @@ AllowShortBlocksOnASingleLine: false
|
||||
AllowAllParametersOfDeclarationOnNextLine: true
|
||||
AllowShortFunctionsOnASingleLine: InlineOnly
|
||||
AlwaysBreakTemplateDeclarations: false
|
||||
ColumnLimit: 80
|
||||
ColumnLimit: 85
|
||||
MaxEmptyLinesToKeep: 2
|
||||
KeepEmptyLinesAtTheStartOfBlocks: false
|
||||
ContinuationIndentWidth: 2
|
||||
PointerAlignment: Right
|
||||
ReflowComments: false
|
||||
SpaceBeforeAssignmentOperators: true
|
||||
SpaceBeforeParens: Always
|
||||
SpaceBeforeParens: ControlStatements
|
||||
SpaceInEmptyParentheses: false
|
||||
SpacesInAngles: false
|
||||
SpacesInParentheses: false
|
||||
@ -44,7 +44,7 @@ SortIncludes: false
|
||||
|
||||
FixNamespaceComments: false
|
||||
BreakBeforeBinaryOperators: NonAssignment
|
||||
SpaceAfterTemplateKeyword: true
|
||||
SpaceAfterTemplateKeyword: false
|
||||
AlignAfterOpenBracket: Align
|
||||
AlignOperands: true
|
||||
BreakConstructorInitializers: AfterColon
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
#include <zmq.hpp>
|
||||
|
||||
int main (int argc, char **argv)
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
zmq::context_t context;
|
||||
return 0;
|
||||
|
||||
@ -7,83 +7,83 @@
|
||||
#include <array>
|
||||
#include <memory>
|
||||
|
||||
TEST (active_poller, create_destroy)
|
||||
TEST(active_poller, create_destroy)
|
||||
{
|
||||
zmq::active_poller_t active_poller;
|
||||
ASSERT_TRUE (active_poller.empty ());
|
||||
ASSERT_TRUE(active_poller.empty());
|
||||
}
|
||||
|
||||
static_assert (!std::is_copy_constructible<zmq::active_poller_t>::value,
|
||||
"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");
|
||||
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_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;
|
||||
ASSERT_TRUE (a.empty ());
|
||||
zmq::active_poller_t b = std::move (a);
|
||||
ASSERT_TRUE (b.empty ());
|
||||
ASSERT_EQ (0u, a.size ());
|
||||
ASSERT_EQ (0u, b.size ());
|
||||
ASSERT_TRUE(a.empty());
|
||||
zmq::active_poller_t b = std::move(a);
|
||||
ASSERT_TRUE(b.empty());
|
||||
ASSERT_EQ(0u, a.size());
|
||||
ASSERT_EQ(0u, b.size());
|
||||
}
|
||||
|
||||
TEST (active_poller, move_assign_empty)
|
||||
TEST(active_poller, move_assign_empty)
|
||||
{
|
||||
zmq::active_poller_t a;
|
||||
ASSERT_TRUE (a.empty ());
|
||||
ASSERT_TRUE(a.empty());
|
||||
zmq::active_poller_t b;
|
||||
ASSERT_TRUE (b.empty ());
|
||||
b = std::move (a);
|
||||
ASSERT_EQ (0u, a.size ());
|
||||
ASSERT_EQ (0u, b.size ());
|
||||
ASSERT_TRUE (a.empty ());
|
||||
ASSERT_TRUE (b.empty ());
|
||||
ASSERT_TRUE(b.empty());
|
||||
b = std::move(a);
|
||||
ASSERT_EQ(0u, a.size());
|
||||
ASSERT_EQ(0u, b.size());
|
||||
ASSERT_TRUE(a.empty());
|
||||
ASSERT_TRUE(b.empty());
|
||||
}
|
||||
|
||||
TEST (active_poller, move_construct_non_empty)
|
||||
TEST(active_poller, move_construct_non_empty)
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::socket_t socket{context, zmq::socket_type::router};
|
||||
|
||||
zmq::active_poller_t a;
|
||||
a.add (socket, ZMQ_POLLIN, [](short) {});
|
||||
ASSERT_FALSE (a.empty ());
|
||||
ASSERT_EQ (1u, a.size ());
|
||||
zmq::active_poller_t b = std::move (a);
|
||||
ASSERT_TRUE (a.empty ());
|
||||
ASSERT_EQ (0u, a.size ());
|
||||
ASSERT_FALSE (b.empty ());
|
||||
ASSERT_EQ (1u, b.size ());
|
||||
a.add(socket, ZMQ_POLLIN, [](short) {});
|
||||
ASSERT_FALSE(a.empty());
|
||||
ASSERT_EQ(1u, a.size());
|
||||
zmq::active_poller_t b = std::move(a);
|
||||
ASSERT_TRUE(a.empty());
|
||||
ASSERT_EQ(0u, a.size());
|
||||
ASSERT_FALSE(b.empty());
|
||||
ASSERT_EQ(1u, b.size());
|
||||
}
|
||||
|
||||
TEST (active_poller, move_assign_non_empty)
|
||||
TEST(active_poller, move_assign_non_empty)
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::socket_t socket{context, zmq::socket_type::router};
|
||||
|
||||
zmq::active_poller_t a;
|
||||
a.add (socket, ZMQ_POLLIN, [](short) {});
|
||||
ASSERT_FALSE (a.empty ());
|
||||
ASSERT_EQ (1u, a.size ());
|
||||
a.add(socket, ZMQ_POLLIN, [](short) {});
|
||||
ASSERT_FALSE(a.empty());
|
||||
ASSERT_EQ(1u, a.size());
|
||||
zmq::active_poller_t b;
|
||||
b = std::move (a);
|
||||
ASSERT_TRUE (a.empty ());
|
||||
ASSERT_EQ (0u, a.size ());
|
||||
ASSERT_FALSE (b.empty ());
|
||||
ASSERT_EQ (1u, b.size ());
|
||||
b = std::move(a);
|
||||
ASSERT_TRUE(a.empty());
|
||||
ASSERT_EQ(0u, a.size());
|
||||
ASSERT_FALSE(b.empty());
|
||||
ASSERT_EQ(1u, b.size());
|
||||
}
|
||||
|
||||
TEST (active_poller, add_handler)
|
||||
TEST(active_poller, add_handler)
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::socket_t socket{context, zmq::socket_type::router};
|
||||
zmq::active_poller_t active_poller;
|
||||
zmq::active_poller_t::handler_t handler;
|
||||
ASSERT_NO_THROW (active_poller.add (socket, ZMQ_POLLIN, handler));
|
||||
ASSERT_NO_THROW(active_poller.add(socket, ZMQ_POLLIN, handler));
|
||||
}
|
||||
|
||||
TEST (active_poller, add_handler_invalid_events_type)
|
||||
TEST(active_poller, add_handler_invalid_events_type)
|
||||
{
|
||||
/// \todo is it good that this is accepted? should probably already be
|
||||
/// 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::handler_t handler;
|
||||
short invalid_events_type = 2 << 10;
|
||||
ASSERT_NO_THROW (active_poller.add (socket, invalid_events_type, handler));
|
||||
ASSERT_FALSE (active_poller.empty ());
|
||||
ASSERT_EQ (1u, active_poller.size ());
|
||||
ASSERT_NO_THROW(active_poller.add(socket, invalid_events_type, handler));
|
||||
ASSERT_FALSE(active_poller.empty());
|
||||
ASSERT_EQ(1u, active_poller.size());
|
||||
}
|
||||
|
||||
TEST (active_poller, add_handler_twice_throws)
|
||||
TEST(active_poller, add_handler_twice_throws)
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::socket_t socket{context, zmq::socket_type::router};
|
||||
zmq::active_poller_t active_poller;
|
||||
zmq::active_poller_t::handler_t handler;
|
||||
active_poller.add (socket, ZMQ_POLLIN, handler);
|
||||
active_poller.add(socket, ZMQ_POLLIN, handler);
|
||||
/// \todo the actual error code should be checked
|
||||
ASSERT_THROW (active_poller.add (socket, ZMQ_POLLIN, handler),
|
||||
zmq::error_t);
|
||||
ASSERT_THROW(active_poller.add(socket, ZMQ_POLLIN, handler), zmq::error_t);
|
||||
}
|
||||
|
||||
TEST (active_poller, wait_with_no_handlers_throws)
|
||||
TEST(active_poller, wait_with_no_handlers_throws)
|
||||
{
|
||||
zmq::active_poller_t active_poller;
|
||||
/// \todo the actual error code should be checked
|
||||
ASSERT_THROW (active_poller.wait (std::chrono::milliseconds{10}),
|
||||
zmq::error_t);
|
||||
ASSERT_THROW(active_poller.wait(std::chrono::milliseconds{10}), zmq::error_t);
|
||||
}
|
||||
|
||||
TEST (active_poller, remove_unregistered_throws)
|
||||
TEST(active_poller, remove_unregistered_throws)
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::socket_t socket{context, zmq::socket_type::router};
|
||||
zmq::active_poller_t active_poller;
|
||||
/// \todo the actual error code should be checked
|
||||
ASSERT_THROW (active_poller.remove (socket), zmq::error_t);
|
||||
ASSERT_THROW(active_poller.remove(socket), zmq::error_t);
|
||||
}
|
||||
|
||||
TEST (active_poller, remove_registered_empty)
|
||||
TEST(active_poller, remove_registered_empty)
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::socket_t socket{context, zmq::socket_type::router};
|
||||
zmq::active_poller_t active_poller;
|
||||
active_poller.add (socket, ZMQ_POLLIN, zmq::active_poller_t::handler_t{});
|
||||
ASSERT_NO_THROW (active_poller.remove (socket));
|
||||
active_poller.add(socket, ZMQ_POLLIN, zmq::active_poller_t::handler_t{});
|
||||
ASSERT_NO_THROW(active_poller.remove(socket));
|
||||
}
|
||||
|
||||
TEST (active_poller, remove_registered_non_empty)
|
||||
TEST(active_poller, remove_registered_non_empty)
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::socket_t socket{context, zmq::socket_type::router};
|
||||
zmq::active_poller_t active_poller;
|
||||
active_poller.add (socket, ZMQ_POLLIN, [](short) {});
|
||||
ASSERT_NO_THROW (active_poller.remove (socket));
|
||||
active_poller.add(socket, ZMQ_POLLIN, [](short) {});
|
||||
ASSERT_NO_THROW(active_poller.remove(socket));
|
||||
}
|
||||
|
||||
namespace
|
||||
@ -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;
|
||||
|
||||
ASSERT_NO_THROW (s.client.send ("Hi"));
|
||||
ASSERT_NO_THROW(s.client.send("Hi"));
|
||||
|
||||
zmq::active_poller_t active_poller;
|
||||
bool message_received = false;
|
||||
zmq::active_poller_t::handler_t handler =
|
||||
[&message_received](short events) {
|
||||
ASSERT_TRUE (0 != (events & ZMQ_POLLIN));
|
||||
message_received = true;
|
||||
};
|
||||
ASSERT_NO_THROW (active_poller.add (s.server, ZMQ_POLLIN, handler));
|
||||
ASSERT_EQ (1, active_poller.wait (std::chrono::milliseconds{-1}));
|
||||
ASSERT_TRUE (message_received);
|
||||
zmq::active_poller_t::handler_t handler = [&message_received](short events) {
|
||||
ASSERT_TRUE(0 != (events & ZMQ_POLLIN));
|
||||
message_received = true;
|
||||
};
|
||||
ASSERT_NO_THROW(active_poller.add(s.server, ZMQ_POLLIN, handler));
|
||||
ASSERT_EQ(1, active_poller.wait(std::chrono::milliseconds{-1}));
|
||||
ASSERT_TRUE(message_received);
|
||||
}
|
||||
|
||||
/// \todo this contains multiple test cases that should be split up
|
||||
TEST (active_poller, client_server)
|
||||
TEST(active_poller, client_server)
|
||||
{
|
||||
const std::string send_msg = "Hi";
|
||||
|
||||
@ -187,127 +184,125 @@ TEST (active_poller, client_server)
|
||||
zmq::active_poller_t::handler_t handler = [&](short e) {
|
||||
if (0 != (e & ZMQ_POLLIN)) {
|
||||
zmq::message_t zmq_msg;
|
||||
ASSERT_NO_THROW (s.server.recv (&zmq_msg)); // get message
|
||||
std::string recv_msg (zmq_msg.data<char> (), zmq_msg.size ());
|
||||
ASSERT_EQ (send_msg, recv_msg);
|
||||
ASSERT_NO_THROW(s.server.recv(&zmq_msg)); // get message
|
||||
std::string recv_msg(zmq_msg.data<char>(), zmq_msg.size());
|
||||
ASSERT_EQ(send_msg, recv_msg);
|
||||
} else if (0 != (e & ~ZMQ_POLLOUT)) {
|
||||
ASSERT_TRUE (false) << "Unexpected event type " << events;
|
||||
ASSERT_TRUE(false) << "Unexpected event type " << events;
|
||||
}
|
||||
events = e;
|
||||
};
|
||||
|
||||
ASSERT_NO_THROW (active_poller.add (s.server, ZMQ_POLLIN, handler));
|
||||
ASSERT_NO_THROW(active_poller.add(s.server, ZMQ_POLLIN, handler));
|
||||
|
||||
// client sends message
|
||||
ASSERT_NO_THROW (s.client.send (send_msg));
|
||||
ASSERT_NO_THROW(s.client.send(send_msg));
|
||||
|
||||
ASSERT_EQ (1, active_poller.wait (std::chrono::milliseconds{-1}));
|
||||
ASSERT_EQ (events, ZMQ_POLLIN);
|
||||
ASSERT_EQ(1, active_poller.wait(std::chrono::milliseconds{-1}));
|
||||
ASSERT_EQ(events, ZMQ_POLLIN);
|
||||
|
||||
// Re-add server socket with pollout flag
|
||||
ASSERT_NO_THROW (active_poller.remove (s.server));
|
||||
ASSERT_NO_THROW (
|
||||
active_poller.add (s.server, ZMQ_POLLIN | ZMQ_POLLOUT, handler));
|
||||
ASSERT_EQ (1, active_poller.wait (std::chrono::milliseconds{-1}));
|
||||
ASSERT_EQ (events, ZMQ_POLLOUT);
|
||||
ASSERT_NO_THROW(active_poller.remove(s.server));
|
||||
ASSERT_NO_THROW(active_poller.add(s.server, ZMQ_POLLIN | ZMQ_POLLOUT, handler));
|
||||
ASSERT_EQ(1, active_poller.wait(std::chrono::milliseconds{-1}));
|
||||
ASSERT_EQ(events, ZMQ_POLLOUT);
|
||||
}
|
||||
|
||||
TEST (active_poller, add_invalid_socket_throws)
|
||||
TEST(active_poller, add_invalid_socket_throws)
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::active_poller_t active_poller;
|
||||
zmq::socket_t a{context, zmq::socket_type::router};
|
||||
zmq::socket_t b{std::move (a)};
|
||||
ASSERT_THROW (
|
||||
active_poller.add (a, ZMQ_POLLIN, zmq::active_poller_t::handler_t{}),
|
||||
zmq::error_t);
|
||||
zmq::socket_t b{std::move(a)};
|
||||
ASSERT_THROW(active_poller.add(a, ZMQ_POLLIN, zmq::active_poller_t::handler_t{}),
|
||||
zmq::error_t);
|
||||
}
|
||||
|
||||
TEST (active_poller, remove_invalid_socket_throws)
|
||||
TEST(active_poller, remove_invalid_socket_throws)
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::socket_t socket{context, zmq::socket_type::router};
|
||||
zmq::active_poller_t active_poller;
|
||||
ASSERT_NO_THROW (active_poller.add (socket, ZMQ_POLLIN,
|
||||
zmq::active_poller_t::handler_t{}));
|
||||
ASSERT_EQ (1u, active_poller.size ());
|
||||
ASSERT_NO_THROW(
|
||||
active_poller.add(socket, ZMQ_POLLIN, zmq::active_poller_t::handler_t{}));
|
||||
ASSERT_EQ(1u, active_poller.size());
|
||||
std::vector<zmq::socket_t> sockets;
|
||||
sockets.emplace_back (std::move (socket));
|
||||
ASSERT_THROW (active_poller.remove (socket), zmq::error_t);
|
||||
ASSERT_EQ (1u, active_poller.size ());
|
||||
sockets.emplace_back(std::move(socket));
|
||||
ASSERT_THROW(active_poller.remove(socket), zmq::error_t);
|
||||
ASSERT_EQ(1u, active_poller.size());
|
||||
}
|
||||
|
||||
TEST (active_poller, wait_on_added_empty_handler)
|
||||
TEST(active_poller, wait_on_added_empty_handler)
|
||||
{
|
||||
server_client_setup s;
|
||||
ASSERT_NO_THROW (s.client.send ("Hi"));
|
||||
ASSERT_NO_THROW(s.client.send("Hi"));
|
||||
zmq::active_poller_t active_poller;
|
||||
zmq::active_poller_t::handler_t handler;
|
||||
ASSERT_NO_THROW (active_poller.add (s.server, ZMQ_POLLIN, handler));
|
||||
ASSERT_NO_THROW (active_poller.wait (std::chrono::milliseconds{-1}));
|
||||
ASSERT_NO_THROW(active_poller.add(s.server, ZMQ_POLLIN, handler));
|
||||
ASSERT_NO_THROW(active_poller.wait(std::chrono::milliseconds{-1}));
|
||||
}
|
||||
|
||||
TEST (active_poller, modify_empty_throws)
|
||||
TEST(active_poller, modify_empty_throws)
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::socket_t socket{context, zmq::socket_type::push};
|
||||
zmq::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::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;
|
||||
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::socket_t a{context, zmq::socket_type::push};
|
||||
zmq::socket_t b{context, zmq::socket_type::push};
|
||||
zmq::active_poller_t active_poller;
|
||||
ASSERT_NO_THROW (
|
||||
active_poller.add (a, ZMQ_POLLIN, zmq::active_poller_t::handler_t{}));
|
||||
ASSERT_THROW (active_poller.modify (b, ZMQ_POLLIN), zmq::error_t);
|
||||
ASSERT_NO_THROW(
|
||||
active_poller.add(a, ZMQ_POLLIN, zmq::active_poller_t::handler_t{}));
|
||||
ASSERT_THROW(active_poller.modify(b, ZMQ_POLLIN), zmq::error_t);
|
||||
}
|
||||
|
||||
TEST (active_poller, modify_simple)
|
||||
TEST(active_poller, modify_simple)
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::socket_t a{context, zmq::socket_type::push};
|
||||
zmq::active_poller_t active_poller;
|
||||
ASSERT_NO_THROW (
|
||||
active_poller.add (a, ZMQ_POLLIN, zmq::active_poller_t::handler_t{}));
|
||||
ASSERT_NO_THROW (active_poller.modify (a, ZMQ_POLLIN | ZMQ_POLLOUT));
|
||||
ASSERT_NO_THROW(
|
||||
active_poller.add(a, ZMQ_POLLIN, zmq::active_poller_t::handler_t{}));
|
||||
ASSERT_NO_THROW(active_poller.modify(a, ZMQ_POLLIN | ZMQ_POLLOUT));
|
||||
}
|
||||
|
||||
TEST (active_poller, poll_client_server)
|
||||
TEST(active_poller, poll_client_server)
|
||||
{
|
||||
// Setup server and client
|
||||
server_client_setup s;
|
||||
|
||||
// Setup active_poller
|
||||
zmq::active_poller_t active_poller;
|
||||
ASSERT_NO_THROW (active_poller.add (s.server, ZMQ_POLLIN, s.handler));
|
||||
ASSERT_NO_THROW(active_poller.add(s.server, ZMQ_POLLIN, s.handler));
|
||||
|
||||
// client sends message
|
||||
ASSERT_NO_THROW (s.client.send ("Hi"));
|
||||
ASSERT_NO_THROW(s.client.send("Hi"));
|
||||
|
||||
// wait for message and verify events
|
||||
ASSERT_NO_THROW (active_poller.wait (std::chrono::milliseconds{500}));
|
||||
ASSERT_EQ (s.events, ZMQ_POLLIN);
|
||||
ASSERT_NO_THROW(active_poller.wait(std::chrono::milliseconds{500}));
|
||||
ASSERT_EQ(s.events, ZMQ_POLLIN);
|
||||
|
||||
// Modify server socket with pollout flag
|
||||
ASSERT_NO_THROW (active_poller.modify (s.server, ZMQ_POLLIN | ZMQ_POLLOUT));
|
||||
ASSERT_EQ (1, active_poller.wait (std::chrono::milliseconds{500}));
|
||||
ASSERT_EQ (s.events, ZMQ_POLLIN | ZMQ_POLLOUT);
|
||||
ASSERT_NO_THROW(active_poller.modify(s.server, ZMQ_POLLIN | ZMQ_POLLOUT));
|
||||
ASSERT_EQ(1, active_poller.wait(std::chrono::milliseconds{500}));
|
||||
ASSERT_EQ(s.events, ZMQ_POLLIN | ZMQ_POLLOUT);
|
||||
}
|
||||
|
||||
TEST (active_poller, wait_one_return)
|
||||
TEST(active_poller, wait_one_return)
|
||||
{
|
||||
// Setup server and client
|
||||
server_client_setup s;
|
||||
@ -316,106 +311,105 @@ TEST (active_poller, wait_one_return)
|
||||
|
||||
// Setup active_poller
|
||||
zmq::active_poller_t active_poller;
|
||||
ASSERT_NO_THROW (
|
||||
active_poller.add (s.server, ZMQ_POLLIN, [&count](short) { ++count; }));
|
||||
ASSERT_NO_THROW(
|
||||
active_poller.add(s.server, ZMQ_POLLIN, [&count](short) { ++count; }));
|
||||
|
||||
// client sends message
|
||||
ASSERT_NO_THROW (s.client.send ("Hi"));
|
||||
ASSERT_NO_THROW(s.client.send("Hi"));
|
||||
|
||||
// wait for message and verify events
|
||||
ASSERT_EQ (1, active_poller.wait (std::chrono::milliseconds{500}));
|
||||
ASSERT_EQ (1u, count);
|
||||
ASSERT_EQ(1, active_poller.wait(std::chrono::milliseconds{500}));
|
||||
ASSERT_EQ(1u, count);
|
||||
}
|
||||
|
||||
TEST (active_poller, wait_on_move_constructed_active_poller)
|
||||
TEST(active_poller, wait_on_move_constructed_active_poller)
|
||||
{
|
||||
server_client_setup s;
|
||||
ASSERT_NO_THROW (s.client.send ("Hi"));
|
||||
ASSERT_NO_THROW(s.client.send("Hi"));
|
||||
zmq::active_poller_t a;
|
||||
zmq::active_poller_t::handler_t handler;
|
||||
ASSERT_NO_THROW (a.add (s.server, ZMQ_POLLIN, handler));
|
||||
zmq::active_poller_t b{std::move (a)};
|
||||
ASSERT_EQ (1u, b.size ());
|
||||
ASSERT_NO_THROW(a.add(s.server, ZMQ_POLLIN, handler));
|
||||
zmq::active_poller_t b{std::move(a)};
|
||||
ASSERT_EQ(1u, b.size());
|
||||
/// \todo the actual error code should be checked
|
||||
ASSERT_THROW (a.wait (std::chrono::milliseconds{10}), zmq::error_t);
|
||||
ASSERT_TRUE (b.wait (std::chrono::milliseconds{-1}));
|
||||
ASSERT_THROW(a.wait(std::chrono::milliseconds{10}), zmq::error_t);
|
||||
ASSERT_TRUE(b.wait(std::chrono::milliseconds{-1}));
|
||||
}
|
||||
|
||||
TEST (active_poller, wait_on_move_assigned_active_poller)
|
||||
TEST(active_poller, wait_on_move_assigned_active_poller)
|
||||
{
|
||||
server_client_setup s;
|
||||
ASSERT_NO_THROW (s.client.send ("Hi"));
|
||||
ASSERT_NO_THROW(s.client.send("Hi"));
|
||||
zmq::active_poller_t a;
|
||||
zmq::active_poller_t::handler_t handler;
|
||||
ASSERT_NO_THROW (a.add (s.server, ZMQ_POLLIN, handler));
|
||||
ASSERT_NO_THROW(a.add(s.server, ZMQ_POLLIN, handler));
|
||||
zmq::active_poller_t b;
|
||||
b = {std::move (a)};
|
||||
ASSERT_EQ (1u, b.size ());
|
||||
b = {std::move(a)};
|
||||
ASSERT_EQ(1u, b.size());
|
||||
/// \todo the actual error code should be checked
|
||||
ASSERT_THROW (a.wait (std::chrono::milliseconds{10}), zmq::error_t);
|
||||
ASSERT_TRUE (b.wait (std::chrono::milliseconds{-1}));
|
||||
ASSERT_THROW(a.wait(std::chrono::milliseconds{10}), zmq::error_t);
|
||||
ASSERT_TRUE(b.wait(std::chrono::milliseconds{-1}));
|
||||
}
|
||||
|
||||
TEST (active_poller, received_on_move_constructed_active_poller)
|
||||
TEST(active_poller, received_on_move_constructed_active_poller)
|
||||
{
|
||||
// Setup server and client
|
||||
server_client_setup s;
|
||||
int count = 0;
|
||||
// Setup active_poller a
|
||||
zmq::active_poller_t a;
|
||||
ASSERT_NO_THROW (
|
||||
a.add (s.server, ZMQ_POLLIN, [&count](short) { ++count; }));
|
||||
ASSERT_NO_THROW(a.add(s.server, ZMQ_POLLIN, [&count](short) { ++count; }));
|
||||
// client sends message
|
||||
ASSERT_NO_THROW (s.client.send ("Hi"));
|
||||
ASSERT_NO_THROW(s.client.send("Hi"));
|
||||
// wait for message and verify it is received
|
||||
ASSERT_EQ (1, a.wait (std::chrono::milliseconds{500}));
|
||||
ASSERT_EQ (1u, count);
|
||||
ASSERT_EQ(1, a.wait(std::chrono::milliseconds{500}));
|
||||
ASSERT_EQ(1u, count);
|
||||
// Move construct active_poller b
|
||||
zmq::active_poller_t b{std::move (a)};
|
||||
zmq::active_poller_t b{std::move(a)};
|
||||
// client sends message again
|
||||
ASSERT_NO_THROW (s.client.send ("Hi"));
|
||||
ASSERT_NO_THROW(s.client.send("Hi"));
|
||||
// wait for message and verify it is received
|
||||
ASSERT_EQ (1, b.wait (std::chrono::milliseconds{500}));
|
||||
ASSERT_EQ (2u, count);
|
||||
ASSERT_EQ(1, b.wait(std::chrono::milliseconds{500}));
|
||||
ASSERT_EQ(2u, count);
|
||||
}
|
||||
|
||||
|
||||
TEST (active_poller, remove_from_handler)
|
||||
TEST(active_poller, remove_from_handler)
|
||||
{
|
||||
constexpr auto ITER_NO = 10;
|
||||
|
||||
// Setup servers and clients
|
||||
std::vector<server_client_setup> setup_list;
|
||||
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
|
||||
zmq::active_poller_t active_poller;
|
||||
int count = 0;
|
||||
for (auto i = 0; i < ITER_NO; ++i) {
|
||||
ASSERT_NO_THROW (active_poller.add (
|
||||
setup_list[i].server, ZMQ_POLLIN, [&, i](short events) {
|
||||
ASSERT_EQ (events, ZMQ_POLLIN);
|
||||
active_poller.remove (setup_list[ITER_NO - i - 1].server);
|
||||
ASSERT_EQ (ITER_NO - i - 1, active_poller.size ());
|
||||
ASSERT_NO_THROW(
|
||||
active_poller.add(setup_list[i].server, ZMQ_POLLIN, [&, i](short events) {
|
||||
ASSERT_EQ(events, ZMQ_POLLIN);
|
||||
active_poller.remove(setup_list[ITER_NO - i - 1].server);
|
||||
ASSERT_EQ(ITER_NO - i - 1, active_poller.size());
|
||||
}));
|
||||
++count;
|
||||
}
|
||||
ASSERT_EQ (ITER_NO, active_poller.size ());
|
||||
ASSERT_EQ(ITER_NO, active_poller.size());
|
||||
// Clients send messages
|
||||
for (auto &s : setup_list) {
|
||||
ASSERT_NO_THROW (s.client.send ("Hi"));
|
||||
ASSERT_NO_THROW(s.client.send("Hi"));
|
||||
}
|
||||
|
||||
// Wait for all servers to receive a message
|
||||
for (auto &s : setup_list) {
|
||||
zmq::pollitem_t items[] = {{s.server, 0, ZMQ_POLLIN, 0}};
|
||||
zmq::poll (&items[0], 1);
|
||||
zmq::poll(&items[0], 1);
|
||||
}
|
||||
|
||||
// Fire all handlers in one wait
|
||||
ASSERT_EQ (ITER_NO, active_poller.wait (std::chrono::milliseconds{-1}));
|
||||
ASSERT_EQ (ITER_NO, count);
|
||||
ASSERT_EQ(ITER_NO, active_poller.wait(std::chrono::milliseconds{-1}));
|
||||
ASSERT_EQ(ITER_NO, count);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@ -1,15 +1,15 @@
|
||||
#include <gtest/gtest.h>
|
||||
#include <zmq.hpp>
|
||||
|
||||
TEST (context, create_default_destroy)
|
||||
TEST(context, create_default_destroy)
|
||||
{
|
||||
zmq::context_t context;
|
||||
}
|
||||
|
||||
TEST (context, create_close)
|
||||
TEST(context, create_close)
|
||||
{
|
||||
zmq::context_t context;
|
||||
context.close ();
|
||||
context.close();
|
||||
|
||||
ASSERT_EQ (NULL, (void *) context);
|
||||
ASSERT_EQ(NULL, (void *) context);
|
||||
}
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
int main (int argc, char **argv)
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
::testing::InitGoogleTest (&argc, argv);
|
||||
return RUN_ALL_TESTS ();
|
||||
::testing::InitGoogleTest(&argc, argv);
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
||||
|
||||
@ -2,119 +2,119 @@
|
||||
#include <zmq.hpp>
|
||||
|
||||
#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_assignable<zmq::message_t>::value,
|
||||
"message_t should not be copy-assignable");
|
||||
static_assert(!std::is_copy_constructible<zmq::message_t>::value,
|
||||
"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
|
||||
|
||||
TEST (message, constructor_default)
|
||||
TEST(message, constructor_default)
|
||||
{
|
||||
const zmq::message_t message;
|
||||
ASSERT_EQ (0u, message.size ());
|
||||
ASSERT_EQ(0u, message.size());
|
||||
}
|
||||
|
||||
const char *const data = "Hi";
|
||||
|
||||
TEST (message, constructor_iterators)
|
||||
TEST(message, constructor_iterators)
|
||||
{
|
||||
const std::string hi (data);
|
||||
const zmq::message_t hi_msg (hi.begin (), hi.end ());
|
||||
ASSERT_EQ (2u, hi_msg.size ());
|
||||
ASSERT_EQ (0, memcmp (data, hi_msg.data (), 2));
|
||||
const std::string hi(data);
|
||||
const zmq::message_t hi_msg(hi.begin(), hi.end());
|
||||
ASSERT_EQ(2u, hi_msg.size());
|
||||
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 zmq::message_t hi_msg (hi.data (), hi.size ());
|
||||
ASSERT_EQ (2u, hi_msg.size ());
|
||||
ASSERT_EQ (0, memcmp (data, hi_msg.data (), 2));
|
||||
const std::string hi(data);
|
||||
const zmq::message_t hi_msg(hi.data(), hi.size());
|
||||
ASSERT_EQ(2u, hi_msg.size());
|
||||
ASSERT_EQ(0, memcmp(data, hi_msg.data(), 2));
|
||||
}
|
||||
|
||||
TEST (message, constructor_char_array)
|
||||
TEST(message, constructor_char_array)
|
||||
{
|
||||
const zmq::message_t hi_msg (data, strlen (data));
|
||||
ASSERT_EQ (2u, hi_msg.size ());
|
||||
ASSERT_EQ (0, memcmp (data, hi_msg.data (), 2));
|
||||
const zmq::message_t hi_msg(data, strlen(data));
|
||||
ASSERT_EQ(2u, hi_msg.size());
|
||||
ASSERT_EQ(0, memcmp(data, hi_msg.data(), 2));
|
||||
}
|
||||
|
||||
#if defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11)
|
||||
TEST (message, constructor_container)
|
||||
TEST(message, constructor_container)
|
||||
{
|
||||
const std::string hi (data);
|
||||
zmq::message_t hi_msg (hi);
|
||||
ASSERT_EQ (2u, hi_msg.size ());
|
||||
ASSERT_EQ (0, memcmp (data, hi_msg.data (), 2));
|
||||
const std::string hi(data);
|
||||
zmq::message_t hi_msg(hi);
|
||||
ASSERT_EQ(2u, hi_msg.size());
|
||||
ASSERT_EQ(0, memcmp(data, hi_msg.data(), 2));
|
||||
}
|
||||
#endif
|
||||
|
||||
#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;
|
||||
hi_msg = zmq::message_t (data, strlen (data));
|
||||
ASSERT_EQ (2u, hi_msg.size ());
|
||||
ASSERT_EQ (0, memcmp (data, hi_msg.data (), 2));
|
||||
hi_msg = zmq::message_t(data, strlen(data));
|
||||
ASSERT_EQ(2u, hi_msg.size());
|
||||
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));
|
||||
hi_msg = zmq::message_t ();
|
||||
ASSERT_EQ (0u, hi_msg.size ());
|
||||
zmq::message_t hi_msg(data, strlen(data));
|
||||
hi_msg = zmq::message_t();
|
||||
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;
|
||||
hi_msg = zmq::message_t ();
|
||||
ASSERT_EQ (0u, hi_msg.size ());
|
||||
hi_msg = zmq::message_t();
|
||||
ASSERT_EQ(0u, hi_msg.size());
|
||||
}
|
||||
#endif
|
||||
|
||||
TEST (message, equality_self)
|
||||
TEST(message, equality_self)
|
||||
{
|
||||
const zmq::message_t hi_msg (data, strlen (data));
|
||||
ASSERT_EQ (hi_msg, hi_msg);
|
||||
const zmq::message_t hi_msg(data, strlen(data));
|
||||
ASSERT_EQ(hi_msg, hi_msg);
|
||||
}
|
||||
|
||||
TEST (message, equality_equal)
|
||||
TEST(message, equality_equal)
|
||||
{
|
||||
const zmq::message_t hi_msg_a (data, strlen (data));
|
||||
const zmq::message_t hi_msg_b (data, strlen (data));
|
||||
ASSERT_EQ (hi_msg_a, hi_msg_b);
|
||||
const zmq::message_t hi_msg_a(data, strlen(data));
|
||||
const zmq::message_t hi_msg_b(data, strlen(data));
|
||||
ASSERT_EQ(hi_msg_a, hi_msg_b);
|
||||
}
|
||||
|
||||
TEST (message, equality_equal_empty)
|
||||
TEST(message, equality_equal_empty)
|
||||
{
|
||||
const zmq::message_t msg_a;
|
||||
const zmq::message_t msg_b;
|
||||
ASSERT_EQ (msg_a, msg_b);
|
||||
ASSERT_EQ(msg_a, msg_b);
|
||||
}
|
||||
|
||||
TEST (message, equality_non_equal)
|
||||
TEST(message, equality_non_equal)
|
||||
{
|
||||
const zmq::message_t msg_a ("Hi", 2);
|
||||
const zmq::message_t msg_b ("Hello", 5);
|
||||
ASSERT_NE (msg_a, msg_b);
|
||||
const zmq::message_t msg_a("Hi", 2);
|
||||
const zmq::message_t msg_b("Hello", 5);
|
||||
ASSERT_NE(msg_a, msg_b);
|
||||
}
|
||||
|
||||
TEST (message, equality_non_equal_rhs_empty)
|
||||
TEST(message, equality_non_equal_rhs_empty)
|
||||
{
|
||||
const zmq::message_t msg_a ("Hi", 2);
|
||||
const zmq::message_t msg_a("Hi", 2);
|
||||
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_b ("Hi", 2);
|
||||
ASSERT_NE (msg_a, msg_b);
|
||||
const zmq::message_t msg_b("Hi", 2);
|
||||
ASSERT_NE(msg_a, msg_b);
|
||||
}
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
#ifdef ZMQ_HAS_RVALUE_REFS
|
||||
/// \todo split this up into separate test cases
|
||||
///
|
||||
TEST (multipart, legacy_test)
|
||||
TEST(multipart, legacy_test)
|
||||
{
|
||||
using namespace zmq;
|
||||
|
||||
@ -16,158 +16,158 @@ TEST (multipart, legacy_test)
|
||||
message_t msg;
|
||||
|
||||
// Create two PAIR sockets and connect over inproc
|
||||
context_t context (1);
|
||||
socket_t output (context, ZMQ_PAIR);
|
||||
socket_t input (context, ZMQ_PAIR);
|
||||
output.bind ("inproc://multipart.test");
|
||||
input.connect ("inproc://multipart.test");
|
||||
context_t context(1);
|
||||
socket_t output(context, ZMQ_PAIR);
|
||||
socket_t input(context, ZMQ_PAIR);
|
||||
output.bind("inproc://multipart.test");
|
||||
input.connect("inproc://multipart.test");
|
||||
|
||||
// Test send and receive of single-frame message
|
||||
multipart_t multipart;
|
||||
assert (multipart.empty ());
|
||||
assert(multipart.empty());
|
||||
|
||||
multipart.push (message_t ("Hello", 5));
|
||||
assert (multipart.size () == 1);
|
||||
multipart.push(message_t("Hello", 5));
|
||||
assert(multipart.size() == 1);
|
||||
|
||||
ok = multipart.send (output);
|
||||
assert (multipart.empty ());
|
||||
assert (ok);
|
||||
ok = multipart.send(output);
|
||||
assert(multipart.empty());
|
||||
assert(ok);
|
||||
|
||||
ok = multipart.recv (input);
|
||||
assert (multipart.size () == 1);
|
||||
assert (ok);
|
||||
ok = multipart.recv(input);
|
||||
assert(multipart.size() == 1);
|
||||
assert(ok);
|
||||
|
||||
msg = multipart.pop ();
|
||||
assert (multipart.empty ());
|
||||
assert (std::string (msg.data<char> (), msg.size ()) == "Hello");
|
||||
msg = multipart.pop();
|
||||
assert(multipart.empty());
|
||||
assert(std::string(msg.data<char>(), msg.size()) == "Hello");
|
||||
|
||||
// Test send and receive of multi-frame message
|
||||
multipart.addstr ("A");
|
||||
multipart.addstr ("BB");
|
||||
multipart.addstr ("CCC");
|
||||
assert (multipart.size () == 3);
|
||||
multipart.addstr("A");
|
||||
multipart.addstr("BB");
|
||||
multipart.addstr("CCC");
|
||||
assert(multipart.size() == 3);
|
||||
|
||||
multipart_t copy = multipart.clone ();
|
||||
assert (copy.size () == 3);
|
||||
multipart_t copy = multipart.clone();
|
||||
assert(copy.size() == 3);
|
||||
|
||||
ok = copy.send (output);
|
||||
assert (copy.empty ());
|
||||
assert (ok);
|
||||
ok = copy.send(output);
|
||||
assert(copy.empty());
|
||||
assert(ok);
|
||||
|
||||
ok = copy.recv (input);
|
||||
assert (copy.size () == 3);
|
||||
assert (ok);
|
||||
assert (copy.equal (&multipart));
|
||||
ok = copy.recv(input);
|
||||
assert(copy.size() == 3);
|
||||
assert(ok);
|
||||
assert(copy.equal(&multipart));
|
||||
|
||||
multipart.clear ();
|
||||
assert (multipart.empty ());
|
||||
multipart.clear();
|
||||
assert(multipart.empty());
|
||||
|
||||
// Test message frame manipulation
|
||||
multipart.add (message_t ("Frame5", 6));
|
||||
multipart.addstr ("Frame6");
|
||||
multipart.addstr ("Frame7");
|
||||
multipart.addtyp (8.0f);
|
||||
multipart.addmem ("Frame9", 6);
|
||||
multipart.push (message_t ("Frame4", 6));
|
||||
multipart.pushstr ("Frame3");
|
||||
multipart.pushstr ("Frame2");
|
||||
multipart.pushtyp (1.0f);
|
||||
multipart.pushmem ("Frame0", 6);
|
||||
assert (multipart.size () == 10);
|
||||
multipart.add(message_t("Frame5", 6));
|
||||
multipart.addstr("Frame6");
|
||||
multipart.addstr("Frame7");
|
||||
multipart.addtyp(8.0f);
|
||||
multipart.addmem("Frame9", 6);
|
||||
multipart.push(message_t("Frame4", 6));
|
||||
multipart.pushstr("Frame3");
|
||||
multipart.pushstr("Frame2");
|
||||
multipart.pushtyp(1.0f);
|
||||
multipart.pushmem("Frame0", 6);
|
||||
assert(multipart.size() == 10);
|
||||
|
||||
msg = multipart.remove ();
|
||||
assert (multipart.size () == 9);
|
||||
assert (std::string (msg.data<char> (), msg.size ()) == "Frame9");
|
||||
msg = multipart.remove();
|
||||
assert(multipart.size() == 9);
|
||||
assert(std::string(msg.data<char>(), msg.size()) == "Frame9");
|
||||
|
||||
msg = multipart.pop ();
|
||||
assert (multipart.size () == 8);
|
||||
assert (std::string (msg.data<char> (), msg.size ()) == "Frame0");
|
||||
msg = multipart.pop();
|
||||
assert(multipart.size() == 8);
|
||||
assert(std::string(msg.data<char>(), msg.size()) == "Frame0");
|
||||
|
||||
num = multipart.poptyp<float> ();
|
||||
assert (multipart.size () == 7);
|
||||
assert (num == 1.0f);
|
||||
num = multipart.poptyp<float>();
|
||||
assert(multipart.size() == 7);
|
||||
assert(num == 1.0f);
|
||||
|
||||
str = multipart.popstr ();
|
||||
assert (multipart.size () == 6);
|
||||
assert (str == "Frame2");
|
||||
str = multipart.popstr();
|
||||
assert(multipart.size() == 6);
|
||||
assert(str == "Frame2");
|
||||
|
||||
str = multipart.popstr ();
|
||||
assert (multipart.size () == 5);
|
||||
assert (str == "Frame3");
|
||||
str = multipart.popstr();
|
||||
assert(multipart.size() == 5);
|
||||
assert(str == "Frame3");
|
||||
|
||||
str = multipart.popstr ();
|
||||
assert (multipart.size () == 4);
|
||||
assert (str == "Frame4");
|
||||
str = multipart.popstr();
|
||||
assert(multipart.size() == 4);
|
||||
assert(str == "Frame4");
|
||||
|
||||
str = multipart.popstr ();
|
||||
assert (multipart.size () == 3);
|
||||
assert (str == "Frame5");
|
||||
str = multipart.popstr();
|
||||
assert(multipart.size() == 3);
|
||||
assert(str == "Frame5");
|
||||
|
||||
str = multipart.popstr ();
|
||||
assert (multipart.size () == 2);
|
||||
assert (str == "Frame6");
|
||||
str = multipart.popstr();
|
||||
assert(multipart.size() == 2);
|
||||
assert(str == "Frame6");
|
||||
|
||||
str = multipart.popstr ();
|
||||
assert (multipart.size () == 1);
|
||||
assert (str == "Frame7");
|
||||
str = multipart.popstr();
|
||||
assert(multipart.size() == 1);
|
||||
assert(str == "Frame7");
|
||||
|
||||
num = multipart.poptyp<float> ();
|
||||
assert (multipart.empty ());
|
||||
assert (num == 8.0f);
|
||||
num = multipart.poptyp<float>();
|
||||
assert(multipart.empty());
|
||||
assert(num == 8.0f);
|
||||
|
||||
// Test message constructors and concatenation
|
||||
multipart_t head ("One", 3);
|
||||
head.addstr ("Two");
|
||||
assert (head.size () == 2);
|
||||
multipart_t head("One", 3);
|
||||
head.addstr("Two");
|
||||
assert(head.size() == 2);
|
||||
|
||||
multipart_t tail (std::string ("One-hundred"));
|
||||
tail.pushstr ("Ninety-nine");
|
||||
assert (tail.size () == 2);
|
||||
multipart_t tail(std::string("One-hundred"));
|
||||
tail.pushstr("Ninety-nine");
|
||||
assert(tail.size() == 2);
|
||||
|
||||
multipart_t tmp (message_t ("Fifty", 5));
|
||||
assert (tmp.size () == 1);
|
||||
multipart_t tmp(message_t("Fifty", 5));
|
||||
assert(tmp.size() == 1);
|
||||
|
||||
multipart_t mid = multipart_t::create (49.0f);
|
||||
mid.append (std::move (tmp));
|
||||
assert (mid.size () == 2);
|
||||
assert (tmp.empty ());
|
||||
multipart_t mid = multipart_t::create(49.0f);
|
||||
mid.append(std::move(tmp));
|
||||
assert(mid.size() == 2);
|
||||
assert(tmp.empty());
|
||||
|
||||
multipart_t merged (std::move (mid));
|
||||
merged.prepend (std::move (head));
|
||||
merged.append (std::move (tail));
|
||||
assert (merged.size () == 6);
|
||||
assert (head.empty ());
|
||||
assert (tail.empty ());
|
||||
multipart_t merged(std::move(mid));
|
||||
merged.prepend(std::move(head));
|
||||
merged.append(std::move(tail));
|
||||
assert(merged.size() == 6);
|
||||
assert(head.empty());
|
||||
assert(tail.empty());
|
||||
|
||||
ok = merged.send (output);
|
||||
assert (merged.empty ());
|
||||
assert (ok);
|
||||
ok = merged.send(output);
|
||||
assert(merged.empty());
|
||||
assert(ok);
|
||||
|
||||
multipart_t received (input);
|
||||
assert (received.size () == 6);
|
||||
multipart_t received(input);
|
||||
assert(received.size() == 6);
|
||||
|
||||
str = received.popstr ();
|
||||
assert (received.size () == 5);
|
||||
assert (str == "One");
|
||||
str = received.popstr();
|
||||
assert(received.size() == 5);
|
||||
assert(str == "One");
|
||||
|
||||
str = received.popstr ();
|
||||
assert (received.size () == 4);
|
||||
assert (str == "Two");
|
||||
str = received.popstr();
|
||||
assert(received.size() == 4);
|
||||
assert(str == "Two");
|
||||
|
||||
num = received.poptyp<float> ();
|
||||
assert (received.size () == 3);
|
||||
assert (num == 49.0f);
|
||||
num = received.poptyp<float>();
|
||||
assert(received.size() == 3);
|
||||
assert(num == 49.0f);
|
||||
|
||||
str = received.popstr ();
|
||||
assert (received.size () == 2);
|
||||
assert (str == "Fifty");
|
||||
str = received.popstr();
|
||||
assert(received.size() == 2);
|
||||
assert(str == "Fifty");
|
||||
|
||||
str = received.popstr ();
|
||||
assert (received.size () == 1);
|
||||
assert (str == "Ninety-nine");
|
||||
str = received.popstr();
|
||||
assert(received.size() == 1);
|
||||
assert(str == "Ninety-nine");
|
||||
|
||||
str = received.popstr ();
|
||||
assert (received.empty ());
|
||||
assert (str == "One-hundred");
|
||||
str = received.popstr();
|
||||
assert(received.empty());
|
||||
assert(str == "One-hundred");
|
||||
}
|
||||
#endif
|
||||
|
||||
194
tests/poller.cpp
194
tests/poller.cpp
@ -5,68 +5,68 @@
|
||||
#include <array>
|
||||
#include <memory>
|
||||
|
||||
TEST (poller, create_destroy)
|
||||
TEST(poller, create_destroy)
|
||||
{
|
||||
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_assignable<zmq::poller_t<>>::value,
|
||||
"poller_t should not be copy-assignable");
|
||||
static_assert(!std::is_copy_constructible<zmq::poller_t<>>::value,
|
||||
"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<> 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<> b;
|
||||
b = std::move (a);
|
||||
b = std::move(a);
|
||||
}
|
||||
|
||||
TEST (poller, move_construct_non_empty)
|
||||
TEST(poller, move_construct_non_empty)
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::socket_t socket{context, zmq::socket_type::router};
|
||||
|
||||
zmq::poller_t<> a;
|
||||
a.add (socket, ZMQ_POLLIN, nullptr);
|
||||
zmq::poller_t<> b = std::move (a);
|
||||
a.add(socket, ZMQ_POLLIN, nullptr);
|
||||
zmq::poller_t<> b = std::move(a);
|
||||
}
|
||||
|
||||
TEST (poller, move_assign_non_empty)
|
||||
TEST(poller, move_assign_non_empty)
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::socket_t socket{context, zmq::socket_type::router};
|
||||
|
||||
zmq::poller_t<> a;
|
||||
a.add (socket, ZMQ_POLLIN, nullptr);
|
||||
a.add(socket, ZMQ_POLLIN, nullptr);
|
||||
zmq::poller_t<> b;
|
||||
b = std::move (a);
|
||||
b = std::move(a);
|
||||
}
|
||||
|
||||
TEST (poller, add_nullptr)
|
||||
TEST(poller, add_nullptr)
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::socket_t socket{context, zmq::socket_type::router};
|
||||
zmq::poller_t<> poller;
|
||||
ASSERT_NO_THROW (poller.add (socket, ZMQ_POLLIN, nullptr));
|
||||
ASSERT_NO_THROW(poller.add(socket, ZMQ_POLLIN, nullptr));
|
||||
}
|
||||
|
||||
TEST (poller, add_non_nullptr)
|
||||
TEST(poller, add_non_nullptr)
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::socket_t socket{context, zmq::socket_type::router};
|
||||
zmq::poller_t<> poller;
|
||||
int i;
|
||||
ASSERT_NO_THROW (poller.add (socket, ZMQ_POLLIN, &i));
|
||||
ASSERT_NO_THROW(poller.add(socket, ZMQ_POLLIN, &i));
|
||||
}
|
||||
|
||||
TEST (poller, add_handler_invalid_events_type)
|
||||
TEST(poller, add_handler_invalid_events_type)
|
||||
{
|
||||
/// \todo is it good that this is accepted? should probably already be
|
||||
/// 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::poller_t<> poller;
|
||||
short invalid_events_type = 2 << 10;
|
||||
ASSERT_NO_THROW (poller.add (socket, invalid_events_type, nullptr));
|
||||
ASSERT_NO_THROW(poller.add(socket, invalid_events_type, nullptr));
|
||||
}
|
||||
|
||||
TEST (poller, add_handler_twice_throws)
|
||||
TEST(poller, add_handler_twice_throws)
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::socket_t socket{context, zmq::socket_type::router};
|
||||
zmq::poller_t<> poller;
|
||||
poller.add (socket, ZMQ_POLLIN, nullptr);
|
||||
poller.add(socket, ZMQ_POLLIN, nullptr);
|
||||
/// \todo the actual error code should be checked
|
||||
ASSERT_THROW (poller.add (socket, ZMQ_POLLIN, nullptr), zmq::error_t);
|
||||
ASSERT_THROW(poller.add(socket, ZMQ_POLLIN, nullptr), zmq::error_t);
|
||||
}
|
||||
|
||||
TEST (poller, wait_with_no_handlers_throws)
|
||||
TEST(poller, wait_with_no_handlers_throws)
|
||||
{
|
||||
zmq::poller_t<> poller;
|
||||
std::vector<zmq_poller_event_t> events;
|
||||
/// \todo the actual error code should be checked
|
||||
ASSERT_THROW (poller.wait_all (events, std::chrono::milliseconds{10}),
|
||||
zmq::error_t);
|
||||
ASSERT_THROW(poller.wait_all(events, std::chrono::milliseconds{10}),
|
||||
zmq::error_t);
|
||||
}
|
||||
|
||||
TEST (poller, remove_unregistered_throws)
|
||||
TEST(poller, remove_unregistered_throws)
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::socket_t socket{context, zmq::socket_type::router};
|
||||
zmq::poller_t<> poller;
|
||||
/// \todo the actual error code should be checked
|
||||
ASSERT_THROW (poller.remove (socket), zmq::error_t);
|
||||
ASSERT_THROW(poller.remove(socket), zmq::error_t);
|
||||
}
|
||||
|
||||
TEST (poller, remove_registered_empty)
|
||||
TEST(poller, remove_registered_empty)
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::socket_t socket{context, zmq::socket_type::router};
|
||||
zmq::poller_t<> poller;
|
||||
poller.add (socket, ZMQ_POLLIN, nullptr);
|
||||
ASSERT_NO_THROW (poller.remove (socket));
|
||||
poller.add(socket, ZMQ_POLLIN, nullptr);
|
||||
ASSERT_NO_THROW(poller.remove(socket));
|
||||
}
|
||||
|
||||
TEST (poller, remove_registered_non_empty)
|
||||
TEST(poller, remove_registered_non_empty)
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::socket_t socket{context, zmq::socket_type::router};
|
||||
zmq::poller_t<> poller;
|
||||
poller.add (socket, ZMQ_POLLIN, nullptr);
|
||||
ASSERT_NO_THROW (poller.remove (socket));
|
||||
poller.add(socket, ZMQ_POLLIN, nullptr);
|
||||
ASSERT_NO_THROW(poller.remove(socket));
|
||||
}
|
||||
|
||||
TEST (poller, poll_basic)
|
||||
TEST(poller, poll_basic)
|
||||
{
|
||||
common_server_client_setup s;
|
||||
|
||||
ASSERT_NO_THROW (s.client.send ("Hi"));
|
||||
ASSERT_NO_THROW(s.client.send("Hi"));
|
||||
|
||||
zmq::poller_t<int> poller;
|
||||
std::vector<zmq_poller_event_t> events{1};
|
||||
int i = 0;
|
||||
ASSERT_NO_THROW (poller.add (s.server, ZMQ_POLLIN, &i));
|
||||
ASSERT_EQ (1, poller.wait_all (events, std::chrono::milliseconds{-1}));
|
||||
ASSERT_EQ (s.server, events[0].socket);
|
||||
ASSERT_EQ (&i, events[0].user_data);
|
||||
ASSERT_NO_THROW(poller.add(s.server, ZMQ_POLLIN, &i));
|
||||
ASSERT_EQ(1, poller.wait_all(events, std::chrono::milliseconds{-1}));
|
||||
ASSERT_EQ(s.server, events[0].socket);
|
||||
ASSERT_EQ(&i, events[0].user_data);
|
||||
}
|
||||
|
||||
TEST (poller, add_invalid_socket_throws)
|
||||
TEST(poller, add_invalid_socket_throws)
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::poller_t<> poller;
|
||||
zmq::socket_t a{context, zmq::socket_type::router};
|
||||
zmq::socket_t b{std::move (a)};
|
||||
ASSERT_THROW (poller.add (a, ZMQ_POLLIN, nullptr), zmq::error_t);
|
||||
zmq::socket_t b{std::move(a)};
|
||||
ASSERT_THROW(poller.add(a, ZMQ_POLLIN, nullptr), zmq::error_t);
|
||||
}
|
||||
|
||||
TEST (poller, remove_invalid_socket_throws)
|
||||
TEST(poller, remove_invalid_socket_throws)
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::socket_t socket{context, zmq::socket_type::router};
|
||||
zmq::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;
|
||||
sockets.emplace_back (std::move (socket));
|
||||
ASSERT_THROW (poller.remove (socket), zmq::error_t);
|
||||
ASSERT_NO_THROW (poller.remove (sockets[0]));
|
||||
sockets.emplace_back(std::move(socket));
|
||||
ASSERT_THROW(poller.remove(socket), zmq::error_t);
|
||||
ASSERT_NO_THROW(poller.remove(sockets[0]));
|
||||
}
|
||||
|
||||
TEST (poller, modify_empty_throws)
|
||||
TEST(poller, modify_empty_throws)
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::socket_t socket{context, zmq::socket_type::push};
|
||||
zmq::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::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;
|
||||
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::socket_t a{context, zmq::socket_type::push};
|
||||
zmq::socket_t b{context, zmq::socket_type::push};
|
||||
zmq::poller_t<> poller;
|
||||
ASSERT_NO_THROW (poller.add (a, ZMQ_POLLIN, nullptr));
|
||||
ASSERT_THROW (poller.modify (b, ZMQ_POLLIN), zmq::error_t);
|
||||
ASSERT_NO_THROW(poller.add(a, ZMQ_POLLIN, nullptr));
|
||||
ASSERT_THROW(poller.modify(b, ZMQ_POLLIN), zmq::error_t);
|
||||
}
|
||||
|
||||
TEST (poller, modify_simple)
|
||||
TEST(poller, modify_simple)
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::socket_t a{context, zmq::socket_type::push};
|
||||
zmq::poller_t<> poller;
|
||||
ASSERT_NO_THROW (poller.add (a, ZMQ_POLLIN, nullptr));
|
||||
ASSERT_NO_THROW (poller.modify (a, ZMQ_POLLIN | ZMQ_POLLOUT));
|
||||
ASSERT_NO_THROW(poller.add(a, ZMQ_POLLIN, nullptr));
|
||||
ASSERT_NO_THROW(poller.modify(a, ZMQ_POLLIN | ZMQ_POLLOUT));
|
||||
}
|
||||
|
||||
TEST (poller, poll_client_server)
|
||||
TEST(poller, poll_client_server)
|
||||
{
|
||||
// Setup server and client
|
||||
common_server_client_setup s;
|
||||
|
||||
// Setup poller
|
||||
zmq::poller_t<> poller;
|
||||
ASSERT_NO_THROW (poller.add (s.server, ZMQ_POLLIN, s.server));
|
||||
ASSERT_NO_THROW(poller.add(s.server, ZMQ_POLLIN, s.server));
|
||||
|
||||
// client sends message
|
||||
ASSERT_NO_THROW (s.client.send ("Hi"));
|
||||
ASSERT_NO_THROW(s.client.send("Hi"));
|
||||
|
||||
// wait for message and verify events
|
||||
std::vector<zmq_poller_event_t> events (1);
|
||||
ASSERT_EQ (1, poller.wait_all (events, std::chrono::milliseconds{500}));
|
||||
ASSERT_EQ (ZMQ_POLLIN, events[0].events);
|
||||
std::vector<zmq_poller_event_t> events(1);
|
||||
ASSERT_EQ(1, poller.wait_all(events, std::chrono::milliseconds{500}));
|
||||
ASSERT_EQ(ZMQ_POLLIN, events[0].events);
|
||||
|
||||
// Modify server socket with pollout flag
|
||||
ASSERT_NO_THROW (poller.modify (s.server, ZMQ_POLLIN | ZMQ_POLLOUT));
|
||||
ASSERT_EQ (1, poller.wait_all (events, std::chrono::milliseconds{500}));
|
||||
ASSERT_EQ (ZMQ_POLLIN | ZMQ_POLLOUT, events[0].events);
|
||||
ASSERT_NO_THROW(poller.modify(s.server, ZMQ_POLLIN | ZMQ_POLLOUT));
|
||||
ASSERT_EQ(1, poller.wait_all(events, std::chrono::milliseconds{500}));
|
||||
ASSERT_EQ(ZMQ_POLLIN | ZMQ_POLLOUT, events[0].events);
|
||||
}
|
||||
|
||||
TEST (poller, wait_one_return)
|
||||
TEST(poller, wait_one_return)
|
||||
{
|
||||
// Setup server and client
|
||||
common_server_client_setup s;
|
||||
|
||||
// Setup poller
|
||||
zmq::poller_t<> poller;
|
||||
ASSERT_NO_THROW (poller.add (s.server, ZMQ_POLLIN, nullptr));
|
||||
ASSERT_NO_THROW(poller.add(s.server, ZMQ_POLLIN, nullptr));
|
||||
|
||||
// client sends message
|
||||
ASSERT_NO_THROW (s.client.send ("Hi"));
|
||||
ASSERT_NO_THROW(s.client.send("Hi"));
|
||||
|
||||
// wait for message and verify events
|
||||
std::vector<zmq_poller_event_t> events (1);
|
||||
ASSERT_EQ (1, poller.wait_all (events, std::chrono::milliseconds{500}));
|
||||
std::vector<zmq_poller_event_t> events(1);
|
||||
ASSERT_EQ(1, poller.wait_all(events, std::chrono::milliseconds{500}));
|
||||
}
|
||||
|
||||
TEST (poller, wait_on_move_constructed_poller)
|
||||
TEST(poller, wait_on_move_constructed_poller)
|
||||
{
|
||||
common_server_client_setup s;
|
||||
ASSERT_NO_THROW (s.client.send ("Hi"));
|
||||
ASSERT_NO_THROW(s.client.send("Hi"));
|
||||
zmq::poller_t<> a;
|
||||
ASSERT_NO_THROW (a.add (s.server, ZMQ_POLLIN, nullptr));
|
||||
zmq::poller_t<> b{std::move (a)};
|
||||
std::vector<zmq_poller_event_t> events (1);
|
||||
ASSERT_NO_THROW(a.add(s.server, ZMQ_POLLIN, nullptr));
|
||||
zmq::poller_t<> b{std::move(a)};
|
||||
std::vector<zmq_poller_event_t> events(1);
|
||||
/// \todo the actual error code should be checked
|
||||
ASSERT_THROW (a.wait_all (events, std::chrono::milliseconds{10}),
|
||||
zmq::error_t);
|
||||
ASSERT_EQ (1, b.wait_all (events, std::chrono::milliseconds{-1}));
|
||||
ASSERT_THROW(a.wait_all(events, std::chrono::milliseconds{10}), zmq::error_t);
|
||||
ASSERT_EQ(1, b.wait_all(events, std::chrono::milliseconds{-1}));
|
||||
}
|
||||
|
||||
TEST (poller, wait_on_move_assigned_poller)
|
||||
TEST(poller, wait_on_move_assigned_poller)
|
||||
{
|
||||
common_server_client_setup s;
|
||||
ASSERT_NO_THROW (s.client.send ("Hi"));
|
||||
ASSERT_NO_THROW(s.client.send("Hi"));
|
||||
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;
|
||||
b = {std::move (a)};
|
||||
b = {std::move(a)};
|
||||
/// \todo the actual error code should be checked
|
||||
std::vector<zmq_poller_event_t> events (1);
|
||||
ASSERT_THROW (a.wait_all (events, std::chrono::milliseconds{10}),
|
||||
zmq::error_t);
|
||||
ASSERT_EQ (1, b.wait_all (events, std::chrono::milliseconds{-1}));
|
||||
std::vector<zmq_poller_event_t> events(1);
|
||||
ASSERT_THROW(a.wait_all(events, std::chrono::milliseconds{10}), zmq::error_t);
|
||||
ASSERT_EQ(1, b.wait_all(events, std::chrono::milliseconds{-1}));
|
||||
}
|
||||
|
||||
TEST (poller, remove_from_handler)
|
||||
TEST(poller, remove_from_handler)
|
||||
{
|
||||
constexpr auto ITER_NO = 10;
|
||||
|
||||
// Setup servers and clients
|
||||
std::vector<common_server_client_setup> setup_list;
|
||||
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
|
||||
zmq::poller_t<> poller;
|
||||
for (auto i = 0; i < ITER_NO; ++i) {
|
||||
ASSERT_NO_THROW (
|
||||
poller.add (setup_list[i].server, ZMQ_POLLIN, nullptr));
|
||||
ASSERT_NO_THROW(poller.add(setup_list[i].server, ZMQ_POLLIN, nullptr));
|
||||
}
|
||||
// Clients send messages
|
||||
for (auto &s : setup_list) {
|
||||
ASSERT_NO_THROW (s.client.send ("Hi"));
|
||||
ASSERT_NO_THROW(s.client.send("Hi"));
|
||||
}
|
||||
|
||||
// Wait for all servers to receive a message
|
||||
for (auto &s : setup_list) {
|
||||
zmq::pollitem_t items[] = {{s.server, 0, ZMQ_POLLIN, 0}};
|
||||
zmq::poll (&items[0], 1);
|
||||
zmq::poll(&items[0], 1);
|
||||
}
|
||||
|
||||
// Fire all handlers in one wait
|
||||
std::vector<zmq_poller_event_t> events (ITER_NO);
|
||||
ASSERT_EQ (ITER_NO,
|
||||
poller.wait_all (events, std::chrono::milliseconds{-1}));
|
||||
std::vector<zmq_poller_event_t> events(ITER_NO);
|
||||
ASSERT_EQ(ITER_NO, poller.wait_all(events, std::chrono::milliseconds{-1}));
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@ -1,16 +1,16 @@
|
||||
#include <gtest/gtest.h>
|
||||
#include <zmq.hpp>
|
||||
|
||||
TEST (socket, create_destroy)
|
||||
TEST(socket, create_destroy)
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::socket_t socket (context, ZMQ_ROUTER);
|
||||
zmq::socket_t socket(context, ZMQ_ROUTER);
|
||||
}
|
||||
|
||||
#ifdef ZMQ_CPP11
|
||||
TEST (socket, create_by_enum_destroy)
|
||||
TEST(socket, create_by_enum_destroy)
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::socket_t socket (context, zmq::socket_type::router);
|
||||
zmq::socket_t socket(context, zmq::socket_type::router);
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -8,10 +8,11 @@
|
||||
|
||||
class loopback_ip4_binder
|
||||
{
|
||||
public:
|
||||
public:
|
||||
loopback_ip4_binder(zmq::socket_t &socket) { bind(socket); }
|
||||
std::string endpoint() { return endpoint_; }
|
||||
private:
|
||||
|
||||
private:
|
||||
// Helper function used in constructor
|
||||
// as Gtest allows ASSERT_* only in void returning functions
|
||||
// and constructor/destructor are not.
|
||||
@ -20,8 +21,8 @@ private:
|
||||
ASSERT_NO_THROW(socket.bind("tcp://127.0.0.1:*"));
|
||||
std::array<char, 100> endpoint{};
|
||||
size_t endpoint_size = endpoint.size();
|
||||
ASSERT_NO_THROW(socket.getsockopt(ZMQ_LAST_ENDPOINT, endpoint.data(),
|
||||
&endpoint_size));
|
||||
ASSERT_NO_THROW(
|
||||
socket.getsockopt(ZMQ_LAST_ENDPOINT, endpoint.data(), &endpoint_size));
|
||||
ASSERT_TRUE(endpoint_size < endpoint.size());
|
||||
endpoint_ = std::string{endpoint.data()};
|
||||
}
|
||||
@ -30,20 +31,17 @@ private:
|
||||
|
||||
struct common_server_client_setup
|
||||
{
|
||||
common_server_client_setup ()
|
||||
{
|
||||
init ();
|
||||
}
|
||||
common_server_client_setup() { init(); }
|
||||
|
||||
void init()
|
||||
{
|
||||
endpoint = loopback_ip4_binder {server}.endpoint ();
|
||||
ASSERT_NO_THROW (client.connect (endpoint));
|
||||
endpoint = loopback_ip4_binder{server}.endpoint();
|
||||
ASSERT_NO_THROW(client.connect(endpoint));
|
||||
}
|
||||
|
||||
zmq::context_t context;
|
||||
zmq::socket_t server {context, zmq::socket_type::server};
|
||||
zmq::socket_t client {context, zmq::socket_type::client};
|
||||
zmq::socket_t server{context, zmq::socket_type::server};
|
||||
zmq::socket_t client{context, zmq::socket_type::client};
|
||||
std::string endpoint;
|
||||
};
|
||||
#endif
|
||||
|
||||
296
zmq_addon.hpp
296
zmq_addon.hpp
@ -52,252 +52,246 @@ class multipart_t
|
||||
typedef std::deque<message_t>::const_iterator const_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
|
||||
multipart_t () {}
|
||||
multipart_t() {}
|
||||
|
||||
// Construct from socket receive
|
||||
multipart_t (socket_t &socket) { recv (socket); }
|
||||
multipart_t(socket_t &socket) { recv(socket); }
|
||||
|
||||
// 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
|
||||
multipart_t (const std::string &string) { addstr (string); }
|
||||
multipart_t(const std::string &string) { addstr(string); }
|
||||
|
||||
// Construct from message part
|
||||
multipart_t (message_t &&message) { add (std::move (message)); }
|
||||
multipart_t(message_t &&message) { add(std::move(message)); }
|
||||
|
||||
// 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
|
||||
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;
|
||||
}
|
||||
|
||||
// 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
|
||||
void clear () { m_parts.clear (); }
|
||||
void clear() { m_parts.clear(); }
|
||||
|
||||
// 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
|
||||
bool empty () const { return m_parts.empty (); }
|
||||
bool empty() const { return m_parts.empty(); }
|
||||
|
||||
// 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;
|
||||
while (more) {
|
||||
message_t message;
|
||||
if (!socket.recv (&message, flags))
|
||||
if (!socket.recv(&message, flags))
|
||||
return false;
|
||||
more = message.more ();
|
||||
add (std::move (message));
|
||||
more = message.more();
|
||||
add(std::move(message));
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// Send multipart message to socket
|
||||
bool send (socket_t &socket, int flags = 0)
|
||||
bool send(socket_t &socket, int flags = 0)
|
||||
{
|
||||
flags &= ~(ZMQ_SNDMORE);
|
||||
bool more = size () > 0;
|
||||
bool more = size() > 0;
|
||||
while (more) {
|
||||
message_t message = pop ();
|
||||
more = size () > 0;
|
||||
if (!socket.send (message, (more ? ZMQ_SNDMORE : 0) | flags))
|
||||
message_t message = pop();
|
||||
more = size() > 0;
|
||||
if (!socket.send(message, (more ? ZMQ_SNDMORE : 0) | flags))
|
||||
return false;
|
||||
}
|
||||
clear ();
|
||||
clear();
|
||||
return true;
|
||||
}
|
||||
|
||||
// Concatenate other multipart to front
|
||||
void prepend (multipart_t &&other)
|
||||
void prepend(multipart_t &&other)
|
||||
{
|
||||
while (!other.empty ())
|
||||
push (other.remove ());
|
||||
while (!other.empty())
|
||||
push(other.remove());
|
||||
}
|
||||
|
||||
// Concatenate other multipart to back
|
||||
void append (multipart_t &&other)
|
||||
void append(multipart_t &&other)
|
||||
{
|
||||
while (!other.empty ())
|
||||
add (other.pop ());
|
||||
while (!other.empty())
|
||||
add(other.pop());
|
||||
}
|
||||
|
||||
// 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
|
||||
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
|
||||
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
|
||||
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
|
||||
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,
|
||||
"Use pushstr() instead of pushtyp<std::string>()");
|
||||
m_parts.push_front (message_t (&type, sizeof (type)));
|
||||
static_assert(!std::is_same<T, std::string>::value,
|
||||
"Use pushstr() instead of pushtyp<std::string>()");
|
||||
m_parts.push_front(message_t(&type, sizeof(type)));
|
||||
}
|
||||
|
||||
// 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,
|
||||
"Use addstr() instead of addtyp<std::string>()");
|
||||
m_parts.push_back (message_t (&type, sizeof (type)));
|
||||
static_assert(!std::is_same<T, std::string>::value,
|
||||
"Use addstr() instead of addtyp<std::string>()");
|
||||
m_parts.push_back(message_t(&type, sizeof(type)));
|
||||
}
|
||||
|
||||
// Push message part to front
|
||||
void push (message_t &&message)
|
||||
{
|
||||
m_parts.push_front (std::move (message));
|
||||
}
|
||||
void push(message_t &&message) { m_parts.push_front(std::move(message)); }
|
||||
|
||||
// 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
|
||||
std::string popstr ()
|
||||
std::string popstr()
|
||||
{
|
||||
std::string string (m_parts.front ().data<char> (),
|
||||
m_parts.front ().size ());
|
||||
m_parts.pop_front ();
|
||||
std::string string(m_parts.front().data<char>(), m_parts.front().size());
|
||||
m_parts.pop_front();
|
||||
return string;
|
||||
}
|
||||
|
||||
// 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,
|
||||
"Use popstr() instead of poptyp<std::string>()");
|
||||
if (sizeof (T) != m_parts.front ().size ())
|
||||
throw std::runtime_error (
|
||||
static_assert(!std::is_same<T, std::string>::value,
|
||||
"Use popstr() instead of poptyp<std::string>()");
|
||||
if (sizeof(T) != m_parts.front().size())
|
||||
throw std::runtime_error(
|
||||
"Invalid type, size does not match the message size");
|
||||
T type = *m_parts.front ().data<T> ();
|
||||
m_parts.pop_front ();
|
||||
T type = *m_parts.front().data<T>();
|
||||
m_parts.pop_front();
|
||||
return type;
|
||||
}
|
||||
|
||||
// Pop message part from front
|
||||
message_t pop ()
|
||||
message_t pop()
|
||||
{
|
||||
message_t message = std::move (m_parts.front ());
|
||||
m_parts.pop_front ();
|
||||
message_t message = std::move(m_parts.front());
|
||||
m_parts.pop_front();
|
||||
return message;
|
||||
}
|
||||
|
||||
// Pop message part from back
|
||||
message_t remove ()
|
||||
message_t remove()
|
||||
{
|
||||
message_t message = std::move (m_parts.back ());
|
||||
m_parts.pop_back ();
|
||||
message_t message = std::move(m_parts.back());
|
||||
m_parts.pop_back();
|
||||
return message;
|
||||
}
|
||||
|
||||
// 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
|
||||
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;
|
||||
}
|
||||
|
||||
// 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,
|
||||
"Use peekstr() instead of peektyp<std::string>()");
|
||||
if (sizeof (T) != m_parts[index].size ())
|
||||
throw std::runtime_error (
|
||||
static_assert(!std::is_same<T, std::string>::value,
|
||||
"Use peekstr() instead of peektyp<std::string>()");
|
||||
if (sizeof(T) != m_parts[index].size())
|
||||
throw std::runtime_error(
|
||||
"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;
|
||||
}
|
||||
|
||||
// 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.addtyp (type);
|
||||
multipart.addtyp(type);
|
||||
return multipart;
|
||||
}
|
||||
|
||||
// Copy multipart
|
||||
multipart_t clone () const
|
||||
multipart_t clone() const
|
||||
{
|
||||
multipart_t multipart;
|
||||
for (size_t i = 0; i < size (); i++)
|
||||
multipart.addmem (m_parts[i].data (), m_parts[i].size ());
|
||||
for (size_t i = 0; i < size(); i++)
|
||||
multipart.addmem(m_parts[i].data(), m_parts[i].size());
|
||||
return multipart;
|
||||
}
|
||||
|
||||
// Dump content to string
|
||||
std::string str () const
|
||||
std::string str() const
|
||||
{
|
||||
std::stringstream ss;
|
||||
for (size_t i = 0; i < m_parts.size (); i++) {
|
||||
const unsigned char *data = m_parts[i].data<unsigned char> ();
|
||||
size_t size = m_parts[i].size ();
|
||||
for (size_t i = 0; i < m_parts.size(); i++) {
|
||||
const unsigned char *data = m_parts[i].data<unsigned char>();
|
||||
size_t size = m_parts[i].size();
|
||||
|
||||
// Dump the message as text or binary
|
||||
bool isText = true;
|
||||
@ -307,121 +301,119 @@ class multipart_t
|
||||
break;
|
||||
}
|
||||
}
|
||||
ss << "\n[" << std::dec << std::setw (3) << std::setfill ('0')
|
||||
<< size << "] ";
|
||||
ss << "\n[" << std::dec << std::setw(3) << std::setfill('0') << size
|
||||
<< "] ";
|
||||
if (size >= 1000) {
|
||||
ss << "... (to big to print)";
|
||||
continue;
|
||||
}
|
||||
for (size_t j = 0; j < size; j++) {
|
||||
if (isText)
|
||||
ss << static_cast<char> (data[j]);
|
||||
ss << static_cast<char>(data[j]);
|
||||
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
|
||||
bool equal (const multipart_t *other) const
|
||||
bool equal(const multipart_t *other) const
|
||||
{
|
||||
if (size () != other->size ())
|
||||
if (size() != other->size())
|
||||
return false;
|
||||
for (size_t i = 0; i < size (); i++)
|
||||
if (*peek (i) != *other->peek (i))
|
||||
for (size_t i = 0; i < size(); i++)
|
||||
if (*peek(i) != *other->peek(i))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
private:
|
||||
// Disable implicit copying (moving is more efficient)
|
||||
multipart_t (const multipart_t &other) ZMQ_DELETED_FUNCTION;
|
||||
void operator= (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;
|
||||
}; // 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
|
||||
|
||||
#if defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) \
|
||||
&& defined(ZMQ_HAVE_POLLER)
|
||||
#if defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) && defined(ZMQ_HAVE_POLLER)
|
||||
class active_poller_t
|
||||
{
|
||||
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 &operator= (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 (active_poller_t &&src) = default;
|
||||
active_poller_t &operator= (active_poller_t &&src) = default;
|
||||
active_poller_t(active_poller_t &&src) = default;
|
||||
active_poller_t &operator=(active_poller_t &&src) = default;
|
||||
|
||||
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{};
|
||||
std::tie (it, inserted) =
|
||||
handlers.emplace (static_cast<void *> (socket),
|
||||
std::make_shared<handler_t> (std::move (handler)));
|
||||
std::tie(it, inserted) =
|
||||
handlers.emplace(static_cast<void *>(socket),
|
||||
std::make_shared<handler_t>(std::move(handler)));
|
||||
try {
|
||||
base_poller.add (socket, events,
|
||||
inserted && *(it->second) ? it->second.get ()
|
||||
: nullptr);
|
||||
base_poller.add(socket, events,
|
||||
inserted && *(it->second) ? it->second.get() : nullptr);
|
||||
need_rebuild |= inserted;
|
||||
}
|
||||
catch (const zmq::error_t &) {
|
||||
// rollback
|
||||
if (inserted) {
|
||||
handlers.erase (static_cast<void *> (socket));
|
||||
handlers.erase(static_cast<void *>(socket));
|
||||
}
|
||||
throw;
|
||||
}
|
||||
}
|
||||
|
||||
void remove (zmq::socket_t &socket)
|
||||
void remove(zmq::socket_t &socket)
|
||||
{
|
||||
base_poller.remove (socket);
|
||||
handlers.erase (static_cast<void *> (socket));
|
||||
base_poller.remove(socket);
|
||||
handlers.erase(static_cast<void *>(socket));
|
||||
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) {
|
||||
poller_events.resize (handlers.size ());
|
||||
poller_handlers.clear ();
|
||||
poller_handlers.reserve (handlers.size ());
|
||||
poller_events.resize(handlers.size());
|
||||
poller_handlers.clear();
|
||||
poller_handlers.reserve(handlers.size());
|
||||
for (const auto &handler : handlers) {
|
||||
poller_handlers.push_back (handler.second);
|
||||
poller_handlers.push_back(handler.second);
|
||||
}
|
||||
need_rebuild = false;
|
||||
}
|
||||
const auto count = base_poller.wait_all (poller_events, timeout);
|
||||
std::for_each (poller_events.begin (), poller_events.begin () + count,
|
||||
[](zmq_poller_event_t &event) {
|
||||
if (event.user_data != NULL)
|
||||
(*reinterpret_cast<handler_t *> (
|
||||
event.user_data)) (event.events);
|
||||
});
|
||||
const auto count = base_poller.wait_all(poller_events, timeout);
|
||||
std::for_each(poller_events.begin(), poller_events.begin() + count,
|
||||
[](zmq_poller_event_t &event) {
|
||||
if (event.user_data != NULL)
|
||||
(*reinterpret_cast<handler_t *>(event.user_data))(
|
||||
event.events);
|
||||
});
|
||||
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:
|
||||
bool need_rebuild{false};
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user