mirror of
https://github.com/zeromq/cppzmq.git
synced 2025-03-01 10:57:59 +01:00
Merge pull request #317 from gummif/gfa/typesafe-send-recv
Problem: send/recv functions lack type-safety
This commit is contained in:
Simon Giesecke
GitHub
commit
6f0fb2a3ea
17
README.md
17
README.md
@ -39,6 +39,21 @@ Supported platforms
|
||||
- Any platform supported by libzmq that provides a sufficiently recent gcc (4.8.1 or newer) or clang (3.3 or newer)
|
||||
- Visual Studio 2012+ x86/x64
|
||||
|
||||
Examples
|
||||
========
|
||||
```c++
|
||||
#include <string>
|
||||
#include <zmq.hpp>
|
||||
int main()
|
||||
{
|
||||
zmq::context_t ctx;
|
||||
zmq::socket_t sock(ctx, zmq::socket_type::push);
|
||||
sock.bind("inproc://test");
|
||||
const std::string_view m = "Hello, world";
|
||||
sock.send(zmq::buffer(m), zmq::send_flags::dontwait);
|
||||
}
|
||||
```
|
||||
|
||||
Contribution policy
|
||||
===================
|
||||
|
||||
@ -74,5 +89,3 @@ cpp zmq (which will also include libzmq for you).
|
||||
find_package(cppzmq)
|
||||
target_link_libraries(*Your Project Name* cppzmq)
|
||||
```
|
||||
|
||||
|
||||
|
||||
@ -17,6 +17,7 @@ find_package(Threads)
|
||||
|
||||
add_executable(
|
||||
unit_tests
|
||||
buffer.cpp
|
||||
message.cpp
|
||||
context.cpp
|
||||
socket.cpp
|
||||
|
||||
@ -157,7 +157,7 @@ TEST_CASE("poll basic", "[active_poller]")
|
||||
{
|
||||
server_client_setup s;
|
||||
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}));
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}, zmq::send_flags::none));
|
||||
|
||||
zmq::active_poller_t active_poller;
|
||||
bool message_received = false;
|
||||
@ -184,7 +184,7 @@ TEST_CASE("client server", "[active_poller]")
|
||||
zmq::active_poller_t::handler_t handler = [&](short e) {
|
||||
if (0 != (e & ZMQ_POLLIN)) {
|
||||
zmq::message_t zmq_msg;
|
||||
CHECK_NOTHROW(s.server.recv(&zmq_msg)); // get message
|
||||
CHECK_NOTHROW(s.server.recv(zmq_msg)); // get message
|
||||
std::string recv_msg(zmq_msg.data<char>(), zmq_msg.size());
|
||||
CHECK(send_msg == recv_msg);
|
||||
} else if (0 != (e & ~ZMQ_POLLOUT)) {
|
||||
@ -197,7 +197,7 @@ TEST_CASE("client server", "[active_poller]")
|
||||
CHECK_NOTHROW(active_poller.add(s.server, ZMQ_POLLIN, handler));
|
||||
|
||||
// client sends message
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{send_msg}));
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{send_msg}, zmq::send_flags::none));
|
||||
|
||||
CHECK(1 == active_poller.wait(std::chrono::milliseconds{-1}));
|
||||
CHECK(events == ZMQ_POLLIN);
|
||||
@ -236,7 +236,7 @@ TEST_CASE("remove invalid socket throws", "[active_poller]")
|
||||
TEST_CASE("wait on added empty handler", "[active_poller]")
|
||||
{
|
||||
server_client_setup s;
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}));
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}, zmq::send_flags::none));
|
||||
zmq::active_poller_t active_poller;
|
||||
zmq::active_poller_t::handler_t handler;
|
||||
CHECK_NOTHROW(active_poller.add(s.server, ZMQ_POLLIN, handler));
|
||||
@ -291,7 +291,7 @@ TEST_CASE("poll client server", "[active_poller]")
|
||||
CHECK_NOTHROW(active_poller.add(s.server, ZMQ_POLLIN, s.handler));
|
||||
|
||||
// client sends message
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}));
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}, zmq::send_flags::none));
|
||||
|
||||
// wait for message and verify events
|
||||
CHECK_NOTHROW(active_poller.wait(std::chrono::milliseconds{500}));
|
||||
@ -316,7 +316,7 @@ TEST_CASE("wait one return", "[active_poller]")
|
||||
active_poller.add(s.server, ZMQ_POLLIN, [&count](short) { ++count; }));
|
||||
|
||||
// client sends message
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}));
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}, zmq::send_flags::none));
|
||||
|
||||
// wait for message and verify events
|
||||
CHECK(1 == active_poller.wait(std::chrono::milliseconds{500}));
|
||||
@ -326,7 +326,7 @@ TEST_CASE("wait one return", "[active_poller]")
|
||||
TEST_CASE("wait on move constructed active_poller", "[active_poller]")
|
||||
{
|
||||
server_client_setup s;
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}));
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}, zmq::send_flags::none));
|
||||
zmq::active_poller_t a;
|
||||
zmq::active_poller_t::handler_t handler;
|
||||
CHECK_NOTHROW(a.add(s.server, ZMQ_POLLIN, handler));
|
||||
@ -340,7 +340,7 @@ TEST_CASE("wait on move constructed active_poller", "[active_poller]")
|
||||
TEST_CASE("wait on move assigned active_poller", "[active_poller]")
|
||||
{
|
||||
server_client_setup s;
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}));
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}, zmq::send_flags::none));
|
||||
zmq::active_poller_t a;
|
||||
zmq::active_poller_t::handler_t handler;
|
||||
CHECK_NOTHROW(a.add(s.server, ZMQ_POLLIN, handler));
|
||||
@ -361,14 +361,14 @@ TEST_CASE("received on move constructed active_poller", "[active_poller]")
|
||||
zmq::active_poller_t a;
|
||||
CHECK_NOTHROW(a.add(s.server, ZMQ_POLLIN, [&count](short) { ++count; }));
|
||||
// client sends message
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}));
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}, zmq::send_flags::none));
|
||||
// wait for message and verify it is received
|
||||
CHECK(1 == a.wait(std::chrono::milliseconds{500}));
|
||||
CHECK(1u == count);
|
||||
// Move construct active_poller b
|
||||
zmq::active_poller_t b{std::move(a)};
|
||||
// client sends message again
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}));
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}, zmq::send_flags::none));
|
||||
// wait for message and verify it is received
|
||||
CHECK(1 == b.wait(std::chrono::milliseconds{500}));
|
||||
CHECK(2u == count);
|
||||
@ -399,7 +399,7 @@ TEST_CASE("remove from handler", "[active_poller]")
|
||||
CHECK(ITER_NO == active_poller.size());
|
||||
// Clients send messages
|
||||
for (auto &s : setup_list) {
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}));
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}, zmq::send_flags::none));
|
||||
}
|
||||
|
||||
// Wait for all servers to receive a message
|
||||
|
||||
260
tests/buffer.cpp
Normal file
260
tests/buffer.cpp
Normal file
@ -0,0 +1,260 @@
|
||||
#include <catch.hpp>
|
||||
#include <zmq.hpp>
|
||||
|
||||
#ifdef ZMQ_CPP17
|
||||
static_assert(std::is_nothrow_swappable_v<zmq::const_buffer>);
|
||||
static_assert(std::is_nothrow_swappable_v<zmq::mutable_buffer>);
|
||||
static_assert(std::is_trivially_copyable_v<zmq::const_buffer>);
|
||||
static_assert(std::is_trivially_copyable_v<zmq::mutable_buffer>);
|
||||
#endif
|
||||
|
||||
#ifdef ZMQ_CPP11
|
||||
|
||||
using BT = int16_t;
|
||||
|
||||
TEST_CASE("buffer default ctor", "[buffer]")
|
||||
{
|
||||
constexpr zmq::mutable_buffer mb;
|
||||
constexpr zmq::const_buffer cb;
|
||||
CHECK(mb.size() == 0);
|
||||
CHECK(mb.data() == nullptr);
|
||||
CHECK(cb.size() == 0);
|
||||
CHECK(cb.data() == nullptr);
|
||||
}
|
||||
|
||||
TEST_CASE("buffer data ctor", "[buffer]")
|
||||
{
|
||||
std::vector<BT> v(10);
|
||||
zmq::const_buffer cb(v.data(), v.size() * sizeof(BT));
|
||||
CHECK(cb.size() == v.size() * sizeof(BT));
|
||||
CHECK(cb.data() == v.data());
|
||||
zmq::mutable_buffer mb(v.data(), v.size() * sizeof(BT));
|
||||
CHECK(mb.size() == v.size() * sizeof(BT));
|
||||
CHECK(mb.data() == v.data());
|
||||
zmq::const_buffer from_mut = mb;
|
||||
CHECK(mb.size() == from_mut.size());
|
||||
CHECK(mb.data() == from_mut.data());
|
||||
const auto cmb = mb;
|
||||
static_assert(std::is_same<decltype(cmb.data()), void*>::value, "");
|
||||
|
||||
constexpr const void* cp = nullptr;
|
||||
constexpr void* p = nullptr;
|
||||
constexpr zmq::const_buffer cecb = zmq::buffer(p, 0);
|
||||
constexpr zmq::mutable_buffer cemb = zmq::buffer(p, 0);
|
||||
CHECK(cecb.data() == nullptr);
|
||||
CHECK(cemb.data() == nullptr);
|
||||
}
|
||||
|
||||
TEST_CASE("const_buffer operator+", "[buffer]")
|
||||
{
|
||||
std::vector<BT> v(10);
|
||||
zmq::const_buffer cb(v.data(), v.size() * sizeof(BT));
|
||||
const size_t shift = 4;
|
||||
auto shifted = cb + shift;
|
||||
CHECK(shifted.size() == v.size() * sizeof(BT) - shift);
|
||||
CHECK(shifted.data() == v.data() + shift / sizeof(BT));
|
||||
auto shifted2 = shift + cb;
|
||||
CHECK(shifted.size() == shifted2.size());
|
||||
CHECK(shifted.data() == shifted2.data());
|
||||
auto cbinp = cb;
|
||||
cbinp += shift;
|
||||
CHECK(shifted.size() == cbinp.size());
|
||||
CHECK(shifted.data() == cbinp.data());
|
||||
}
|
||||
|
||||
TEST_CASE("mutable_buffer operator+", "[buffer]")
|
||||
{
|
||||
std::vector<BT> v(10);
|
||||
zmq::mutable_buffer mb(v.data(), v.size() * sizeof(BT));
|
||||
const size_t shift = 4;
|
||||
auto shifted = mb + shift;
|
||||
CHECK(shifted.size() == v.size() * sizeof(BT) - shift);
|
||||
CHECK(shifted.data() == v.data() + shift / sizeof(BT));
|
||||
auto shifted2 = shift + mb;
|
||||
CHECK(shifted.size() == shifted2.size());
|
||||
CHECK(shifted.data() == shifted2.data());
|
||||
auto mbinp = mb;
|
||||
mbinp += shift;
|
||||
CHECK(shifted.size() == mbinp.size());
|
||||
CHECK(shifted.data() == mbinp.data());
|
||||
}
|
||||
|
||||
TEST_CASE("mutable_buffer creation basic", "[buffer]")
|
||||
{
|
||||
std::vector<BT> v(10);
|
||||
zmq::mutable_buffer mb(v.data(), v.size() * sizeof(BT));
|
||||
zmq::mutable_buffer mb2 = zmq::buffer(v.data(), v.size() * sizeof(BT));
|
||||
CHECK(mb.data() == mb2.data());
|
||||
CHECK(mb.size() == mb2.size());
|
||||
zmq::mutable_buffer mb3 = zmq::buffer(mb);
|
||||
CHECK(mb.data() == mb3.data());
|
||||
CHECK(mb.size() == mb3.size());
|
||||
zmq::mutable_buffer mb4 = zmq::buffer(mb, 10 * v.size() * sizeof(BT));
|
||||
CHECK(mb.data() == mb4.data());
|
||||
CHECK(mb.size() == mb4.size());
|
||||
zmq::mutable_buffer mb5 = zmq::buffer(mb, 4);
|
||||
CHECK(mb.data() == mb5.data());
|
||||
CHECK(4 == mb5.size());
|
||||
}
|
||||
|
||||
TEST_CASE("const_buffer creation basic", "[buffer]")
|
||||
{
|
||||
const std::vector<BT> v(10);
|
||||
zmq::const_buffer cb(v.data(), v.size() * sizeof(BT));
|
||||
zmq::const_buffer cb2 = zmq::buffer(v.data(), v.size() * sizeof(BT));
|
||||
CHECK(cb.data() == cb2.data());
|
||||
CHECK(cb.size() == cb2.size());
|
||||
zmq::const_buffer cb3 = zmq::buffer(cb);
|
||||
CHECK(cb.data() == cb3.data());
|
||||
CHECK(cb.size() == cb3.size());
|
||||
zmq::const_buffer cb4 = zmq::buffer(cb, 10 * v.size() * sizeof(BT));
|
||||
CHECK(cb.data() == cb4.data());
|
||||
CHECK(cb.size() == cb4.size());
|
||||
zmq::const_buffer cb5 = zmq::buffer(cb, 4);
|
||||
CHECK(cb.data() == cb5.data());
|
||||
CHECK(4 == cb5.size());
|
||||
}
|
||||
|
||||
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<BT*>(d));
|
||||
zmq::const_buffer b2 = zmq::buffer(d, 4);
|
||||
CHECK(b2.size() == 4);
|
||||
CHECK(b2.data() == static_cast<BT*>(d));
|
||||
}
|
||||
|
||||
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<const BT*>(d));
|
||||
zmq::const_buffer b2 = zmq::buffer(d, 4);
|
||||
CHECK(b2.size() == 4);
|
||||
CHECK(b2.data() == static_cast<const BT*>(d));
|
||||
}
|
||||
|
||||
TEST_CASE("mutable_buffer creation array", "[buffer]")
|
||||
{
|
||||
std::array<BT, 10> d = {};
|
||||
zmq::mutable_buffer b = zmq::buffer(d);
|
||||
CHECK(b.size() == d.size() * sizeof(BT));
|
||||
CHECK(b.data() == d.data());
|
||||
zmq::mutable_buffer b2 = zmq::buffer(d, 4);
|
||||
CHECK(b2.size() == 4);
|
||||
CHECK(b2.data() == d.data());
|
||||
}
|
||||
|
||||
TEST_CASE("const_buffer creation array", "[buffer]")
|
||||
{
|
||||
const std::array<BT, 10> d = {};
|
||||
zmq::const_buffer b = zmq::buffer(d);
|
||||
CHECK(b.size() == d.size() * sizeof(BT));
|
||||
CHECK(b.data() == d.data());
|
||||
zmq::const_buffer b2 = zmq::buffer(d, 4);
|
||||
CHECK(b2.size() == 4);
|
||||
CHECK(b2.data() == d.data());
|
||||
}
|
||||
|
||||
TEST_CASE("const_buffer creation array 2", "[buffer]")
|
||||
{
|
||||
std::array<const BT, 10> d = {{}};
|
||||
zmq::const_buffer b = zmq::buffer(d);
|
||||
CHECK(b.size() == d.size() * sizeof(BT));
|
||||
CHECK(b.data() == d.data());
|
||||
zmq::const_buffer b2 = zmq::buffer(d, 4);
|
||||
CHECK(b2.size() == 4);
|
||||
CHECK(b2.data() == d.data());
|
||||
}
|
||||
|
||||
TEST_CASE("mutable_buffer creation vector", "[buffer]")
|
||||
{
|
||||
std::vector<BT> d(10);
|
||||
zmq::mutable_buffer b = zmq::buffer(d);
|
||||
CHECK(b.size() == d.size() * sizeof(BT));
|
||||
CHECK(b.data() == d.data());
|
||||
zmq::mutable_buffer b2 = zmq::buffer(d, 4);
|
||||
CHECK(b2.size() == 4);
|
||||
CHECK(b2.data() == d.data());
|
||||
d.clear();
|
||||
b = zmq::buffer(d);
|
||||
CHECK(b.size() == 0);
|
||||
CHECK(b.data() == nullptr);
|
||||
}
|
||||
|
||||
TEST_CASE("const_buffer creation vector", "[buffer]")
|
||||
{
|
||||
std::vector<BT> d(10);
|
||||
zmq::const_buffer b = zmq::buffer(static_cast<const std::vector<BT>&>(d));
|
||||
CHECK(b.size() == d.size() * sizeof(BT));
|
||||
CHECK(b.data() == d.data());
|
||||
zmq::const_buffer b2 = zmq::buffer(static_cast<const std::vector<BT>&>(d), 4);
|
||||
CHECK(b2.size() == 4);
|
||||
CHECK(b2.data() == d.data());
|
||||
d.clear();
|
||||
b = zmq::buffer(static_cast<const std::vector<BT>&>(d));
|
||||
CHECK(b.size() == 0);
|
||||
CHECK(b.data() == nullptr);
|
||||
}
|
||||
|
||||
TEST_CASE("const_buffer creation string", "[buffer]")
|
||||
{
|
||||
const std::wstring d(10, L'a');
|
||||
zmq::const_buffer b = zmq::buffer(d);
|
||||
CHECK(b.size() == d.size() * sizeof(wchar_t));
|
||||
CHECK(b.data() == d.data());
|
||||
zmq::const_buffer b2 = zmq::buffer(d, 4);
|
||||
CHECK(b2.size() == 4);
|
||||
CHECK(b2.data() == d.data());
|
||||
}
|
||||
|
||||
TEST_CASE("mutable_buffer creation string", "[buffer]")
|
||||
{
|
||||
std::wstring d(10, L'a');
|
||||
zmq::mutable_buffer b = zmq::buffer(d);
|
||||
CHECK(b.size() == d.size() * sizeof(wchar_t));
|
||||
CHECK(b.data() == d.data());
|
||||
zmq::mutable_buffer b2 = zmq::buffer(d, 4);
|
||||
CHECK(b2.size() == 4);
|
||||
CHECK(b2.data() == d.data());
|
||||
}
|
||||
|
||||
#ifdef ZMQ_CPP17
|
||||
TEST_CASE("const_buffer creation string_view", "[buffer]")
|
||||
{
|
||||
std::wstring dstr(10, L'a');
|
||||
std::wstring_view d = dstr;
|
||||
zmq::const_buffer b = zmq::buffer(d);
|
||||
CHECK(b.size() == d.size() * sizeof(wchar_t));
|
||||
CHECK(b.data() == d.data());
|
||||
zmq::const_buffer b2 = zmq::buffer(d, 4);
|
||||
CHECK(b2.size() == 4);
|
||||
CHECK(b2.data() == d.data());
|
||||
}
|
||||
#endif
|
||||
|
||||
TEST_CASE("buffer of structs", "[buffer]")
|
||||
{
|
||||
struct some_pod
|
||||
{
|
||||
int64_t val;
|
||||
char arr[8];
|
||||
};
|
||||
struct some_non_pod
|
||||
{
|
||||
int64_t val;
|
||||
char arr[8];
|
||||
std::vector<int> s; // not trivially copyable
|
||||
};
|
||||
static_assert(zmq::detail::is_pod_like<some_pod>::value, "");
|
||||
static_assert(!zmq::detail::is_pod_like<some_non_pod>::value, "");
|
||||
std::array<some_pod, 1> d;
|
||||
zmq::mutable_buffer b = zmq::buffer(d);
|
||||
CHECK(b.size() == d.size() * sizeof(some_pod));
|
||||
CHECK(b.data() == d.data());
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -142,7 +142,7 @@ TEST_CASE("poller poll basic", "[poller]")
|
||||
{
|
||||
common_server_client_setup s;
|
||||
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}));
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}, zmq::send_flags::none));
|
||||
|
||||
zmq::poller_t<int> poller;
|
||||
std::vector<zmq_poller_event_t> events{1};
|
||||
@ -220,7 +220,7 @@ TEST_CASE("poller poll client server", "[poller]")
|
||||
CHECK_NOTHROW(poller.add(s.server, ZMQ_POLLIN, s.server));
|
||||
|
||||
// client sends message
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}));
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}, zmq::send_flags::none));
|
||||
|
||||
// wait for message and verify events
|
||||
std::vector<zmq_poller_event_t> events(1);
|
||||
@ -243,7 +243,7 @@ TEST_CASE("poller wait one return", "[poller]")
|
||||
CHECK_NOTHROW(poller.add(s.server, ZMQ_POLLIN, nullptr));
|
||||
|
||||
// client sends message
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}));
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}, zmq::send_flags::none));
|
||||
|
||||
// wait for message and verify events
|
||||
std::vector<zmq_poller_event_t> events(1);
|
||||
@ -253,7 +253,7 @@ TEST_CASE("poller wait one return", "[poller]")
|
||||
TEST_CASE("poller wait on move constructed", "[poller]")
|
||||
{
|
||||
common_server_client_setup s;
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}));
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}, zmq::send_flags::none));
|
||||
zmq::poller_t<> a;
|
||||
CHECK_NOTHROW(a.add(s.server, ZMQ_POLLIN, nullptr));
|
||||
zmq::poller_t<> b{std::move(a)};
|
||||
@ -266,7 +266,7 @@ TEST_CASE("poller wait on move constructed", "[poller]")
|
||||
TEST_CASE("poller wait on move assigned", "[poller]")
|
||||
{
|
||||
common_server_client_setup s;
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}));
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}, zmq::send_flags::none));
|
||||
zmq::poller_t<> a;
|
||||
CHECK_NOTHROW(a.add(s.server, ZMQ_POLLIN, nullptr));
|
||||
zmq::poller_t<> b;
|
||||
@ -293,7 +293,7 @@ TEST_CASE("poller remove from handler", "[poller]")
|
||||
}
|
||||
// Clients send messages
|
||||
for (auto &s : setup_list) {
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}));
|
||||
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}, zmq::send_flags::none));
|
||||
}
|
||||
|
||||
// Wait for all servers to receive a message
|
||||
|
||||
168
tests/socket.cpp
168
tests/socket.cpp
@ -46,6 +46,34 @@ TEST_CASE("socket swap", "[socket]")
|
||||
using std::swap;
|
||||
swap(socket1, socket2);
|
||||
}
|
||||
|
||||
TEST_CASE("socket flags", "[socket]")
|
||||
{
|
||||
CHECK((zmq::recv_flags::dontwait | zmq::recv_flags::none)
|
||||
== static_cast<zmq::recv_flags>(ZMQ_DONTWAIT | 0));
|
||||
CHECK((zmq::recv_flags::dontwait & zmq::recv_flags::none)
|
||||
== static_cast<zmq::recv_flags>(ZMQ_DONTWAIT & 0));
|
||||
CHECK((zmq::recv_flags::dontwait ^ zmq::recv_flags::none)
|
||||
== static_cast<zmq::recv_flags>(ZMQ_DONTWAIT ^ 0));
|
||||
CHECK(~zmq::recv_flags::dontwait == static_cast<zmq::recv_flags>(~ZMQ_DONTWAIT));
|
||||
|
||||
CHECK((zmq::send_flags::dontwait | zmq::send_flags::sndmore)
|
||||
== static_cast<zmq::send_flags>(ZMQ_DONTWAIT | ZMQ_SNDMORE));
|
||||
CHECK((zmq::send_flags::dontwait & zmq::send_flags::sndmore)
|
||||
== static_cast<zmq::send_flags>(ZMQ_DONTWAIT & ZMQ_SNDMORE));
|
||||
CHECK((zmq::send_flags::dontwait ^ zmq::send_flags::sndmore)
|
||||
== static_cast<zmq::send_flags>(ZMQ_DONTWAIT ^ ZMQ_SNDMORE));
|
||||
CHECK(~zmq::send_flags::dontwait == static_cast<zmq::send_flags>(~ZMQ_DONTWAIT));
|
||||
}
|
||||
|
||||
TEST_CASE("socket readme example", "[socket]")
|
||||
{
|
||||
zmq::context_t ctx;
|
||||
zmq::socket_t sock(ctx, zmq::socket_type::push);
|
||||
sock.bind("inproc://test");
|
||||
const std::string m = "Hello, world";
|
||||
sock.send(zmq::buffer(m), zmq::send_flags::dontwait);
|
||||
}
|
||||
#endif
|
||||
|
||||
TEST_CASE("socket sends and receives const buffer", "[socket]")
|
||||
@ -55,13 +83,149 @@ TEST_CASE("socket sends and receives const buffer", "[socket]")
|
||||
zmq::socket_t receiver(context, ZMQ_PAIR);
|
||||
receiver.bind("inproc://test");
|
||||
sender.connect("inproc://test");
|
||||
CHECK(2 == sender.send("Hi", 2));
|
||||
const char* str = "Hi";
|
||||
|
||||
#ifdef ZMQ_CPP11
|
||||
CHECK(2 == *sender.send(zmq::buffer(str, 2)));
|
||||
char buf[2];
|
||||
const auto res = receiver.recv(zmq::buffer(buf));
|
||||
CHECK(res);
|
||||
CHECK(!res->truncated());
|
||||
CHECK(2 == res->size);
|
||||
#else
|
||||
CHECK(2 == sender.send(str, 2));
|
||||
char buf[2];
|
||||
CHECK(2 == receiver.recv(buf, 2));
|
||||
CHECK(0 == memcmp(buf, "Hi", 2));
|
||||
#endif
|
||||
CHECK(0 == memcmp(buf, str, 2));
|
||||
}
|
||||
|
||||
#ifdef ZMQ_CPP11
|
||||
|
||||
TEST_CASE("socket send none sndmore", "[socket]")
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::socket_t s(context, zmq::socket_type::router);
|
||||
s.bind("inproc://test");
|
||||
|
||||
std::vector<char> buf(4);
|
||||
auto res = s.send(zmq::buffer(buf), zmq::send_flags::sndmore);
|
||||
CHECK(res);
|
||||
CHECK(*res == buf.size());
|
||||
res = s.send(zmq::buffer(buf));
|
||||
CHECK(res);
|
||||
CHECK(*res == buf.size());
|
||||
}
|
||||
|
||||
TEST_CASE("socket send dontwait", "[socket]")
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::socket_t s(context, zmq::socket_type::push);
|
||||
s.bind("inproc://test");
|
||||
|
||||
std::vector<char> buf(4);
|
||||
auto res = s.send(zmq::buffer(buf), zmq::send_flags::dontwait);
|
||||
CHECK(!res);
|
||||
res = s.send(zmq::buffer(buf),
|
||||
zmq::send_flags::dontwait | zmq::send_flags::sndmore);
|
||||
CHECK(!res);
|
||||
|
||||
zmq::message_t msg;
|
||||
auto resm = s.send(msg, zmq::send_flags::dontwait);
|
||||
CHECK(!resm);
|
||||
CHECK(msg.size() == 0);
|
||||
}
|
||||
|
||||
TEST_CASE("socket send exception", "[socket]")
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::socket_t s(context, zmq::socket_type::pull);
|
||||
s.bind("inproc://test");
|
||||
|
||||
std::vector<char> buf(4);
|
||||
CHECK_THROWS_AS(s.send(zmq::buffer(buf)), const zmq::error_t &);
|
||||
}
|
||||
|
||||
TEST_CASE("socket recv none", "[socket]")
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::socket_t s(context, zmq::socket_type::pair);
|
||||
zmq::socket_t s2(context, zmq::socket_type::pair);
|
||||
s2.bind("inproc://test");
|
||||
s.connect("inproc://test");
|
||||
|
||||
std::vector<char> sbuf(4);
|
||||
const auto res_send = s2.send(zmq::buffer(sbuf));
|
||||
CHECK(res_send);
|
||||
CHECK(res_send.has_value());
|
||||
|
||||
std::vector<char> buf(2);
|
||||
const auto res = s.recv(zmq::buffer(buf));
|
||||
CHECK(res.has_value());
|
||||
CHECK(res->truncated());
|
||||
CHECK(res->untruncated_size == sbuf.size());
|
||||
CHECK(res->size == buf.size());
|
||||
|
||||
const auto res_send2 = s2.send(zmq::buffer(sbuf));
|
||||
CHECK(res_send2.has_value());
|
||||
std::vector<char> buf2(10);
|
||||
const auto res2 = s.recv(zmq::buffer(buf2));
|
||||
CHECK(res2.has_value());
|
||||
CHECK(!res2->truncated());
|
||||
CHECK(res2->untruncated_size == sbuf.size());
|
||||
CHECK(res2->size == sbuf.size());
|
||||
}
|
||||
|
||||
TEST_CASE("socket send recv message_t", "[socket]")
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::socket_t s(context, zmq::socket_type::pair);
|
||||
zmq::socket_t s2(context, zmq::socket_type::pair);
|
||||
s2.bind("inproc://test");
|
||||
s.connect("inproc://test");
|
||||
|
||||
zmq::message_t smsg(size_t{10});
|
||||
const auto res_send = s2.send(smsg, zmq::send_flags::none);
|
||||
CHECK(res_send);
|
||||
CHECK(*res_send == 10);
|
||||
CHECK(smsg.size() == 0);
|
||||
|
||||
zmq::message_t rmsg;
|
||||
const auto res = s.recv(rmsg);
|
||||
CHECK(res);
|
||||
CHECK(*res == 10);
|
||||
CHECK(res.value() == 10);
|
||||
CHECK(rmsg.size() == *res);
|
||||
}
|
||||
|
||||
TEST_CASE("socket recv dontwait", "[socket]")
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::socket_t s(context, zmq::socket_type::pull);
|
||||
s.bind("inproc://test");
|
||||
|
||||
std::vector<char> buf(4);
|
||||
constexpr auto flags = zmq::recv_flags::none | zmq::recv_flags::dontwait;
|
||||
auto res = s.recv(zmq::buffer(buf), flags);
|
||||
CHECK(!res);
|
||||
|
||||
zmq::message_t msg;
|
||||
auto resm = s.recv(msg, flags);
|
||||
CHECK(!resm);
|
||||
CHECK_THROWS_AS(resm.value(), const std::exception &);
|
||||
CHECK(msg.size() == 0);
|
||||
}
|
||||
|
||||
TEST_CASE("socket recv exception", "[socket]")
|
||||
{
|
||||
zmq::context_t context;
|
||||
zmq::socket_t s(context, zmq::socket_type::push);
|
||||
s.bind("inproc://test");
|
||||
|
||||
std::vector<char> buf(4);
|
||||
CHECK_THROWS_AS(s.recv(zmq::buffer(buf)), const zmq::error_t &);
|
||||
}
|
||||
|
||||
TEST_CASE("socket proxy", "[socket]")
|
||||
{
|
||||
zmq::context_t context;
|
||||
|
||||
538
zmq.hpp
538
zmq.hpp
@ -75,10 +75,18 @@
|
||||
#include <algorithm>
|
||||
#include <exception>
|
||||
#include <iomanip>
|
||||
#include <iterator>
|
||||
#include <sstream>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#ifdef ZMQ_CPP11
|
||||
#include <array>
|
||||
#include <chrono>
|
||||
#include <tuple>
|
||||
#include <memory>
|
||||
#endif
|
||||
#ifdef ZMQ_CPP17
|
||||
#include <optional>
|
||||
#endif
|
||||
|
||||
/* Version macros for compile-time API version detection */
|
||||
#define CPPZMQ_VERSION_MAJOR 4
|
||||
@ -89,12 +97,6 @@
|
||||
ZMQ_MAKE_VERSION(CPPZMQ_VERSION_MAJOR, CPPZMQ_VERSION_MINOR, \
|
||||
CPPZMQ_VERSION_PATCH)
|
||||
|
||||
#ifdef ZMQ_CPP11
|
||||
#include <chrono>
|
||||
#include <tuple>
|
||||
#include <memory>
|
||||
#endif
|
||||
|
||||
// Detect whether the compiler supports C++11 rvalue references.
|
||||
#if (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 2)) \
|
||||
&& defined(__GXX_EXPERIMENTAL_CXX0X__))
|
||||
@ -276,6 +278,8 @@ class message_t
|
||||
}
|
||||
|
||||
#if defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11)
|
||||
// TODO: this function is too greedy, must add
|
||||
// SFINAE for begin and end support.
|
||||
template<typename T>
|
||||
explicit message_t(const T &msg_) : message_t(std::begin(msg_), std::end(msg_))
|
||||
{
|
||||
@ -612,8 +616,438 @@ inline void swap(context_t &a, context_t &b) ZMQ_NOTHROW {
|
||||
a.swap(b);
|
||||
}
|
||||
|
||||
#ifdef ZMQ_CPP11
|
||||
|
||||
struct recv_buffer_size
|
||||
{
|
||||
size_t size; // number of bytes written to buffer
|
||||
size_t untruncated_size; // untruncated message size in bytes
|
||||
|
||||
ZMQ_NODISCARD bool truncated() const noexcept
|
||||
{
|
||||
return size != untruncated_size;
|
||||
}
|
||||
};
|
||||
|
||||
namespace detail
|
||||
{
|
||||
|
||||
#ifdef ZMQ_CPP17
|
||||
using send_result_t = std::optional<size_t>;
|
||||
using recv_result_t = std::optional<size_t>;
|
||||
using recv_buffer_result_t = std::optional<recv_buffer_size>;
|
||||
#else
|
||||
// A C++11 type emulating the most basic
|
||||
// operations of std::optional for trivial types
|
||||
template<class T> class trivial_optional
|
||||
{
|
||||
public:
|
||||
static_assert(std::is_trivial<T>::value, "T must be trivial");
|
||||
using value_type = T;
|
||||
|
||||
trivial_optional() = default;
|
||||
trivial_optional(T value) noexcept : _value(value), _has_value(true) {}
|
||||
|
||||
const T *operator->() const noexcept
|
||||
{
|
||||
assert(_has_value);
|
||||
return &_value;
|
||||
}
|
||||
T *operator->() noexcept
|
||||
{
|
||||
assert(_has_value);
|
||||
return &_value;
|
||||
}
|
||||
|
||||
const T &operator*() const noexcept
|
||||
{
|
||||
assert(_has_value);
|
||||
return _value;
|
||||
}
|
||||
T &operator*() noexcept
|
||||
{
|
||||
assert(_has_value);
|
||||
return _value;
|
||||
}
|
||||
|
||||
T &value()
|
||||
{
|
||||
if (!_has_value)
|
||||
throw std::exception();
|
||||
return _value;
|
||||
}
|
||||
const T &value() const
|
||||
{
|
||||
if (!_has_value)
|
||||
throw std::exception();
|
||||
return _value;
|
||||
}
|
||||
|
||||
explicit operator bool() const noexcept { return _has_value; }
|
||||
bool has_value() const noexcept { return _has_value; }
|
||||
|
||||
private:
|
||||
T _value{};
|
||||
bool _has_value{false};
|
||||
};
|
||||
|
||||
using send_result_t = trivial_optional<size_t>;
|
||||
using recv_result_t = trivial_optional<size_t>;
|
||||
using recv_buffer_result_t = trivial_optional<recv_buffer_size>;
|
||||
#endif
|
||||
|
||||
template<class T>
|
||||
constexpr T enum_bit_or(T a, T b) noexcept
|
||||
{
|
||||
static_assert(std::is_enum<T>::value, "must be enum");
|
||||
using U = typename std::underlying_type<T>::type;
|
||||
return static_cast<T>(static_cast<U>(a) | static_cast<U>(b));
|
||||
}
|
||||
template<class T>
|
||||
constexpr T enum_bit_and(T a, T b) noexcept
|
||||
{
|
||||
static_assert(std::is_enum<T>::value, "must be enum");
|
||||
using U = typename std::underlying_type<T>::type;
|
||||
return static_cast<T>(static_cast<U>(a) & static_cast<U>(b));
|
||||
}
|
||||
template<class T>
|
||||
constexpr T enum_bit_xor(T a, T b) noexcept
|
||||
{
|
||||
static_assert(std::is_enum<T>::value, "must be enum");
|
||||
using U = typename std::underlying_type<T>::type;
|
||||
return static_cast<T>(static_cast<U>(a) ^ static_cast<U>(b));
|
||||
}
|
||||
template<class T>
|
||||
constexpr T enum_bit_not(T a) noexcept
|
||||
{
|
||||
static_assert(std::is_enum<T>::value, "must be enum");
|
||||
using U = typename std::underlying_type<T>::type;
|
||||
return static_cast<T>(~static_cast<U>(a));
|
||||
}
|
||||
} // namespace detail
|
||||
|
||||
// partially satisfies named requirement BitmaskType
|
||||
enum class send_flags : int
|
||||
{
|
||||
none = 0,
|
||||
dontwait = ZMQ_DONTWAIT,
|
||||
sndmore = ZMQ_SNDMORE
|
||||
};
|
||||
|
||||
constexpr send_flags operator|(send_flags a, send_flags b) noexcept
|
||||
{
|
||||
return detail::enum_bit_or(a, b);
|
||||
}
|
||||
constexpr send_flags operator&(send_flags a, send_flags b) noexcept
|
||||
{
|
||||
return detail::enum_bit_and(a, b);
|
||||
}
|
||||
constexpr send_flags operator^(send_flags a, send_flags b) noexcept
|
||||
{
|
||||
return detail::enum_bit_xor(a, b);
|
||||
}
|
||||
constexpr send_flags operator~(send_flags a) noexcept
|
||||
{
|
||||
return detail::enum_bit_not(a);
|
||||
}
|
||||
|
||||
// partially satisfies named requirement BitmaskType
|
||||
enum class recv_flags : int
|
||||
{
|
||||
none = 0,
|
||||
dontwait = ZMQ_DONTWAIT
|
||||
};
|
||||
|
||||
constexpr recv_flags operator|(recv_flags a, recv_flags b) noexcept
|
||||
{
|
||||
return detail::enum_bit_or(a, b);
|
||||
}
|
||||
constexpr recv_flags operator&(recv_flags a, recv_flags b) noexcept
|
||||
{
|
||||
return detail::enum_bit_and(a, b);
|
||||
}
|
||||
constexpr recv_flags operator^(recv_flags a, recv_flags b) noexcept
|
||||
{
|
||||
return detail::enum_bit_xor(a, b);
|
||||
}
|
||||
constexpr recv_flags operator~(recv_flags a) noexcept
|
||||
{
|
||||
return detail::enum_bit_not(a);
|
||||
}
|
||||
|
||||
|
||||
// mutable_buffer, const_buffer and buffer are based on
|
||||
// the Networking TS specification, draft:
|
||||
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/n4771.pdf
|
||||
|
||||
class mutable_buffer
|
||||
{
|
||||
public:
|
||||
constexpr mutable_buffer() noexcept : _data(nullptr), _size(0) {}
|
||||
constexpr mutable_buffer(void *p, size_t n) noexcept : _data(p), _size(n)
|
||||
{
|
||||
#ifdef ZMQ_CPP14
|
||||
assert(p != nullptr || n == 0);
|
||||
#endif
|
||||
}
|
||||
|
||||
constexpr void *data() const noexcept { return _data; }
|
||||
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);
|
||||
_data = static_cast<char *>(_data) + shift;
|
||||
_size -= shift;
|
||||
return *this;
|
||||
}
|
||||
|
||||
private:
|
||||
void *_data;
|
||||
size_t _size;
|
||||
};
|
||||
|
||||
inline mutable_buffer operator+(const mutable_buffer &mb, size_t n) noexcept
|
||||
{
|
||||
return mutable_buffer(static_cast<char *>(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
|
||||
{
|
||||
return mb + n;
|
||||
}
|
||||
|
||||
class const_buffer
|
||||
{
|
||||
public:
|
||||
constexpr const_buffer() noexcept : _data(nullptr), _size(0) {}
|
||||
constexpr const_buffer(const void *p, size_t n) noexcept : _data(p), _size(n)
|
||||
{
|
||||
#ifdef ZMQ_CPP14
|
||||
assert(p != nullptr || n == 0);
|
||||
#endif
|
||||
}
|
||||
constexpr const_buffer(const mutable_buffer &mb) noexcept :
|
||||
_data(mb.data()),
|
||||
_size(mb.size())
|
||||
{
|
||||
}
|
||||
|
||||
constexpr const void *data() const noexcept { return _data; }
|
||||
constexpr size_t size() const noexcept { return _size; }
|
||||
const_buffer &operator+=(size_t n) noexcept
|
||||
{
|
||||
const auto shift = (std::min)(n, _size);
|
||||
_data = static_cast<const char *>(_data) + shift;
|
||||
_size -= shift;
|
||||
return *this;
|
||||
}
|
||||
|
||||
private:
|
||||
const void *_data;
|
||||
size_t _size;
|
||||
};
|
||||
|
||||
inline const_buffer operator+(const const_buffer &cb, size_t n) noexcept
|
||||
{
|
||||
return const_buffer(static_cast<const char *>(cb.data())
|
||||
+ (std::min)(n, cb.size()),
|
||||
cb.size() - (std::min)(n, cb.size()));
|
||||
}
|
||||
inline const_buffer operator+(size_t n, const const_buffer &cb) noexcept
|
||||
{
|
||||
return cb + n;
|
||||
}
|
||||
|
||||
// buffer creation
|
||||
|
||||
constexpr mutable_buffer buffer(void* p, size_t n) noexcept
|
||||
{
|
||||
return mutable_buffer(p, n);
|
||||
}
|
||||
constexpr const_buffer buffer(const void* p, size_t n) noexcept
|
||||
{
|
||||
return const_buffer(p, n);
|
||||
}
|
||||
constexpr mutable_buffer buffer(const mutable_buffer& mb) noexcept
|
||||
{
|
||||
return mb;
|
||||
}
|
||||
inline mutable_buffer buffer(const mutable_buffer& mb, size_t n) noexcept
|
||||
{
|
||||
return mutable_buffer(mb.data(), (std::min)(mb.size(), n));
|
||||
}
|
||||
constexpr const_buffer buffer(const const_buffer& cb) noexcept
|
||||
{
|
||||
return cb;
|
||||
}
|
||||
inline const_buffer buffer(const const_buffer& cb, size_t n) noexcept
|
||||
{
|
||||
return const_buffer(cb.data(), (std::min)(cb.size(), n));
|
||||
}
|
||||
|
||||
namespace detail
|
||||
{
|
||||
template<class T> struct is_pod_like
|
||||
{
|
||||
// NOTE: The networking draft N4771 section 16.11 requires
|
||||
// T in the buffer functions below to be
|
||||
// trivially copyable OR standard layout.
|
||||
// Here we decide to be conservative and require both.
|
||||
static constexpr bool value =
|
||||
std::is_trivially_copyable<T>::value && std::is_standard_layout<T>::value;
|
||||
};
|
||||
|
||||
template<class C> constexpr auto seq_size(const C &c) noexcept -> decltype(c.size())
|
||||
{
|
||||
return c.size();
|
||||
}
|
||||
template<class T, size_t N>
|
||||
constexpr size_t seq_size(const T (&/*array*/)[N]) noexcept
|
||||
{
|
||||
return N;
|
||||
}
|
||||
|
||||
template<class Seq>
|
||||
auto buffer_contiguous_sequence(Seq &&seq) noexcept
|
||||
-> decltype(buffer(std::addressof(*std::begin(seq)), size_t{}))
|
||||
{
|
||||
using T = typename std::remove_cv<
|
||||
typename std::remove_reference<decltype(*std::begin(seq))>::type>::type;
|
||||
static_assert(detail::is_pod_like<T>::value, "T must be POD");
|
||||
|
||||
const auto size = seq_size(seq);
|
||||
return buffer(size != 0u ? std::addressof(*std::begin(seq)) : nullptr,
|
||||
size * sizeof(T));
|
||||
}
|
||||
template<class Seq>
|
||||
auto buffer_contiguous_sequence(Seq &&seq, size_t n_bytes) noexcept
|
||||
-> decltype(buffer_contiguous_sequence(seq))
|
||||
{
|
||||
using T = typename std::remove_cv<
|
||||
typename std::remove_reference<decltype(*std::begin(seq))>::type>::type;
|
||||
static_assert(detail::is_pod_like<T>::value, "T must be POD");
|
||||
|
||||
const auto size = seq_size(seq);
|
||||
return buffer(size != 0u ? std::addressof(*std::begin(seq)) : nullptr,
|
||||
(std::min)(size * sizeof(T), n_bytes));
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
|
||||
// C array
|
||||
template<class T, size_t N> mutable_buffer buffer(T (&data)[N]) noexcept
|
||||
{
|
||||
return detail::buffer_contiguous_sequence(data);
|
||||
}
|
||||
template<class T, size_t N>
|
||||
mutable_buffer buffer(T (&data)[N], size_t n_bytes) noexcept
|
||||
{
|
||||
return detail::buffer_contiguous_sequence(data, n_bytes);
|
||||
}
|
||||
template<class T, size_t N> const_buffer buffer(const T (&data)[N]) noexcept
|
||||
{
|
||||
return detail::buffer_contiguous_sequence(data);
|
||||
}
|
||||
template<class T, size_t N>
|
||||
const_buffer buffer(const T (&data)[N], size_t n_bytes) noexcept
|
||||
{
|
||||
return detail::buffer_contiguous_sequence(data, n_bytes);
|
||||
}
|
||||
// std::array
|
||||
template<class T, size_t N> mutable_buffer buffer(std::array<T, N> &data) noexcept
|
||||
{
|
||||
return detail::buffer_contiguous_sequence(data);
|
||||
}
|
||||
template<class T, size_t N>
|
||||
mutable_buffer buffer(std::array<T, N> &data, size_t n_bytes) noexcept
|
||||
{
|
||||
return detail::buffer_contiguous_sequence(data, n_bytes);
|
||||
}
|
||||
template<class T, size_t N>
|
||||
const_buffer buffer(std::array<const T, N> &data) noexcept
|
||||
{
|
||||
return detail::buffer_contiguous_sequence(data);
|
||||
}
|
||||
template<class T, size_t N>
|
||||
const_buffer buffer(std::array<const T, N> &data, size_t n_bytes) noexcept
|
||||
{
|
||||
return detail::buffer_contiguous_sequence(data, n_bytes);
|
||||
}
|
||||
template<class T, size_t N>
|
||||
const_buffer buffer(const std::array<T, N> &data) noexcept
|
||||
{
|
||||
return detail::buffer_contiguous_sequence(data);
|
||||
}
|
||||
template<class T, size_t N>
|
||||
const_buffer buffer(const std::array<T, N> &data, size_t n_bytes) noexcept
|
||||
{
|
||||
return detail::buffer_contiguous_sequence(data, n_bytes);
|
||||
}
|
||||
// std::vector
|
||||
template<class T, class Allocator>
|
||||
mutable_buffer buffer(std::vector<T, Allocator> &data) noexcept
|
||||
{
|
||||
return detail::buffer_contiguous_sequence(data);
|
||||
}
|
||||
template<class T, class Allocator>
|
||||
mutable_buffer buffer(std::vector<T, Allocator> &data, size_t n_bytes) noexcept
|
||||
{
|
||||
return detail::buffer_contiguous_sequence(data, n_bytes);
|
||||
}
|
||||
template<class T, class Allocator>
|
||||
const_buffer buffer(const std::vector<T, Allocator> &data) noexcept
|
||||
{
|
||||
return detail::buffer_contiguous_sequence(data);
|
||||
}
|
||||
template<class T, class Allocator>
|
||||
const_buffer buffer(const std::vector<T, Allocator> &data, size_t n_bytes) noexcept
|
||||
{
|
||||
return detail::buffer_contiguous_sequence(data, n_bytes);
|
||||
}
|
||||
// std::basic_string
|
||||
template<class T, class Traits, class Allocator>
|
||||
mutable_buffer buffer(std::basic_string<T, Traits, Allocator> &data) noexcept
|
||||
{
|
||||
return detail::buffer_contiguous_sequence(data);
|
||||
}
|
||||
template<class T, class Traits, class Allocator>
|
||||
mutable_buffer buffer(std::basic_string<T, Traits, Allocator> &data,
|
||||
size_t n_bytes) noexcept
|
||||
{
|
||||
return detail::buffer_contiguous_sequence(data, n_bytes);
|
||||
}
|
||||
template<class T, class Traits, class Allocator>
|
||||
const_buffer buffer(const std::basic_string<T, Traits, Allocator> &data) noexcept
|
||||
{
|
||||
return detail::buffer_contiguous_sequence(data);
|
||||
}
|
||||
template<class T, class Traits, class Allocator>
|
||||
const_buffer buffer(const std::basic_string<T, Traits, Allocator> &data,
|
||||
size_t n_bytes) noexcept
|
||||
{
|
||||
return detail::buffer_contiguous_sequence(data, n_bytes);
|
||||
}
|
||||
|
||||
#ifdef ZMQ_CPP17
|
||||
// std::basic_string_view
|
||||
template<class T, class Traits>
|
||||
const_buffer buffer(std::basic_string_view<T, Traits> data) noexcept
|
||||
{
|
||||
return detail::buffer_contiguous_sequence(data);
|
||||
}
|
||||
template<class T, class Traits>
|
||||
const_buffer buffer(std::basic_string_view<T, Traits> data, size_t n_bytes) noexcept
|
||||
{
|
||||
return detail::buffer_contiguous_sequence(data, n_bytes);
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // ZMQ_CPP11
|
||||
|
||||
namespace detail
|
||||
{
|
||||
|
||||
class socket_base
|
||||
{
|
||||
public:
|
||||
@ -685,6 +1119,9 @@ public:
|
||||
|
||||
bool connected() const ZMQ_NOTHROW { return (_handle != ZMQ_NULLPTR); }
|
||||
|
||||
#ifdef ZMQ_CPP11
|
||||
ZMQ_DEPRECATED("from 4.3.1, use send taking a const_buffer and send_flags")
|
||||
#endif
|
||||
size_t send(const void *buf_, size_t len_, int flags_ = 0)
|
||||
{
|
||||
int nbytes = zmq_send(_handle, buf_, len_, flags_);
|
||||
@ -695,7 +1132,11 @@ public:
|
||||
throw error_t();
|
||||
}
|
||||
|
||||
bool send(message_t &msg_, int flags_ = 0)
|
||||
#ifdef ZMQ_CPP11
|
||||
ZMQ_DEPRECATED("from 4.3.1, use send taking message_t and send_flags")
|
||||
#endif
|
||||
bool send(message_t &msg_,
|
||||
int flags_ = 0) // default until removed
|
||||
{
|
||||
int nbytes = zmq_msg_send(msg_.handle(), _handle, flags_);
|
||||
if (nbytes >= 0)
|
||||
@ -712,9 +1153,51 @@ public:
|
||||
}
|
||||
|
||||
#ifdef ZMQ_HAS_RVALUE_REFS
|
||||
bool send(message_t &&msg_, int flags_ = 0) { return send(msg_, flags_); }
|
||||
#ifdef ZMQ_CPP11
|
||||
ZMQ_DEPRECATED("from 4.3.1, use send taking message_t and send_flags")
|
||||
#endif
|
||||
bool send(message_t &&msg_,
|
||||
int flags_ = 0) // default until removed
|
||||
{
|
||||
#ifdef ZMQ_CPP11
|
||||
return send(msg_, static_cast<send_flags>(flags_)).has_value();
|
||||
#else
|
||||
return send(msg_, flags_);
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef ZMQ_CPP11
|
||||
detail::send_result_t send(const_buffer buf, send_flags flags = send_flags::none)
|
||||
{
|
||||
const int nbytes =
|
||||
zmq_send(_handle, buf.data(), buf.size(), static_cast<int>(flags));
|
||||
if (nbytes >= 0)
|
||||
return static_cast<size_t>(nbytes);
|
||||
if (zmq_errno() == EAGAIN)
|
||||
return {};
|
||||
throw error_t();
|
||||
}
|
||||
|
||||
detail::send_result_t send(message_t &msg, send_flags flags)
|
||||
{
|
||||
int nbytes = zmq_msg_send(msg.handle(), _handle, static_cast<int>(flags));
|
||||
if (nbytes >= 0)
|
||||
return static_cast<size_t>(nbytes);
|
||||
if (zmq_errno() == EAGAIN)
|
||||
return {};
|
||||
throw error_t();
|
||||
}
|
||||
|
||||
detail::send_result_t send(message_t &&msg, send_flags flags)
|
||||
{
|
||||
return send(msg, flags);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef ZMQ_CPP11
|
||||
ZMQ_DEPRECATED("from 4.3.1, use recv taking a mutable_buffer and recv_flags")
|
||||
#endif
|
||||
size_t recv(void *buf_, size_t len_, int flags_ = 0)
|
||||
{
|
||||
int nbytes = zmq_recv(_handle, buf_, len_, flags_);
|
||||
@ -725,7 +1208,14 @@ public:
|
||||
throw error_t();
|
||||
}
|
||||
|
||||
bool recv(message_t *msg_, int flags_ = 0)
|
||||
#ifdef ZMQ_CPP11
|
||||
ZMQ_DEPRECATED("from 4.3.1, use recv taking a reference to message_t and recv_flags")
|
||||
#endif
|
||||
bool recv(message_t *msg_, int flags_
|
||||
#ifndef ZMQ_CPP11
|
||||
= 0
|
||||
#endif
|
||||
)
|
||||
{
|
||||
int nbytes = zmq_msg_recv(msg_->handle(), _handle, flags_);
|
||||
if (nbytes >= 0)
|
||||
@ -735,6 +1225,34 @@ public:
|
||||
throw error_t();
|
||||
}
|
||||
|
||||
#ifdef ZMQ_CPP11
|
||||
detail::recv_buffer_result_t recv(mutable_buffer buf,
|
||||
recv_flags flags = recv_flags::none)
|
||||
{
|
||||
const int nbytes =
|
||||
zmq_recv(_handle, buf.data(), buf.size(), static_cast<int>(flags));
|
||||
if (nbytes >= 0) {
|
||||
return recv_buffer_size{(std::min)(static_cast<size_t>(nbytes), buf.size()),
|
||||
static_cast<size_t>(nbytes)};
|
||||
}
|
||||
if (zmq_errno() == EAGAIN)
|
||||
return {};
|
||||
throw error_t();
|
||||
}
|
||||
|
||||
detail::recv_result_t recv(message_t &msg, recv_flags flags = recv_flags::none)
|
||||
{
|
||||
const int nbytes = zmq_msg_recv(msg.handle(), _handle, static_cast<int>(flags));
|
||||
if (nbytes >= 0) {
|
||||
assert(msg.size() == static_cast<size_t>(nbytes));
|
||||
return static_cast<size_t>(nbytes);
|
||||
}
|
||||
if (zmq_errno() == EAGAIN)
|
||||
return {};
|
||||
throw error_t();
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(ZMQ_BUILD_DRAFT_API) && ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 0)
|
||||
void join(const char* group)
|
||||
{
|
||||
|
||||
@ -130,8 +130,13 @@ class multipart_t
|
||||
bool more = true;
|
||||
while (more) {
|
||||
message_t message;
|
||||
#ifdef ZMQ_CPP11
|
||||
if (!socket.recv(message, static_cast<recv_flags>(flags)))
|
||||
return false;
|
||||
#else
|
||||
if (!socket.recv(&message, flags))
|
||||
return false;
|
||||
#endif
|
||||
more = message.more();
|
||||
add(std::move(message));
|
||||
}
|
||||
@ -146,8 +151,14 @@ class multipart_t
|
||||
while (more) {
|
||||
message_t message = pop();
|
||||
more = size() > 0;
|
||||
#ifdef ZMQ_CPP11
|
||||
if (!socket.send(message,
|
||||
static_cast<send_flags>((more ? ZMQ_SNDMORE : 0) | flags)))
|
||||
return false;
|
||||
#else
|
||||
if (!socket.send(message, (more ? ZMQ_SNDMORE : 0) | flags))
|
||||
return false;
|
||||
#endif
|
||||
}
|
||||
clear();
|
||||
return true;
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user