diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index b310b278..301edbe6 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -132,6 +132,13 @@ jobs: make install echo "LIBZMQ=${PWD}/libzmq-build" >> ${GITHUB_ENV} + - name: format + if: ${{ startsWith(matrix.os, 'ubuntu-24') }} + run: | + sudo apt install -y clang-format-20 + clang-format-20 --version + git ls-files | grep -E '\.(cpp|hpp)' | xargs clang-format-20 --dry-run --Werror + - name: build env: CMAKE_PREFIX_PATH: ${{ env.LIBZMQ }} diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 00000000..bcaf6f36 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,5 @@ +repos: + - repo: https://github.com/pre-commit/mirrors-clang-format + rev: 'v20.1.8' + hooks: + - id: clang-format diff --git a/examples/multipart_messages.cpp b/examples/multipart_messages.cpp index 1af8f8f0..e8b5e5ed 100644 --- a/examples/multipart_messages.cpp +++ b/examples/multipart_messages.cpp @@ -7,25 +7,19 @@ int main() zmq::socket_t sock1(ctx, zmq::socket_type::push); zmq::socket_t sock2(ctx, zmq::socket_type::pull); sock1.bind("tcp://127.0.0.1:*"); - const std::string last_endpoint = - sock1.get(zmq::sockopt::last_endpoint); - std::cout << "Connecting to " - << last_endpoint << std::endl; + const std::string last_endpoint = sock1.get(zmq::sockopt::last_endpoint); + std::cout << "Connecting to " << last_endpoint << std::endl; sock2.connect(last_endpoint); - std::array send_msgs = { - zmq::str_buffer("foo"), - zmq::str_buffer("bar!") - }; + std::array send_msgs = {zmq::str_buffer("foo"), + zmq::str_buffer("bar!")}; if (!zmq::send_multipart(sock1, send_msgs)) return 1; std::vector recv_msgs; - const auto ret = zmq::recv_multipart( - sock2, std::back_inserter(recv_msgs)); + const auto ret = zmq::recv_multipart(sock2, std::back_inserter(recv_msgs)); if (!ret) return 1; - std::cout << "Got " << *ret - << " messages" << std::endl; + std::cout << "Got " << *ret << " messages" << std::endl; return 0; } diff --git a/examples/pubsub_multithread_inproc.cpp b/examples/pubsub_multithread_inproc.cpp index 2727f7b1..7f9f3d1f 100644 --- a/examples/pubsub_multithread_inproc.cpp +++ b/examples/pubsub_multithread_inproc.cpp @@ -6,7 +6,8 @@ #include "zmq.hpp" #include "zmq_addon.hpp" -void PublisherThread(zmq::context_t *ctx) { +void PublisherThread(zmq::context_t *ctx) +{ // Prepare publisher zmq::socket_t publisher(*ctx, zmq::socket_type::pub); publisher.bind("inproc://#1"); @@ -26,7 +27,8 @@ void PublisherThread(zmq::context_t *ctx) { } } -void SubscriberThread1(zmq::context_t *ctx) { +void SubscriberThread1(zmq::context_t *ctx) +{ // Prepare subscriber zmq::socket_t subscriber(*ctx, zmq::socket_type::sub); subscriber.connect("inproc://#1"); @@ -48,7 +50,8 @@ void SubscriberThread1(zmq::context_t *ctx) { } } -void SubscriberThread2(zmq::context_t *ctx) { +void SubscriberThread2(zmq::context_t *ctx) +{ // Prepare our context and subscriber zmq::socket_t subscriber(*ctx, zmq::socket_type::sub); subscriber.connect("inproc://#1"); @@ -69,7 +72,8 @@ void SubscriberThread2(zmq::context_t *ctx) { } } -int main() { +int main() +{ /* * No I/O threads are involved in passing messages using the inproc transport. * Therefore, if you are using a ØMQ context for in-process messaging only you diff --git a/tests/active_poller.cpp b/tests/active_poller.cpp index 86c35d0c..340b21ff 100644 --- a/tests/active_poller.cpp +++ b/tests/active_poller.cpp @@ -9,7 +9,7 @@ #include #if !defined(_WIN32) - #include +#include #endif // !_WIN32 TEST_CASE("create destroy", "[active_poller]") @@ -95,18 +95,15 @@ TEST_CASE("add fd handler", "[active_poller]") { int fd = 1; zmq::active_poller_t active_poller; - CHECK_NOTHROW( - active_poller.add(fd, zmq::event_flags::pollin, no_op_handler)); + CHECK_NOTHROW(active_poller.add(fd, zmq::event_flags::pollin, no_op_handler)); } TEST_CASE("remove fd handler", "[active_poller]") { int fd = 1; zmq::active_poller_t active_poller; - CHECK_NOTHROW( - active_poller.add(fd, zmq::event_flags::pollin, no_op_handler)); - CHECK_NOTHROW( - active_poller.remove(fd)); + CHECK_NOTHROW(active_poller.add(fd, zmq::event_flags::pollin, no_op_handler)); + CHECK_NOTHROW(active_poller.remove(fd)); CHECK_THROWS_ZMQ_ERROR(EINVAL, active_poller.remove(100)); } @@ -117,7 +114,7 @@ TEST_CASE("mixed socket and fd handlers", "[active_poller]") { int pipefd[2]; ::pipe(pipefd); - + zmq::context_t context; constexpr char inprocSocketAddress[] = "inproc://mixed-handlers"; zmq::socket_t socket_rcv{context, zmq::socket_type::pair}; @@ -128,31 +125,29 @@ TEST_CASE("mixed socket and fd handlers", "[active_poller]") unsigned eventsFd = 0; unsigned eventsSocket = 0; - constexpr char messageText[] = "message"; - constexpr size_t messageSize = sizeof(messageText); + constexpr char messageText[] = "message"; + constexpr size_t messageSize = sizeof(messageText); zmq::active_poller_t active_poller; - CHECK_NOTHROW( - active_poller.add(pipefd[0], zmq::event_flags::pollin, [&](zmq::event_flags flags) { - if (flags == zmq::event_flags::pollin) - { - char buffer[256]; - CHECK(messageSize == ::read(pipefd[0], buffer, messageSize)); - CHECK(0 == std::strcmp(buffer, messageText)); - ++eventsFd; - } - })); - CHECK_NOTHROW( - active_poller.add(socket_rcv, zmq::event_flags::pollin, [&](zmq::event_flags flags) { - if (flags == zmq::event_flags::pollin) - { - zmq::message_t msg; - CHECK(socket_rcv.recv(msg, zmq::recv_flags::dontwait).has_value()); - CHECK(messageSize == msg.size()); - CHECK(0 == std::strcmp(messageText, msg.data())); - ++eventsSocket; - } - })); + CHECK_NOTHROW(active_poller.add( + pipefd[0], zmq::event_flags::pollin, [&](zmq::event_flags flags) { + if (flags == zmq::event_flags::pollin) { + char buffer[256]; + CHECK(messageSize == ::read(pipefd[0], buffer, messageSize)); + CHECK(0 == std::strcmp(buffer, messageText)); + ++eventsFd; + } + })); + CHECK_NOTHROW(active_poller.add( + socket_rcv, zmq::event_flags::pollin, [&](zmq::event_flags flags) { + if (flags == zmq::event_flags::pollin) { + zmq::message_t msg; + CHECK(socket_rcv.recv(msg, zmq::recv_flags::dontwait).has_value()); + CHECK(messageSize == msg.size()); + CHECK(0 == std::strcmp(messageText, msg.data())); + ++eventsSocket; + } + })); // send/rcv socket pair zmq::message_t msg{messageText, messageSize}; @@ -369,8 +364,7 @@ TEST_CASE("modify invalid socket throws", "[active_poller]") zmq::socket_t a{context, zmq::socket_type::push}; zmq::socket_t b{std::move(a)}; zmq::active_poller_t active_poller; - CHECK_THROWS_AS(active_poller.modify(a, zmq::event_flags::pollin), - zmq::error_t); + CHECK_THROWS_AS(active_poller.modify(a, zmq::event_flags::pollin), zmq::error_t); } TEST_CASE("modify not added throws", "[active_poller]") @@ -380,8 +374,7 @@ TEST_CASE("modify not added throws", "[active_poller]") zmq::socket_t b{context, zmq::socket_type::push}; zmq::active_poller_t active_poller; CHECK_NOTHROW(active_poller.add(a, zmq::event_flags::pollin, no_op_handler)); - CHECK_THROWS_AS(active_poller.modify(b, zmq::event_flags::pollin), - zmq::error_t); + CHECK_THROWS_AS(active_poller.modify(b, zmq::event_flags::pollin), zmq::error_t); } TEST_CASE("modify simple", "[active_poller]") diff --git a/tests/buffer.cpp b/tests/buffer.cpp index 9db2e9ad..a769939f 100644 --- a/tests/buffer.cpp +++ b/tests/buffer.cpp @@ -120,10 +120,10 @@ TEST_CASE("mutable_buffer creation C array", "[buffer]") BT d[10] = {}; zmq::mutable_buffer b = zmq::buffer(d); CHECK(b.size() == 10 * sizeof(BT)); - CHECK(b.data() == static_cast(d)); + CHECK(b.data() == static_cast(d)); zmq::const_buffer b2 = zmq::buffer(d, 4); CHECK(b2.size() == 4); - CHECK(b2.data() == static_cast(d)); + CHECK(b2.data() == static_cast(d)); } TEST_CASE("const_buffer creation C array", "[buffer]") @@ -131,10 +131,10 @@ TEST_CASE("const_buffer creation C array", "[buffer]") const BT d[10] = {}; zmq::const_buffer b = zmq::buffer(d); CHECK(b.size() == 10 * sizeof(BT)); - CHECK(b.data() == static_cast(d)); + CHECK(b.data() == static_cast(d)); zmq::const_buffer b2 = zmq::buffer(d, 4); CHECK(b2.size() == 4); - CHECK(b2.data() == static_cast(d)); + CHECK(b2.data() == static_cast(d)); } TEST_CASE("mutable_buffer creation array", "[buffer]") @@ -241,13 +241,13 @@ TEST_CASE("const_buffer creation with str_buffer", "[buffer]") const wchar_t wd[10] = {}; zmq::const_buffer b = zmq::str_buffer(wd); CHECK(b.size() == 9 * sizeof(wchar_t)); - CHECK(b.data() == static_cast(wd)); + CHECK(b.data() == static_cast(wd)); zmq::const_buffer b2_null = zmq::buffer("hello"); constexpr zmq::const_buffer b2 = zmq::str_buffer("hello"); CHECK(b2_null.size() == 6); CHECK(b2.size() == 5); - CHECK(std::string(static_cast(b2.data()), b2.size()) == "hello"); + CHECK(std::string(static_cast(b2.data()), b2.size()) == "hello"); } TEST_CASE("const_buffer creation with zbuf string literal char", "[buffer]") diff --git a/tests/codec_multipart.cpp b/tests/codec_multipart.cpp index f43edff3..2c745c5e 100644 --- a/tests/codec_multipart.cpp +++ b/tests/codec_multipart.cpp @@ -10,11 +10,10 @@ TEST_CASE("multipart codec empty", "[codec_multipart]") multipart_t mmsg; message_t msg = mmsg.encode(); CHECK(msg.size() == 0); - + multipart_t mmsg2; mmsg2.decode_append(msg); CHECK(mmsg2.size() == 0); - } TEST_CASE("multipart codec small", "[codec_multipart]") @@ -42,7 +41,7 @@ TEST_CASE("multipart codec big", "[codec_multipart]") { using namespace zmq; - message_t big(495); // large size packing + message_t big(495); // large size packing big.data()[0] = 'X'; multipart_t mmsg; @@ -66,10 +65,8 @@ TEST_CASE("multipart codec decode bad data overflow", "[codec_multipart]") message_t wrong_size(bad_data, 3); CHECK(wrong_size.size() == 3); CHECK(wrong_size.data()[0] == 5); - - CHECK_THROWS_AS( - multipart_t::decode(wrong_size), - std::out_of_range); + + CHECK_THROWS_AS(multipart_t::decode(wrong_size), std::out_of_range); } TEST_CASE("multipart codec decode bad data extra data", "[codec_multipart]") @@ -80,10 +77,8 @@ TEST_CASE("multipart codec decode bad data extra data", "[codec_multipart]") message_t wrong_size(bad_data, 3); CHECK(wrong_size.size() == 3); CHECK(wrong_size.data()[0] == 1); - - CHECK_THROWS_AS( - multipart_t::decode(wrong_size), - std::out_of_range); + + CHECK_THROWS_AS(multipart_t::decode(wrong_size), std::out_of_range); } @@ -110,14 +105,15 @@ TEST_CASE("multipart codec encode too big", "[codec_multipart]") } #endif -TEST_CASE("multipart codec free function with vector of message_t", "[codec_multipart]") +TEST_CASE("multipart codec free function with vector of message_t", + "[codec_multipart]") { using namespace zmq; std::vector parts; parts.emplace_back("Hello", 5); - parts.emplace_back("World",5); + parts.emplace_back("World", 5); auto msg = encode(parts); - CHECK(msg.size() == 1 + 5 + 1 + 5 ); + CHECK(msg.size() == 1 + 5 + 1 + 5); CHECK(msg.data()[0] == 5); CHECK(msg.data()[1] == 'H'); CHECK(msg.data()[6] == 5); @@ -130,14 +126,15 @@ TEST_CASE("multipart codec free function with vector of message_t", "[codec_mult CHECK(parts[1].size() == 5); } -TEST_CASE("multipart codec free function with vector of const_buffer", "[codec_multipart]") +TEST_CASE("multipart codec free function with vector of const_buffer", + "[codec_multipart]") { using namespace zmq; std::vector parts; parts.emplace_back("Hello", 5); - parts.emplace_back("World",5); + parts.emplace_back("World", 5); auto msg = encode(parts); - CHECK(msg.size() == 1 + 5 + 1 + 5 ); + CHECK(msg.size() == 1 + 5 + 1 + 5); CHECK(msg.data()[0] == 5); CHECK(msg.data()[1] == 'H'); CHECK(msg.data()[6] == 5); @@ -150,16 +147,17 @@ TEST_CASE("multipart codec free function with vector of const_buffer", "[codec_m CHECK(parts[1].size() == 5); } -TEST_CASE("multipart codec free function with vector of mutable_buffer", "[codec_multipart]") +TEST_CASE("multipart codec free function with vector of mutable_buffer", + "[codec_multipart]") { using namespace zmq; std::vector parts; char hello[6] = "Hello"; parts.emplace_back(hello, 5); char world[6] = "World"; - parts.emplace_back(world,5); + parts.emplace_back(world, 5); auto msg = encode(parts); - CHECK(msg.size() == 1 + 5 + 1 + 5 ); + CHECK(msg.size() == 1 + 5 + 1 + 5); CHECK(msg.data()[0] == 5); CHECK(msg.data()[1] == 'H'); CHECK(msg.data()[6] == 5); diff --git a/tests/context.cpp b/tests/context.cpp index 76964a6b..4f8dae8b 100644 --- a/tests/context.cpp +++ b/tests/context.cpp @@ -51,15 +51,13 @@ TEST_CASE("context - use socket after shutdown", "[context]") zmq::context_t context; zmq::socket_t sock(context, zmq::socket_type::rep); context.shutdown(); - try - { + try { sock.connect("inproc://test"); zmq::message_t msg; - (void)sock.recv(msg, zmq::recv_flags::dontwait); + (void) sock.recv(msg, zmq::recv_flags::dontwait); REQUIRE(false); } - catch (const zmq::error_t& e) - { + catch (const zmq::error_t &e) { REQUIRE(e.num() == ETERM); } } @@ -73,12 +71,8 @@ TEST_CASE("context set/get options", "[context]") CHECK(context.get(zmq::ctxopt::io_threads) == 5); #endif - CHECK_THROWS_AS( - context.set(static_cast(-42), 5), - zmq::error_t); + CHECK_THROWS_AS(context.set(static_cast(-42), 5), zmq::error_t); - CHECK_THROWS_AS( - context.get(static_cast(-42)), - zmq::error_t); + CHECK_THROWS_AS(context.get(static_cast(-42)), zmq::error_t); } #endif diff --git a/tests/message.cpp b/tests/message.cpp index 645d8065..a15ff73f 100644 --- a/tests/message.cpp +++ b/tests/message.cpp @@ -3,9 +3,9 @@ #if defined(ZMQ_CPP11) static_assert(!std::is_copy_constructible::value, - "message_t should not be copy-constructible"); + "message_t should not be copy-constructible"); static_assert(!std::is_copy_assignable::value, - "message_t should not be copy-assignable"); + "message_t should not be copy-assignable"); #endif #if (__cplusplus >= 201703L) static_assert(std::is_nothrow_swappable::value, diff --git a/tests/monitor.cpp b/tests/monitor.cpp index 5eb0dbd1..f0e03e1e 100644 --- a/tests/monitor.cpp +++ b/tests/monitor.cpp @@ -9,7 +9,6 @@ class mock_monitor_t : public zmq::monitor_t { public: - void on_event_connected(const zmq_event_t &, const char *) ZMQ_OVERRIDE { ++connected; @@ -32,11 +31,13 @@ TEST_CASE("monitor move construct", "[monitor]") { zmq::context_t ctx; zmq::socket_t sock(ctx, ZMQ_DEALER); - SECTION("move ctor empty") { + SECTION("move ctor empty") + { zmq::monitor_t monitor1; zmq::monitor_t monitor2 = std::move(monitor1); } - SECTION("move ctor init") { + SECTION("move ctor init") + { zmq::monitor_t monitor1; monitor1.init(sock, "inproc://monitor-client"); zmq::monitor_t monitor2 = std::move(monitor1); @@ -47,18 +48,21 @@ TEST_CASE("monitor move assign", "[monitor]") { zmq::context_t ctx; zmq::socket_t sock(ctx, ZMQ_DEALER); - SECTION("move assign empty") { + SECTION("move assign empty") + { zmq::monitor_t monitor1; zmq::monitor_t monitor2; monitor1 = std::move(monitor2); } - SECTION("move assign init") { + SECTION("move assign init") + { zmq::monitor_t monitor1; monitor1.init(sock, "inproc://monitor-client"); zmq::monitor_t monitor2; monitor2 = std::move(monitor1); } - SECTION("move assign init both") { + SECTION("move assign init both") + { zmq::monitor_t monitor1; monitor1.init(sock, "inproc://monitor-client"); zmq::monitor_t monitor2; @@ -110,16 +114,14 @@ TEST_CASE("monitor init abort", "[monitor]") std::condition_variable cond_var; bool done{false}; - mock_monitor monitor([&]() - { + mock_monitor monitor([&]() { std::lock_guard lock(mutex); done = true; cond_var.notify_one(); }); monitor.init(s.client, "inproc://foo"); - auto thread = std::thread([&monitor] - { + auto thread = std::thread([&monitor] { while (monitor.check_event(-1)) { } }); diff --git a/tests/multipart.cpp b/tests/multipart.cpp index c201592f..6901517b 100644 --- a/tests/multipart.cpp +++ b/tests/multipart.cpp @@ -84,8 +84,8 @@ TEST_CASE("multipart legacy test", "[multipart]") assert(copy != multipart); assert(multipart != copy); - multipart_t emptyMessage1 {}; - multipart_t emptyMessage2 {}; + multipart_t emptyMessage1{}; + multipart_t emptyMessage2{}; assert(emptyMessage1 == emptyMessage2); assert(emptyMessage2 == emptyMessage1); diff --git a/tests/poller.cpp b/tests/poller.cpp index 174270b3..e32592d2 100644 --- a/tests/poller.cpp +++ b/tests/poller.cpp @@ -1,6 +1,7 @@ #include "testutil.hpp" -#if defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) && !defined(ZMQ_CPP11_PARTIAL) && defined(ZMQ_HAVE_POLLER) +#if defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) \ + && !defined(ZMQ_CPP11_PARTIAL) && defined(ZMQ_HAVE_POLLER) #include #include @@ -9,25 +10,26 @@ static_assert(std::is_nothrow_swappable_v>); #endif static_assert(sizeof(zmq_poller_event_t) == sizeof(zmq::poller_event<>), ""); -static_assert(sizeof(zmq_poller_event_t) == sizeof(zmq::poller_event), ""); +static_assert(sizeof(zmq_poller_event_t) + == sizeof(zmq::poller_event), + ""); static_assert(sizeof(zmq_poller_event_t) == sizeof(zmq::poller_event), ""); static_assert(alignof(zmq_poller_event_t) == alignof(zmq::poller_event<>), ""); static_assert(alignof(zmq_poller_event_t) == alignof(zmq::poller_event), ""); static_assert(!std::is_copy_constructible>::value, - "poller_t should not be copy-constructible"); + "poller_t should not be copy-constructible"); static_assert(!std::is_copy_assignable>::value, - "poller_t should not be copy-assignable"); + "poller_t should not be copy-assignable"); TEST_CASE("event flags", "[poller]") { CHECK((zmq::event_flags::pollin | zmq::event_flags::pollout) - == static_cast(ZMQ_POLLIN | ZMQ_POLLOUT)); + == static_cast(ZMQ_POLLIN | ZMQ_POLLOUT)); CHECK((zmq::event_flags::pollin & zmq::event_flags::pollout) - == static_cast(ZMQ_POLLIN & ZMQ_POLLOUT)); + == static_cast(ZMQ_POLLIN & ZMQ_POLLOUT)); CHECK((zmq::event_flags::pollin ^ zmq::event_flags::pollout) - == static_cast(ZMQ_POLLIN ^ ZMQ_POLLOUT)); + == static_cast(ZMQ_POLLIN ^ ZMQ_POLLOUT)); CHECK(~zmq::event_flags::pollin == static_cast(~ZMQ_POLLIN)); } @@ -108,8 +110,8 @@ TEST_CASE("poller add handler invalid events type", "[poller]") zmq::poller_t<> poller; short invalid_events_type = 2 << 10; CHECK_THROWS_AS( - poller.add(socket, static_cast(invalid_events_type)), - zmq::error_t); + poller.add(socket, static_cast(invalid_events_type)), + zmq::error_t); } #endif @@ -120,8 +122,7 @@ TEST_CASE("poller add handler twice throws", "[poller]") zmq::poller_t<> poller; poller.add(socket, zmq::event_flags::pollin); /// \todo the actual error code should be checked - CHECK_THROWS_AS(poller.add(socket, zmq::event_flags::pollin), - zmq::error_t); + CHECK_THROWS_AS(poller.add(socket, zmq::event_flags::pollin), zmq::error_t); } TEST_CASE("poller wait with no handlers throws", "[poller]") @@ -233,8 +234,7 @@ TEST_CASE("poller modify empty throws", "[poller]") zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::push}; zmq::poller_t<> poller; - CHECK_THROWS_AS(poller.modify(socket, zmq::event_flags::pollin), - zmq::error_t); + CHECK_THROWS_AS(poller.modify(socket, zmq::event_flags::pollin), zmq::error_t); } TEST_CASE("poller modify invalid socket throws", "[poller]") @@ -263,7 +263,7 @@ TEST_CASE("poller modify simple", "[poller]") zmq::poller_t<> poller; CHECK_NOTHROW(poller.add(a, zmq::event_flags::pollin)); CHECK_NOTHROW( - poller.modify(a, zmq::event_flags::pollin | zmq::event_flags::pollout)); + poller.modify(a, zmq::event_flags::pollin | zmq::event_flags::pollout)); } TEST_CASE("poller poll client server", "[poller]") @@ -285,11 +285,10 @@ TEST_CASE("poller poll client server", "[poller]") // Modify server socket with pollout flag CHECK_NOTHROW( - poller.modify(s.server, zmq::event_flags::pollin | zmq::event_flags::pollout - )); + poller.modify(s.server, zmq::event_flags::pollin | zmq::event_flags::pollout)); CHECK(1 == poller.wait_all(events, std::chrono::milliseconds{500})); - CHECK((zmq::event_flags::pollin | zmq::event_flags::pollout) == events[0].events) - ; + CHECK((zmq::event_flags::pollin | zmq::event_flags::pollout) + == events[0].events); } TEST_CASE("poller wait one return", "[poller]") @@ -318,8 +317,7 @@ TEST_CASE("poller wait on move constructed", "[poller]") zmq::poller_t<> b{std::move(a)}; std::vector> events(1); /// \todo the actual error code should be checked - CHECK_THROWS_AS(a.wait_all(events, std::chrono::milliseconds{10}), - zmq::error_t); + CHECK_THROWS_AS(a.wait_all(events, std::chrono::milliseconds{10}), zmq::error_t); CHECK(1 == b.wait_all(events, std::chrono::milliseconds{-1})); } @@ -333,8 +331,7 @@ TEST_CASE("poller wait on move assigned", "[poller]") b = {std::move(a)}; /// \todo the TEST_CASE error code should be checked std::vector> events(1); - CHECK_THROWS_AS(a.wait_all(events, std::chrono::milliseconds{10}), - zmq::error_t); + CHECK_THROWS_AS(a.wait_all(events, std::chrono::milliseconds{10}), zmq::error_t); CHECK(1 == b.wait_all(events, std::chrono::milliseconds{-1})); } diff --git a/tests/recv_multipart.cpp b/tests/recv_multipart.cpp index 5a068d48..da725ccc 100644 --- a/tests/recv_multipart.cpp +++ b/tests/recv_multipart.cpp @@ -10,7 +10,8 @@ TEST_CASE("recv_multipart test", "[recv_multipart]") output.bind("inproc://multipart.test"); input.connect("inproc://multipart.test"); - SECTION("send 1 message") { + SECTION("send 1 message") + { input.send(zmq::str_buffer("hello")); std::vector msgs; @@ -20,7 +21,8 @@ TEST_CASE("recv_multipart test", "[recv_multipart]") REQUIRE(msgs.size() == 1); CHECK(msgs[0].size() == 5); } - SECTION("send 2 messages") { + SECTION("send 2 messages") + { input.send(zmq::str_buffer("hello"), zmq::send_flags::sndmore); input.send(zmq::str_buffer("world!")); @@ -32,14 +34,16 @@ TEST_CASE("recv_multipart test", "[recv_multipart]") CHECK(msgs[0].size() == 5); CHECK(msgs[1].size() == 6); } - SECTION("send no messages, dontwait") { + SECTION("send no messages, dontwait") + { std::vector msgs; auto ret = zmq::recv_multipart(output, std::back_inserter(msgs), zmq::recv_flags::dontwait); CHECK_FALSE(ret); REQUIRE(msgs.size() == 0); } - SECTION("send 1 partial message, dontwait") { + SECTION("send 1 partial message, dontwait") + { input.send(zmq::str_buffer("hello"), zmq::send_flags::sndmore); std::vector msgs; @@ -48,11 +52,12 @@ TEST_CASE("recv_multipart test", "[recv_multipart]") CHECK_FALSE(ret); REQUIRE(msgs.size() == 0); } - SECTION("recv with invalid socket") { + SECTION("recv with invalid socket") + { std::vector msgs; CHECK_THROWS_AS( - zmq::recv_multipart(zmq::socket_ref(), std::back_inserter(msgs)), - zmq::error_t); + zmq::recv_multipart(zmq::socket_ref(), std::back_inserter(msgs)), + zmq::error_t); } } @@ -64,7 +69,8 @@ TEST_CASE("recv_multipart_n test", "[recv_multipart]") output.bind("inproc://multipart.test"); input.connect("inproc://multipart.test"); - SECTION("send 1 message") { + SECTION("send 1 message") + { input.send(zmq::str_buffer("hello")); std::array msgs; @@ -73,7 +79,8 @@ TEST_CASE("recv_multipart_n test", "[recv_multipart]") CHECK(*ret == 1); CHECK(msgs[0].size() == 5); } - SECTION("send 1 message 2") { + SECTION("send 1 message 2") + { input.send(zmq::str_buffer("hello")); std::array msgs; @@ -83,25 +90,26 @@ TEST_CASE("recv_multipart_n test", "[recv_multipart]") CHECK(msgs[0].size() == 5); CHECK(msgs[1].size() == 0); } - SECTION("send 2 messages, recv 1") { + SECTION("send 2 messages, recv 1") + { input.send(zmq::str_buffer("hello"), zmq::send_flags::sndmore); input.send(zmq::str_buffer("world!")); std::array msgs; - CHECK_THROWS_AS( - zmq::recv_multipart_n(output, msgs.data(), msgs.size()), - std::runtime_error); + CHECK_THROWS_AS(zmq::recv_multipart_n(output, msgs.data(), msgs.size()), + std::runtime_error); } - SECTION("recv 0") { + SECTION("recv 0") + { input.send(zmq::str_buffer("hello"), zmq::send_flags::sndmore); input.send(zmq::str_buffer("world!")); std::array msgs; - CHECK_THROWS_AS( - zmq::recv_multipart_n(output, msgs.data(), 0), - std::runtime_error); + CHECK_THROWS_AS(zmq::recv_multipart_n(output, msgs.data(), 0), + std::runtime_error); } - SECTION("send 2 messages") { + SECTION("send 2 messages") + { input.send(zmq::str_buffer("hello"), zmq::send_flags::sndmore); input.send(zmq::str_buffer("world!")); @@ -112,14 +120,16 @@ TEST_CASE("recv_multipart_n test", "[recv_multipart]") CHECK(msgs[0].size() == 5); CHECK(msgs[1].size() == 6); } - SECTION("send no messages, dontwait") { + SECTION("send no messages, dontwait") + { std::array msgs; auto ret = zmq::recv_multipart_n(output, msgs.data(), msgs.size(), zmq::recv_flags::dontwait); CHECK_FALSE(ret); REQUIRE(msgs[0].size() == 0); } - SECTION("send 1 partial message, dontwait") { + SECTION("send 1 partial message, dontwait") + { input.send(zmq::str_buffer("hello"), zmq::send_flags::sndmore); std::array msgs; @@ -128,11 +138,12 @@ TEST_CASE("recv_multipart_n test", "[recv_multipart]") CHECK_FALSE(ret); REQUIRE(msgs[0].size() == 0); } - SECTION("recv with invalid socket") { + SECTION("recv with invalid socket") + { std::array msgs; CHECK_THROWS_AS( - zmq::recv_multipart_n(zmq::socket_ref(), msgs.data(), msgs.size()), - zmq::error_t); + zmq::recv_multipart_n(zmq::socket_ref(), msgs.data(), msgs.size()), + zmq::error_t); } } diff --git a/tests/send_multipart.cpp b/tests/send_multipart.cpp index cc0b41da..d38a6506 100644 --- a/tests/send_multipart.cpp +++ b/tests/send_multipart.cpp @@ -12,13 +12,15 @@ TEST_CASE("send_multipart test", "[send_multipart]") output.bind("inproc://multipart.test"); input.connect("inproc://multipart.test"); - SECTION("send 0 messages") { + SECTION("send 0 messages") + { std::vector imsgs; auto iret = zmq::send_multipart(input, imsgs); REQUIRE(iret); CHECK(*iret == 0); } - SECTION("send 1 message") { + SECTION("send 1 message") + { std::array imsgs = {zmq::message_t(3)}; auto iret = zmq::send_multipart(input, imsgs); REQUIRE(iret); @@ -31,7 +33,8 @@ TEST_CASE("send_multipart test", "[send_multipart]") REQUIRE(omsgs.size() == 1); CHECK(omsgs[0].size() == 3); } - SECTION("send 2 messages") { + SECTION("send 2 messages") + { std::array imsgs = {zmq::message_t(3), zmq::message_t(4)}; auto iret = zmq::send_multipart(input, imsgs); REQUIRE(iret); @@ -45,7 +48,8 @@ TEST_CASE("send_multipart test", "[send_multipart]") CHECK(omsgs[0].size() == 3); CHECK(omsgs[1].size() == 4); } - SECTION("send 2 messages, const_buffer") { + SECTION("send 2 messages, const_buffer") + { std::array imsgs = {zmq::str_buffer("foo"), zmq::str_buffer("bar!")}; auto iret = zmq::send_multipart(input, imsgs); @@ -60,10 +64,11 @@ TEST_CASE("send_multipart test", "[send_multipart]") CHECK(omsgs[0].size() == 3); CHECK(omsgs[1].size() == 4); } - SECTION("send 2 messages, mutable_buffer") { + SECTION("send 2 messages, mutable_buffer") + { char buf[4] = {}; - std::array imsgs = { - zmq::buffer(buf, 3), zmq::buffer(buf)}; + std::array imsgs = {zmq::buffer(buf, 3), + zmq::buffer(buf)}; auto iret = zmq::send_multipart(input, imsgs); REQUIRE(iret); CHECK(*iret == 2); @@ -76,7 +81,8 @@ TEST_CASE("send_multipart test", "[send_multipart]") CHECK(omsgs[0].size() == 3); CHECK(omsgs[1].size() == 4); } - SECTION("send 2 messages, dontwait") { + SECTION("send 2 messages, dontwait") + { zmq::socket_t push(context, ZMQ_PUSH); push.bind("inproc://multipart.test.push"); @@ -84,7 +90,8 @@ TEST_CASE("send_multipart test", "[send_multipart]") auto iret = zmq::send_multipart(push, imsgs, zmq::send_flags::dontwait); REQUIRE_FALSE(iret); } - SECTION("send, misc. containers") { + SECTION("send, misc. containers") + { std::vector msgs_vec; msgs_vec.emplace_back(3); msgs_vec.emplace_back(4); @@ -105,17 +112,16 @@ TEST_CASE("send_multipart test", "[send_multipart]") REQUIRE(iret); CHECK(*iret == 2); // rvalue - iret = zmq::send_multipart(input, - std::initializer_list{ - zmq::str_buffer("foo"), - zmq::str_buffer("bar!")}); + iret = zmq::send_multipart( + input, std::initializer_list{zmq::str_buffer("foo"), + zmq::str_buffer("bar!")}); REQUIRE(iret); CHECK(*iret == 2); } - SECTION("send with invalid socket") { + SECTION("send with invalid socket") + { std::vector msgs(1); - CHECK_THROWS_AS(zmq::send_multipart(zmq::socket_ref(), msgs), - zmq::error_t); + CHECK_THROWS_AS(zmq::send_multipart(zmq::socket_ref(), msgs), zmq::error_t); } } #endif diff --git a/tests/socket.cpp b/tests/socket.cpp index ddc2d4df..15395e41 100644 --- a/tests/socket.cpp +++ b/tests/socket.cpp @@ -365,8 +365,7 @@ TEST_CASE("socket check integral options", "[socket]") "router_mandatory", true); #endif #ifdef ZMQ_ROUTER_RAW - check_integral_opt(zmq::sockopt::router_raw, router, "router_raw", - true); + check_integral_opt(zmq::sockopt::router_raw, router, "router_raw", true); #endif #ifdef ZMQ_ROUTER_NOTIFY check_integral_opt(zmq::sockopt::router_notify, router, "router_notify"); @@ -411,7 +410,8 @@ TEST_CASE("socket check integral options", "[socket]") #ifdef ZMQ_TYPE check_integral_opt_get(zmq::sockopt::type, router, "type"); #ifdef ZMQ_CPP11 - check_integral_opt_get(zmq::sockopt::socket_type, router, "socket_type"); + check_integral_opt_get(zmq::sockopt::socket_type, router, + "socket_type"); #endif // ZMQ_CPP11 #endif // ZMQ_TYPE diff --git a/tests/socket_ref.cpp b/tests/socket_ref.cpp index 6da39b08..83db550d 100644 --- a/tests/socket_ref.cpp +++ b/tests/socket_ref.cpp @@ -8,7 +8,7 @@ static_assert(std::is_nothrow_swappable_v); static_assert(sizeof(zmq::socket_ref) == sizeof(void *), "size mismatch"); static_assert(alignof(zmq::socket_ref) == alignof(void *), "alignment mismatch"); static_assert(ZMQ_IS_TRIVIALLY_COPYABLE(zmq::socket_ref), - "needs to be trivially copyable"); + "needs to be trivially copyable"); TEST_CASE("socket_ref default init", "[socket_ref]") { diff --git a/tests/timers.cpp b/tests/timers.cpp index 4229fd5a..e7a5e3aa 100644 --- a/tests/timers.cpp +++ b/tests/timers.cpp @@ -74,7 +74,6 @@ TEST_CASE("timers reset", "[timers]") timers.reset(id); CHECK(timers.timeout().has_value()); CHECK(!handler_ran); - } #endif // defined(ZMQ_CPP11) && defined(ZMQ_HAVE_TIMERS) diff --git a/zmq.hpp b/zmq.hpp index ad0509e8..1ce18ebc 100644 --- a/zmq.hpp +++ b/zmq.hpp @@ -30,6 +30,15 @@ #ifndef NOMINMAX #define NOMINMAX #endif +// To avoid the `(std::min)` workaround for when a min macro is defined +#ifdef min +#define WINDOWS_MIN min +#undef min +#endif +#ifdef max +#define WINDOWS_MAX max +#undef max +#endif #endif // included here for _HAS_CXX* macros @@ -94,7 +103,8 @@ #define ZMQ_CONSTEXPR_VAR const #define ZMQ_CPP11_DEPRECATED(msg) #endif -#if defined(ZMQ_CPP14) && (!defined(_MSC_VER) || _MSC_VER > 1900) && (!defined(__GNUC__) || __GNUC__ > 5 || (__GNUC__ == 5 && __GNUC_MINOR__ > 3)) +#if defined(ZMQ_CPP14) && (!defined(_MSC_VER) || _MSC_VER > 1900) \ + && (!defined(__GNUC__) || __GNUC__ > 5 || (__GNUC__ == 5 && __GNUC_MINOR__ > 3)) #define ZMQ_EXTENDED_CONSTEXPR #endif #if defined(ZMQ_CPP17) @@ -251,8 +261,8 @@ template using iter_value_t = typename std::iterator_traits::value_type; template -using range_iter_t = decltype( - ranges::begin(std::declval::type &>())); +using range_iter_t = decltype(ranges::begin( + std::declval::type &>())); template using range_value_t = iter_value_t>; @@ -263,9 +273,10 @@ template struct is_range : std::false_type template struct is_range< T, - void_t::type &>()) - == ranges::end(std::declval::type &>()))>> + void_t::type &>()) + == ranges::end( + std::declval::type &>()))>> : std::true_type { }; @@ -302,7 +313,8 @@ class error_t : public std::exception int errnum; }; -namespace detail { +namespace detail +{ inline int poll(zmq_pollitem_t *items_, size_t nitems_, long timeout_) { int rc = zmq_poll(items_, static_cast(nitems_), timeout_); @@ -334,7 +346,7 @@ inline int poll(zmq_pollitem_t const *items, size_t nitems, std::chrono::milliseconds timeout) { return detail::poll(const_cast(items), nitems, - static_cast(timeout.count())); + static_cast(timeout.count())); } ZMQ_DEPRECATED("from 4.3.1, use poll taking non-const items") @@ -342,17 +354,19 @@ inline int poll(std::vector const &items, std::chrono::milliseconds timeout) { return detail::poll(const_cast(items.data()), items.size(), - static_cast(timeout.count())); + static_cast(timeout.count())); } ZMQ_DEPRECATED("from 4.3.1, use poll taking non-const items") inline int poll(std::vector const &items, long timeout_ = -1) { - return detail::poll(const_cast(items.data()), items.size(), timeout_); + return detail::poll(const_cast(items.data()), items.size(), + timeout_); } -inline int -poll(zmq_pollitem_t *items, size_t nitems, std::chrono::milliseconds timeout = std::chrono::milliseconds{-1}) +inline int poll(zmq_pollitem_t *items, + size_t nitems, + std::chrono::milliseconds timeout = std::chrono::milliseconds{-1}) { return detail::poll(items, nitems, static_cast(timeout.count())); } @@ -360,7 +374,8 @@ poll(zmq_pollitem_t *items, size_t nitems, std::chrono::milliseconds timeout = s inline int poll(std::vector &items, std::chrono::milliseconds timeout = std::chrono::milliseconds{-1}) { - return detail::poll(items.data(), items.size(), static_cast(timeout.count())); + return detail::poll(items.data(), items.size(), + static_cast(timeout.count())); } ZMQ_DEPRECATED("from 4.3.1, use poll taking std::chrono::duration instead of long") @@ -373,7 +388,8 @@ template inline int poll(std::array &items, std::chrono::milliseconds timeout = std::chrono::milliseconds{-1}) { - return detail::poll(items.data(), items.size(), static_cast(timeout.count())); + return detail::poll(items.data(), items.size(), + static_cast(timeout.count())); } #endif @@ -539,11 +555,8 @@ class message_t throw error_t(); memcpy(data(), data_, size_); } - - void rebuild(const std::string &str) - { - rebuild(str.data(), str.size()); - } + + void rebuild(const std::string &str) { rebuild(str.data(), str.size()); } void rebuild(void *data_, size_t size_, free_fn *ffn_, void *hint_ = ZMQ_NULLPTR) { @@ -697,7 +710,7 @@ class message_t std::stringstream os; const unsigned char *msg_data = this->data(); - size_t size_to_print = (std::min)(this->size(), max_size); + size_t size_to_print = std::min(this->size(), max_size); int is_ascii[2] = {0, 0}; // Set is_ascii for the first character if (size_to_print > 0) @@ -1097,8 +1110,7 @@ class mutable_buffer constexpr size_t size() const noexcept { return _size; } mutable_buffer &operator+=(size_t n) noexcept { - // (std::min) is a workaround for when a min macro is defined - const auto shift = (std::min)(n, _size); + const auto shift = std::min(n, _size); _data = static_cast(_data) + shift; _size -= shift; return *this; @@ -1111,8 +1123,8 @@ class mutable_buffer inline mutable_buffer operator+(const mutable_buffer &mb, size_t n) noexcept { - return mutable_buffer(static_cast(mb.data()) + (std::min)(n, mb.size()), - mb.size() - (std::min)(n, mb.size())); + return mutable_buffer(static_cast(mb.data()) + std::min(n, mb.size()), + mb.size() - std::min(n, mb.size())); } inline mutable_buffer operator+(size_t n, const mutable_buffer &mb) noexcept { @@ -1138,7 +1150,7 @@ class const_buffer constexpr size_t size() const noexcept { return _size; } const_buffer &operator+=(size_t n) noexcept { - const auto shift = (std::min)(n, _size); + const auto shift = std::min(n, _size); _data = static_cast(_data) + shift; _size -= shift; return *this; @@ -1152,8 +1164,8 @@ class const_buffer inline const_buffer operator+(const const_buffer &cb, size_t n) noexcept { return const_buffer(static_cast(cb.data()) - + (std::min)(n, cb.size()), - cb.size() - (std::min)(n, cb.size())); + + std::min(n, cb.size()), + cb.size() - std::min(n, cb.size())); } inline const_buffer operator+(size_t n, const const_buffer &cb) noexcept { @@ -1176,7 +1188,7 @@ constexpr mutable_buffer buffer(const mutable_buffer &mb) noexcept } inline mutable_buffer buffer(const mutable_buffer &mb, size_t n) noexcept { - return mutable_buffer(mb.data(), (std::min)(mb.size(), n)); + return mutable_buffer(mb.data(), std::min(mb.size(), n)); } constexpr const_buffer buffer(const const_buffer &cb) noexcept { @@ -1184,7 +1196,7 @@ constexpr const_buffer buffer(const const_buffer &cb) noexcept } inline const_buffer buffer(const const_buffer &cb, size_t n) noexcept { - return const_buffer(cb.data(), (std::min)(cb.size(), n)); + return const_buffer(cb.data(), std::min(cb.size(), n)); } namespace detail @@ -1210,7 +1222,7 @@ template constexpr auto seq_size(const C &c) noexcept -> decltype(c.siz return c.size(); } template -constexpr size_t seq_size(const T (&/*array*/)[N]) noexcept +constexpr size_t seq_size(const T (& /*array*/)[N]) noexcept { return N; } @@ -1237,7 +1249,7 @@ auto buffer_contiguous_sequence(Seq &&seq, size_t n_bytes) noexcept const auto size = seq_size(seq); return buffer(size != 0u ? std::addressof(*std::begin(seq)) : nullptr, - (std::min)(size * sizeof(T), n_bytes)); + std::min(size * sizeof(T), n_bytes)); } } // namespace detail @@ -1437,19 +1449,29 @@ template struct array_option #define ZMQ_DEFINE_INTEGRAL_OPT(OPT, NAME, TYPE) \ using NAME##_t = integral_option; \ - ZMQ_INLINE_VAR ZMQ_CONSTEXPR_VAR NAME##_t NAME {} + ZMQ_INLINE_VAR ZMQ_CONSTEXPR_VAR NAME##_t NAME \ + { \ + } #define ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(OPT, NAME, TYPE) \ using NAME##_t = integral_option; \ - ZMQ_INLINE_VAR ZMQ_CONSTEXPR_VAR NAME##_t NAME {} + ZMQ_INLINE_VAR ZMQ_CONSTEXPR_VAR NAME##_t NAME \ + { \ + } #define ZMQ_DEFINE_ARRAY_OPT(OPT, NAME) \ using NAME##_t = array_option; \ - ZMQ_INLINE_VAR ZMQ_CONSTEXPR_VAR NAME##_t NAME {} + ZMQ_INLINE_VAR ZMQ_CONSTEXPR_VAR NAME##_t NAME \ + { \ + } #define ZMQ_DEFINE_ARRAY_OPT_BINARY(OPT, NAME) \ using NAME##_t = array_option; \ - ZMQ_INLINE_VAR ZMQ_CONSTEXPR_VAR NAME##_t NAME {} + ZMQ_INLINE_VAR ZMQ_CONSTEXPR_VAR NAME##_t NAME \ + { \ + } #define ZMQ_DEFINE_ARRAY_OPT_BIN_OR_Z85(OPT, NAME) \ using NAME##_t = array_option; \ - ZMQ_INLINE_VAR ZMQ_CONSTEXPR_VAR NAME##_t NAME {} + ZMQ_INLINE_VAR ZMQ_CONSTEXPR_VAR NAME##_t NAME \ + { \ + } // deprecated, use zmq::fd_t using cppzmq_fd_t = ::zmq::fd_t; @@ -1567,7 +1589,9 @@ ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_MULTICAST_LOOP, multicast_loop, int); ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_MULTICAST_MAXTPDU, multicast_maxtpdu, int); #endif #ifdef ZMQ_ONLY_FIRST_SUBSCRIBE -ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_ONLY_FIRST_SUBSCRIBE, only_first_subscribe, int); +ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_ONLY_FIRST_SUBSCRIBE, + only_first_subscribe, + int); #endif #ifdef ZMQ_PLAIN_SERVER ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_PLAIN_SERVER, plain_server, int); @@ -1711,7 +1735,9 @@ ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_XPUB_VERBOSER, xpub_verboser, int); ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_XPUB_MANUAL, xpub_manual, int); #endif #ifdef ZMQ_XPUB_MANUAL_LAST_VALUE -ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_XPUB_MANUAL_LAST_VALUE, xpub_manual_last_value, int); +ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_XPUB_MANUAL_LAST_VALUE, + xpub_manual_last_value, + int); #endif #ifdef ZMQ_XPUB_NODROP ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_XPUB_NODROP, xpub_nodrop, int); @@ -2032,7 +2058,7 @@ class socket_base zmq_recv(_handle, buf.data(), buf.size(), static_cast(flags)); if (nbytes >= 0) { return recv_buffer_size{ - (std::min)(static_cast(nbytes), buf.size()), + std::min(static_cast(nbytes), buf.size()), static_cast(nbytes)}; } if (zmq_errno() == EAGAIN) @@ -2144,27 +2170,33 @@ inline bool operator!=(std::nullptr_t /*p*/, socket_ref sr) ZMQ_NOTHROW } #endif -inline bool operator==(const detail::socket_base& a, const detail::socket_base& b) ZMQ_NOTHROW +inline bool operator==(const detail::socket_base &a, + const detail::socket_base &b) ZMQ_NOTHROW { return std::equal_to()(a.handle(), b.handle()); } -inline bool operator!=(const detail::socket_base& a, const detail::socket_base& b) ZMQ_NOTHROW +inline bool operator!=(const detail::socket_base &a, + const detail::socket_base &b) ZMQ_NOTHROW { return !(a == b); } -inline bool operator<(const detail::socket_base& a, const detail::socket_base& b) ZMQ_NOTHROW +inline bool operator<(const detail::socket_base &a, + const detail::socket_base &b) ZMQ_NOTHROW { return std::less()(a.handle(), b.handle()); } -inline bool operator>(const detail::socket_base& a, const detail::socket_base& b) ZMQ_NOTHROW +inline bool operator>(const detail::socket_base &a, + const detail::socket_base &b) ZMQ_NOTHROW { return b < a; } -inline bool operator<=(const detail::socket_base& a, const detail::socket_base& b) ZMQ_NOTHROW +inline bool operator<=(const detail::socket_base &a, + const detail::socket_base &b) ZMQ_NOTHROW { return !(a > b); } -inline bool operator>=(const detail::socket_base& a, const detail::socket_base& b) ZMQ_NOTHROW +inline bool operator>=(const detail::socket_base &a, + const detail::socket_base &b) ZMQ_NOTHROW { return !(a < b); } @@ -2374,11 +2406,11 @@ class monitor_t {_monitor_socket.handle(), 0, ZMQ_POLLIN, 0}, }; - #ifdef ZMQ_CPP11 +#ifdef ZMQ_CPP11 zmq::poll(&items[0], 1, std::chrono::milliseconds(timeout)); - #else +#else zmq::poll(&items[0], 1, timeout); - #endif +#endif return process_event(items[0].revents); } @@ -2492,7 +2524,7 @@ class monitor_t (void) addr_; } - protected: + protected: bool process_event(short events) { zmq::message_t eventMsg; @@ -2571,7 +2603,8 @@ class monitor_t case ZMQ_EVENT_DISCONNECTED: on_event_disconnected(*event, address.c_str()); break; -#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 3, 0) || (defined(ZMQ_BUILD_DRAFT_API) && ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 3)) +#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 3, 0) \ + || (defined(ZMQ_BUILD_DRAFT_API) && ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 3)) case ZMQ_EVENT_HANDSHAKE_FAILED_NO_DETAIL: on_event_handshake_failed_no_detail(*event, address.c_str()); break; @@ -2600,7 +2633,7 @@ class monitor_t return true; } - socket_ref monitor_socket() {return _monitor_socket;} + socket_ref monitor_socket() { return _monitor_socket; } private: monitor_t(const monitor_t &) ZMQ_DELETED_FUNCTION; @@ -2720,14 +2753,13 @@ template class poller_t { if (0 != zmq_poller_modify_fd(poller_ptr.get(), fd, - static_cast(events))) { + static_cast(events))) { throw error_t(); } } - template - size_t wait_all(Sequence &poller_events, - const std::chrono::milliseconds timeout) + template + size_t wait_all(Sequence &poller_events, const std::chrono::milliseconds timeout) { static_assert(std::is_same::value, "Sequence::value_type must be of poller_t::event_type"); @@ -2754,7 +2786,7 @@ template class poller_t { int rc = zmq_poller_size(const_cast(poller_ptr.get())); ZMQ_ASSERT(rc >= 0); - return static_cast((std::max)(rc, 0)); + return static_cast(std::max(rc, 0)); } #endif @@ -2876,4 +2908,15 @@ class timers } // namespace zmq +#ifdef _WIN32 +#ifdef WINDOWS_MIN +#define min WINDOWS_MIN +#undef WINDOWS_MIN +#endif +#ifdef WINDOWS_MAX +#define max WINDOWS_MAX +#undef WINDOWS_MAX +#endif +#endif + #endif // __ZMQ_HPP_INCLUDED__ diff --git a/zmq_addon.hpp b/zmq_addon.hpp index c6b4462c..168735d4 100644 --- a/zmq_addon.hpp +++ b/zmq_addon.hpp @@ -37,60 +37,57 @@ namespace zmq { - // socket ref or native file descriptor for poller - class poller_ref_t - { - public: - enum RefType - { - RT_SOCKET, - RT_FD - }; - - poller_ref_t() : poller_ref_t(socket_ref{}) - {} - - poller_ref_t(const zmq::socket_ref& socket) : data{RT_SOCKET, socket, {}} - {} - - poller_ref_t(zmq::fd_t fd) : data{RT_FD, {}, fd} - {} - - size_t hash() const ZMQ_NOTHROW - { - std::size_t h = 0; - hash_combine(h, std::get<0>(data)); - hash_combine(h, std::get<1>(data)); - hash_combine(h, std::get<2>(data)); - return h; - } - - bool operator == (const poller_ref_t& o) const ZMQ_NOTHROW - { - return data == o.data; - } - - private: - template - static void hash_combine(std::size_t& seed, const T& v) ZMQ_NOTHROW - { - std::hash hasher; - seed ^= hasher(v) + 0x9e3779b9 + (seed<<6) + (seed>>2); - } - - std::tuple data; - - }; // class poller_ref_t +// socket ref or native file descriptor for poller +class poller_ref_t +{ + public: + enum RefType + { + RT_SOCKET, + RT_FD + }; + + poller_ref_t() : poller_ref_t(socket_ref{}) {} + + poller_ref_t(const zmq::socket_ref &socket) : data{RT_SOCKET, socket, {}} {} + + poller_ref_t(zmq::fd_t fd) : data{RT_FD, {}, fd} {} + + size_t hash() const ZMQ_NOTHROW + { + std::size_t h = 0; + hash_combine(h, std::get<0>(data)); + hash_combine(h, std::get<1>(data)); + hash_combine(h, std::get<2>(data)); + return h; + } + + bool operator==(const poller_ref_t &o) const ZMQ_NOTHROW + { + return data == o.data; + } + + private: + template + static void hash_combine(std::size_t &seed, const T &v) ZMQ_NOTHROW + { + std::hash hasher; + seed ^= hasher(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2); + } + + std::tuple data; + +}; // class poller_ref_t } // namespace zmq // std::hash<> specialization for std::unordered_map -template <> struct std::hash +template<> struct std::hash { - size_t operator()(const zmq::poller_ref_t& ref) const ZMQ_NOTHROW - { - return ref.hash(); - } + size_t operator()(const zmq::poller_ref_t &ref) const ZMQ_NOTHROW + { + return ref.hash(); + } }; #endif // ZMQ_CPP11 @@ -401,7 +398,10 @@ class multipart_t multipart_t(message_t &&message) { add(std::move(message)); } // Move constructor - multipart_t(multipart_t &&other) ZMQ_NOTHROW { m_parts = std::move(other.m_parts); } + multipart_t(multipart_t &&other) ZMQ_NOTHROW + { + m_parts = std::move(other.m_parts); + } // Move assignment operator multipart_t &operator=(multipart_t &&other) ZMQ_NOTHROW @@ -744,9 +744,10 @@ class active_poller_t const poller_ref_t ref{socket}; if (!handler) - throw std::invalid_argument("null handler in active_poller_t::add (socket)"); - auto ret = handlers.emplace( - ref, std::make_shared(std::move(handler))); + throw std::invalid_argument( + "null handler in active_poller_t::add (socket)"); + auto ret = + handlers.emplace(ref, std::make_shared(std::move(handler))); if (!ret.second) throw error_t(EINVAL); // already added try { @@ -766,8 +767,8 @@ class active_poller_t if (!handler) throw std::invalid_argument("null handler in active_poller_t::add (fd)"); - auto ret = handlers.emplace( - ref, std::make_shared(std::move(handler))); + auto ret = + handlers.emplace(ref, std::make_shared(std::move(handler))); if (!ret.second) throw error_t(EINVAL); // already added try { @@ -800,10 +801,7 @@ class active_poller_t base_poller.modify(socket, events); } - void modify(fd_t fd, event_flags events) - { - base_poller.modify(fd, events); - } + void modify(fd_t fd, event_flags events) { base_poller.modify(fd, events); } size_t wait(std::chrono::milliseconds timeout) { @@ -839,7 +837,7 @@ class active_poller_t std::vector poller_events{}; std::vector> poller_handlers{}; -}; // class active_poller_t +}; // class active_poller_t #endif // defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) && defined(ZMQ_HAVE_POLLER)