26 #ifndef __ZMQ_HPP_INCLUDED__
27 #define __ZMQ_HPP_INCLUDED__
38 #if defined(_MSVC_LANG)
39 #define CPPZMQ_LANG _MSVC_LANG
41 #define CPPZMQ_LANG __cplusplus
44 #if defined(_HAS_CXX14) && _HAS_CXX14 && CPPZMQ_LANG < 201402L
46 #define CPPZMQ_LANG 201402L
48 #if defined(_HAS_CXX17) && _HAS_CXX17 && CPPZMQ_LANG < 201703L
50 #define CPPZMQ_LANG 201703L
54 #if CPPZMQ_LANG >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1900)
57 #if CPPZMQ_LANG >= 201402L
60 #if CPPZMQ_LANG >= 201703L
64 #if defined(ZMQ_CPP14) && !defined(_MSC_VER)
65 #define ZMQ_DEPRECATED(msg) [[deprecated(msg)]]
66 #elif defined(_MSC_VER)
67 #define ZMQ_DEPRECATED(msg) __declspec(deprecated(msg))
68 #elif defined(__GNUC__)
69 #define ZMQ_DEPRECATED(msg) __attribute__((deprecated(msg)))
71 #define ZMQ_DEPRECATED(msg)
74 #if defined(ZMQ_CPP17)
75 #define ZMQ_NODISCARD [[nodiscard]]
80 #if defined(ZMQ_CPP11)
81 #define ZMQ_NOTHROW noexcept
82 #define ZMQ_EXPLICIT explicit
83 #define ZMQ_OVERRIDE override
84 #define ZMQ_NULLPTR nullptr
85 #define ZMQ_CONSTEXPR_FN constexpr
86 #define ZMQ_CONSTEXPR_VAR constexpr
87 #define ZMQ_CPP11_DEPRECATED(msg) ZMQ_DEPRECATED(msg)
89 #define ZMQ_NOTHROW throw()
93 #define ZMQ_CONSTEXPR_FN
94 #define ZMQ_CONSTEXPR_VAR const
95 #define ZMQ_CPP11_DEPRECATED(msg)
97 #if defined(ZMQ_CPP14) && (!defined(_MSC_VER) || _MSC_VER > 1900) && (!defined(__GNUC__) || __GNUC__ > 5 || (__GNUC__ == 5 && __GNUC_MINOR__ > 3))
98 #define ZMQ_EXTENDED_CONSTEXPR
100 #if defined(ZMQ_CPP17)
101 #define ZMQ_INLINE_VAR inline
102 #define ZMQ_CONSTEXPR_IF constexpr
104 #define ZMQ_INLINE_VAR
105 #define ZMQ_CONSTEXPR_IF
124 #if defined(__has_include) && defined(ZMQ_CPP17)
125 #define CPPZMQ_HAS_INCLUDE_CPP17(X) __has_include(X)
127 #define CPPZMQ_HAS_INCLUDE_CPP17(X) 0
130 #if CPPZMQ_HAS_INCLUDE_CPP17(<optional>) && !defined(CPPZMQ_HAS_OPTIONAL)
131 #define CPPZMQ_HAS_OPTIONAL 1
133 #ifndef CPPZMQ_HAS_OPTIONAL
134 #define CPPZMQ_HAS_OPTIONAL 0
135 #elif CPPZMQ_HAS_OPTIONAL
139 #if CPPZMQ_HAS_INCLUDE_CPP17(<string_view>) && !defined(CPPZMQ_HAS_STRING_VIEW)
140 #define CPPZMQ_HAS_STRING_VIEW 1
142 #ifndef CPPZMQ_HAS_STRING_VIEW
143 #define CPPZMQ_HAS_STRING_VIEW 0
144 #elif CPPZMQ_HAS_STRING_VIEW
145 #include <string_view>
149 #define CPPZMQ_VERSION_MAJOR 4
150 #define CPPZMQ_VERSION_MINOR 9
151 #define CPPZMQ_VERSION_PATCH 0
153 #define CPPZMQ_VERSION \
154 ZMQ_MAKE_VERSION(CPPZMQ_VERSION_MAJOR, CPPZMQ_VERSION_MINOR, \
155 CPPZMQ_VERSION_PATCH)
158 #if (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 2)) \
159 && defined(__GXX_EXPERIMENTAL_CXX0X__))
160 #define ZMQ_HAS_RVALUE_REFS
161 #define ZMQ_DELETED_FUNCTION = delete
162 #elif defined(__clang__)
163 #if __has_feature(cxx_rvalue_references)
164 #define ZMQ_HAS_RVALUE_REFS
167 #if __has_feature(cxx_deleted_functions)
168 #define ZMQ_DELETED_FUNCTION = delete
170 #define ZMQ_DELETED_FUNCTION
172 #elif defined(_MSC_VER) && (_MSC_VER >= 1900)
173 #define ZMQ_HAS_RVALUE_REFS
174 #define ZMQ_DELETED_FUNCTION = delete
175 #elif defined(_MSC_VER) && (_MSC_VER >= 1600)
176 #define ZMQ_HAS_RVALUE_REFS
177 #define ZMQ_DELETED_FUNCTION
179 #define ZMQ_DELETED_FUNCTION
182 #if defined(ZMQ_CPP11) && !defined(__llvm__) && !defined(__INTEL_COMPILER) \
183 && defined(__GNUC__) && __GNUC__ < 5
184 #define ZMQ_CPP11_PARTIAL
185 #elif defined(__GLIBCXX__) && __GLIBCXX__ < 20160805
188 #define ZMQ_CPP11_PARTIAL
192 #ifdef ZMQ_CPP11_PARTIAL
193 #define ZMQ_IS_TRIVIALLY_COPYABLE(T) __has_trivial_copy(T)
195 #include <type_traits>
196 #define ZMQ_IS_TRIVIALLY_COPYABLE(T) std::is_trivially_copyable<T>::value
200 #if ZMQ_VERSION >= ZMQ_MAKE_VERSION(3, 3, 0)
201 #define ZMQ_NEW_MONITOR_EVENT_LAYOUT
204 #if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 1, 0)
205 #define ZMQ_HAS_PROXY_STEERABLE
215 #if ZMQ_VERSION < ZMQ_MAKE_VERSION(3, 2, 0)
216 #define zmq_msg_recv(msg, socket, flags) zmq_recvmsg(socket, msg, flags)
223 #define ZMQ_ASSERT(expression) assert(expression)
225 #define ZMQ_ASSERT(expression) (void) (expression)
237 template<
class T>
auto begin(T &&r) -> decltype(
begin(std::forward<T>(r)))
239 return begin(std::forward<T>(r));
241 template<
class T>
auto end(T &&r) -> decltype(
end(std::forward<T>(r)))
243 return end(std::forward<T>(r));
250 using iter_value_t =
typename std::iterator_traits<Iter>::value_type;
252 template<
class Range>
253 using range_iter_t = decltype(
256 template<
class Range>
using range_value_t = iter_value_t<range_iter_t<Range>>;
258 template<
class T,
class =
void>
struct is_range : std::false_type
266 ranges::
begin(std::declval<typename std::remove_reference<T>::type &>())
267 ==
ranges::end(std::declval<typename std::remove_reference<T>::type &>()))>>
281 typedef unsigned __int64
fd_t;
283 typedef unsigned int fd_t;
296 return zmq_strerror(
errnum);
305 inline int poll(zmq_pollitem_t *items_,
size_t nitems_,
long timeout_)
307 int rc = zmq_poll(items_,
static_cast<int>(nitems_), timeout_);
315 ZMQ_DEPRECATED(
"from 4.8.0, use poll taking std::chrono::duration instead of long")
316 inline
int poll(zmq_pollitem_t *items_,
size_t nitems_,
long timeout_)
318 inline int poll(zmq_pollitem_t *items_,
size_t nitems_,
long timeout_ = -1)
325 inline
int poll(zmq_pollitem_t const *items_,
size_t nitems_,
long timeout_ = -1)
327 return detail::poll(
const_cast<zmq_pollitem_t *
>(items_), nitems_, timeout_);
333 poll(zmq_pollitem_t const *items,
size_t nitems,
std::chrono::milliseconds timeout)
335 return detail::poll(
const_cast<zmq_pollitem_t *
>(items), nitems,
336 static_cast<long>(timeout.count()));
340 inline
int poll(
std::vector<zmq_pollitem_t> const &items,
341 std::chrono::milliseconds timeout)
343 return detail::poll(
const_cast<zmq_pollitem_t *
>(items.data()), items.size(),
344 static_cast<long>(timeout.count()));
348 inline
int poll(
std::vector<zmq_pollitem_t> const &items,
long timeout_ = -1)
350 return detail::poll(
const_cast<zmq_pollitem_t *
>(items.data()), items.size(), timeout_);
354 poll(zmq_pollitem_t *items,
size_t nitems, std::chrono::milliseconds timeout = std::chrono::milliseconds{-1})
356 return detail::poll(items, nitems,
static_cast<long>(timeout.count()));
359 inline int poll(std::vector<zmq_pollitem_t> &items,
360 std::chrono::milliseconds timeout = std::chrono::milliseconds{-1})
362 return detail::poll(items.data(), items.size(),
static_cast<long>(timeout.count()));
365 ZMQ_DEPRECATED(
"from 4.3.1, use poll taking std::chrono::duration instead of long")
366 inline
int poll(
std::vector<zmq_pollitem_t> &items,
long timeout_)
368 return detail::poll(items.data(), items.size(), timeout_);
371 template<std::
size_t SIZE>
372 inline int poll(std::array<zmq_pollitem_t, SIZE> &items,
373 std::chrono::milliseconds timeout = std::chrono::milliseconds{-1})
375 return detail::poll(items.data(), items.size(),
static_cast<long>(timeout.count()));
380 inline void version(
int *major_,
int *minor_,
int *patch_)
382 zmq_version(major_, minor_, patch_);
386 inline std::tuple<int, int, int>
version()
388 std::tuple<int, int, int> v;
389 zmq_version(&std::get<0>(v), &std::get<1>(v), &std::get<2>(v));
393 #if !defined(ZMQ_CPP11_PARTIAL)
396 template<
class T>
struct is_char_type
399 static constexpr
bool value =
413 int rc = zmq_msg_init(&
msg);
419 int rc = zmq_msg_init_size(&
msg, size_);
424 template<
class ForwardIter>
message_t(ForwardIter first, ForwardIter last)
426 typedef typename std::iterator_traits<ForwardIter>::value_type
value_t;
428 assert(std::distance(first, last) >= 0);
430 static_cast<size_t>(std::distance(first, last)) *
sizeof(
value_t);
431 int const rc = zmq_msg_init_size(&
msg, size_);
434 std::copy(first, last, data<value_t>());
439 int rc = zmq_msg_init_size(&
msg, size_);
445 memcpy(
data(), data_, size_);
451 int rc = zmq_msg_init_data(&
msg, data_, size_, ffn_, hint_);
457 #if defined(ZMQ_CPP11) && !defined(ZMQ_CPP11_PARTIAL)
466 ZMQ_DEPRECATED(
"from 4.7.0, use constructors taking iterators, (pointer, size) "
467 "or strings instead")
473 template<
class Range,
477 && !detail::is_char_type<detail::range_value_t<Range>>::value
486 #if CPPZMQ_HAS_STRING_VIEW
492 #ifdef ZMQ_HAS_RVALUE_REFS
495 int rc = zmq_msg_init(&rhs.msg);
508 int rc = zmq_msg_close(&
msg);
514 int rc = zmq_msg_close(&
msg);
517 rc = zmq_msg_init(&
msg);
523 int rc = zmq_msg_close(&
msg);
526 rc = zmq_msg_init_size(&
msg, size_);
533 int rc = zmq_msg_close(&
msg);
536 rc = zmq_msg_init_size(&
msg, size_);
539 memcpy(
data(), data_, size_);
544 int rc = zmq_msg_close(&
msg);
547 rc = zmq_msg_init_data(&
msg, data_, size_, ffn_, hint_);
552 ZMQ_DEPRECATED(
"from 4.3.1, use move taking non-const reference instead")
555 int rc = zmq_msg_move(&
msg,
const_cast<zmq_msg_t *
>(msg_->handle()));
562 int rc = zmq_msg_move(&
msg, msg_.
handle());
567 ZMQ_DEPRECATED(
"from 4.3.1, use copy taking non-const reference instead")
570 int rc = zmq_msg_copy(&
msg,
const_cast<zmq_msg_t *
>(msg_->handle()));
577 int rc = zmq_msg_copy(&
msg, msg_.
handle());
584 int rc = zmq_msg_more(
const_cast<zmq_msg_t *
>(&
msg));
592 return zmq_msg_data(
const_cast<zmq_msg_t *
>(&
msg));
597 return zmq_msg_size(
const_cast<zmq_msg_t *
>(&
msg));
606 return static_cast<T
const *
>(
data());
614 const size_t my_size =
size();
615 return my_size == other.size() && 0 == memcmp(
data(), other.data(), my_size);
620 return !(*
this == other);
623 #if ZMQ_VERSION >= ZMQ_MAKE_VERSION(3, 2, 0)
626 int value = zmq_msg_get(&
msg, property_);
633 #if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 1, 0)
634 const char *
gets(
const char *property_)
636 const char *value = zmq_msg_gets(&
msg, property_);
643 #if defined(ZMQ_BUILD_DRAFT_API) && ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 0)
644 uint32_t routing_id()
const
646 return zmq_msg_routing_id(
const_cast<zmq_msg_t *
>(&
msg));
649 void set_routing_id(uint32_t routing_id)
651 int rc = zmq_msg_set_routing_id(&
msg, routing_id);
656 const char *group()
const
658 return zmq_msg_group(
const_cast<zmq_msg_t *
>(&
msg));
661 void set_group(
const char *group)
663 int rc = zmq_msg_set_group(&
msg, group);
672 return std::string(
static_cast<const char *
>(
data()),
size());
674 #if CPPZMQ_HAS_STRING_VIEW
691 std::stringstream os;
693 const unsigned char *msg_data = this->data<unsigned char>();
698 os <<
"zmq::message_t [size " << std::dec << std::setw(3)
699 << std::setfill(
'0') <<
size <<
"] (";
702 os <<
"... too big to print)";
707 is_ascii[1] = (
byte >= 32 &&
byte < 127);
715 << std::setfill(
'0') <<
static_cast<short>(
byte);
754 #ifdef ZMQ_IO_THREADS
755 io_threads = ZMQ_IO_THREADS,
757 #ifdef ZMQ_THREAD_SCHED_POLICY
758 thread_sched_policy = ZMQ_THREAD_SCHED_POLICY,
760 #ifdef ZMQ_THREAD_PRIORITY
761 thread_priority = ZMQ_THREAD_PRIORITY,
763 #ifdef ZMQ_THREAD_AFFINITY_CPU_ADD
764 thread_affinity_cpu_add = ZMQ_THREAD_AFFINITY_CPU_ADD,
766 #ifdef ZMQ_THREAD_AFFINITY_CPU_REMOVE
767 thread_affinity_cpu_remove = ZMQ_THREAD_AFFINITY_CPU_REMOVE,
769 #ifdef ZMQ_THREAD_NAME_PREFIX
770 thread_name_prefix = ZMQ_THREAD_NAME_PREFIX,
773 max_msgsz = ZMQ_MAX_MSGSZ,
775 #ifdef ZMQ_ZERO_COPY_RECV
776 zero_copy_recv = ZMQ_ZERO_COPY_RECV,
778 #ifdef ZMQ_MAX_SOCKETS
779 max_sockets = ZMQ_MAX_SOCKETS,
781 #ifdef ZMQ_SOCKET_LIMIT
782 socket_limit = ZMQ_SOCKET_LIMIT,
787 #ifdef ZMQ_MSG_T_SIZE
788 msg_t_size = ZMQ_MSG_T_SIZE
804 explicit context_t(
int io_threads_,
int max_sockets_ = ZMQ_MAX_SOCKETS_DFLT)
810 int rc = zmq_ctx_set(
ptr, ZMQ_IO_THREADS, io_threads_);
813 rc = zmq_ctx_set(
ptr, ZMQ_MAX_SOCKETS, max_sockets_);
817 #ifdef ZMQ_HAS_RVALUE_REFS
832 int rc = zmq_ctx_set(
ptr, option_, optval_);
841 void set(ctxopt option,
int optval)
843 int rc = zmq_ctx_set(
ptr,
static_cast<int>(option), optval);
850 int rc = zmq_ctx_get(
ptr,
static_cast<int>(option));
868 rc = zmq_ctx_term(
ptr);
869 }
while (rc == -1 && errno == EINTR);
882 int rc = zmq_ctx_shutdown(
ptr);
914 struct recv_buffer_size
917 size_t untruncated_size;
921 return size != untruncated_size;
925 #if CPPZMQ_HAS_OPTIONAL
927 using send_result_t = std::optional<size_t>;
928 using recv_result_t = std::optional<size_t>;
929 using recv_buffer_result_t = std::optional<recv_buffer_size>;
937 template<
class T>
class trivial_optional
941 using value_type = T;
943 trivial_optional() =
default;
944 trivial_optional(T value) noexcept : _value(value), _has_value(
true) {}
946 const T *operator->() const noexcept
951 T *operator->() noexcept
957 const T &operator*() const noexcept
962 T &operator*() noexcept
971 throw std::exception();
974 const T &
value()
const
977 throw std::exception();
981 explicit operator bool() const noexcept {
return _has_value; }
982 bool has_value() const noexcept {
return _has_value; }
986 bool _has_value{
false};
990 using send_result_t = detail::trivial_optional<size_t>;
991 using recv_result_t = detail::trivial_optional<size_t>;
992 using recv_buffer_result_t = detail::trivial_optional<recv_buffer_size>;
998 template<
class T> constexpr T enum_bit_or(T a, T b) noexcept
1001 using U =
typename std::underlying_type<T>::type;
1002 return static_cast<T
>(
static_cast<U
>(a) |
static_cast<U
>(b));
1004 template<
class T> constexpr T enum_bit_and(T a, T b) noexcept
1007 using U =
typename std::underlying_type<T>::type;
1008 return static_cast<T
>(
static_cast<U
>(a) &
static_cast<U
>(b));
1010 template<
class T> constexpr T enum_bit_xor(T a, T b) noexcept
1013 using U =
typename std::underlying_type<T>::type;
1014 return static_cast<T
>(
static_cast<U
>(a) ^
static_cast<U
>(b));
1016 template<
class T> constexpr T enum_bit_not(T a) noexcept
1019 using U =
typename std::underlying_type<T>::type;
1020 return static_cast<T
>(~static_cast<U>(a));
1025 enum class send_flags : int
1028 dontwait = ZMQ_DONTWAIT,
1029 sndmore = ZMQ_SNDMORE
1032 constexpr send_flags
operator|(send_flags a, send_flags b) noexcept
1034 return detail::enum_bit_or(a, b);
1036 constexpr send_flags
operator&(send_flags a, send_flags b) noexcept
1038 return detail::enum_bit_and(a, b);
1040 constexpr send_flags
operator^(send_flags a, send_flags b) noexcept
1042 return detail::enum_bit_xor(a, b);
1044 constexpr send_flags
operator~(send_flags a) noexcept
1046 return detail::enum_bit_not(a);
1050 enum class recv_flags : int
1053 dontwait = ZMQ_DONTWAIT
1056 constexpr recv_flags
operator|(recv_flags a, recv_flags b) noexcept
1058 return detail::enum_bit_or(a, b);
1060 constexpr recv_flags
operator&(recv_flags a, recv_flags b) noexcept
1062 return detail::enum_bit_and(a, b);
1064 constexpr recv_flags
operator^(recv_flags a, recv_flags b) noexcept
1066 return detail::enum_bit_xor(a, b);
1068 constexpr recv_flags
operator~(recv_flags a) noexcept
1070 return detail::enum_bit_not(a);
1078 class mutable_buffer
1081 constexpr mutable_buffer() noexcept : _data(
nullptr), _size(0) {}
1082 constexpr mutable_buffer(
void *
p,
size_t n) noexcept : _data(
p), _size(
n)
1084 #ifdef ZMQ_EXTENDED_CONSTEXPR
1085 assert(
p !=
nullptr ||
n == 0);
1089 constexpr
void *data() const noexcept {
return _data; }
1090 constexpr
size_t size() const noexcept {
return _size; }
1091 mutable_buffer &operator+=(
size_t n) noexcept
1094 const auto shift = (std::min)(
n, _size);
1095 _data =
static_cast<char *
>(_data) + shift;
1105 inline mutable_buffer
operator+(
const mutable_buffer &mb,
size_t n) noexcept
1107 return mutable_buffer(
static_cast<char *
>(mb.data()) + (std::min)(
n, mb.size()),
1108 mb.size() - (std::min)(
n, mb.size()));
1110 inline mutable_buffer
operator+(
size_t n,
const mutable_buffer &mb) noexcept
1118 constexpr const_buffer() noexcept : _data(
nullptr), _size(0) {}
1119 constexpr const_buffer(
const void *
p,
size_t n) noexcept : _data(
p), _size(
n)
1121 #ifdef ZMQ_EXTENDED_CONSTEXPR
1122 assert(
p !=
nullptr ||
n == 0);
1125 constexpr const_buffer(
const mutable_buffer &mb) noexcept :
1126 _data(mb.data()), _size(mb.size())
1130 constexpr
const void *data() const noexcept {
return _data; }
1131 constexpr
size_t size() const noexcept {
return _size; }
1132 const_buffer &operator+=(
size_t n) noexcept
1134 const auto shift = (std::min)(
n, _size);
1135 _data =
static_cast<const char *
>(_data) + shift;
1145 inline const_buffer
operator+(
const const_buffer &cb,
size_t n) noexcept
1147 return const_buffer(
static_cast<const char *
>(cb.data())
1148 + (std::min)(
n, cb.size()),
1149 cb.size() - (std::min)(
n, cb.size()));
1151 inline const_buffer
operator+(
size_t n,
const const_buffer &cb) noexcept
1158 constexpr mutable_buffer
buffer(
void *
p,
size_t n) noexcept
1160 return mutable_buffer(
p,
n);
1162 constexpr const_buffer
buffer(
const void *
p,
size_t n) noexcept
1164 return const_buffer(
p,
n);
1166 constexpr mutable_buffer
buffer(
const mutable_buffer &mb) noexcept
1170 inline mutable_buffer
buffer(
const mutable_buffer &mb,
size_t n) noexcept
1172 return mutable_buffer(mb.data(), (std::min)(mb.size(),
n));
1174 constexpr const_buffer
buffer(
const const_buffer &cb) noexcept
1178 inline const_buffer
buffer(
const const_buffer &cb,
size_t n) noexcept
1180 return const_buffer(cb.data(), (std::min)(cb.size(),
n));
1185 template<
class T>
struct is_buffer
1187 static constexpr
bool value =
1191 template<
class T>
struct is_pod_like
1197 static constexpr
bool value =
1201 template<
class C> constexpr
auto seq_size(
const C &c) noexcept -> decltype(c.size())
1205 template<
class T,
size_t N>
1206 constexpr
size_t seq_size(
const T (&)[N]) noexcept
1212 auto buffer_contiguous_sequence(Seq &&seq) noexcept
1215 using T =
typename std::remove_cv<
1216 typename std::remove_reference<decltype(*
std::begin(seq))>::type>::type;
1219 const auto size = seq_size(seq);
1224 auto buffer_contiguous_sequence(Seq &&seq,
size_t n_bytes) noexcept
1225 -> decltype(buffer_contiguous_sequence(seq))
1227 using T =
typename std::remove_cv<
1228 typename std::remove_reference<decltype(*
std::begin(seq))>::type>::type;
1231 const auto size = seq_size(seq);
1233 (std::min)(
size *
sizeof(T), n_bytes));
1239 template<
class T,
size_t N> mutable_buffer
buffer(T (&data)[N]) noexcept
1241 return detail::buffer_contiguous_sequence(data);
1243 template<
class T,
size_t N>
1244 mutable_buffer
buffer(T (&data)[N],
size_t n_bytes) noexcept
1246 return detail::buffer_contiguous_sequence(data, n_bytes);
1248 template<
class T,
size_t N> const_buffer
buffer(
const T (&data)[N]) noexcept
1250 return detail::buffer_contiguous_sequence(data);
1252 template<
class T,
size_t N>
1253 const_buffer
buffer(
const T (&data)[N],
size_t n_bytes) noexcept
1255 return detail::buffer_contiguous_sequence(data, n_bytes);
1258 template<
class T,
size_t N> mutable_buffer
buffer(std::array<T, N> &data) noexcept
1260 return detail::buffer_contiguous_sequence(data);
1262 template<
class T,
size_t N>
1263 mutable_buffer
buffer(std::array<T, N> &data,
size_t n_bytes) noexcept
1265 return detail::buffer_contiguous_sequence(data, n_bytes);
1267 template<
class T,
size_t N>
1268 const_buffer
buffer(std::array<const T, N> &data) noexcept
1270 return detail::buffer_contiguous_sequence(data);
1272 template<
class T,
size_t N>
1273 const_buffer
buffer(std::array<const T, N> &data,
size_t n_bytes) noexcept
1275 return detail::buffer_contiguous_sequence(data, n_bytes);
1277 template<
class T,
size_t N>
1278 const_buffer
buffer(
const std::array<T, N> &data) noexcept
1280 return detail::buffer_contiguous_sequence(data);
1282 template<
class T,
size_t N>
1283 const_buffer
buffer(
const std::array<T, N> &data,
size_t n_bytes) noexcept
1285 return detail::buffer_contiguous_sequence(data, n_bytes);
1288 template<
class T,
class Allocator>
1289 mutable_buffer
buffer(std::vector<T, Allocator> &data) noexcept
1291 return detail::buffer_contiguous_sequence(data);
1293 template<
class T,
class Allocator>
1294 mutable_buffer
buffer(std::vector<T, Allocator> &data,
size_t n_bytes) noexcept
1296 return detail::buffer_contiguous_sequence(data, n_bytes);
1298 template<
class T,
class Allocator>
1299 const_buffer
buffer(
const std::vector<T, Allocator> &data) noexcept
1301 return detail::buffer_contiguous_sequence(data);
1303 template<
class T,
class Allocator>
1304 const_buffer
buffer(
const std::vector<T, Allocator> &data,
size_t n_bytes) noexcept
1306 return detail::buffer_contiguous_sequence(data, n_bytes);
1309 template<
class T,
class Traits,
class Allocator>
1310 mutable_buffer
buffer(std::basic_string<T, Traits, Allocator> &data) noexcept
1312 return detail::buffer_contiguous_sequence(data);
1314 template<
class T,
class Traits,
class Allocator>
1315 mutable_buffer
buffer(std::basic_string<T, Traits, Allocator> &data,
1316 size_t n_bytes) noexcept
1318 return detail::buffer_contiguous_sequence(data, n_bytes);
1320 template<
class T,
class Traits,
class Allocator>
1321 const_buffer
buffer(
const std::basic_string<T, Traits, Allocator> &data) noexcept
1323 return detail::buffer_contiguous_sequence(data);
1325 template<
class T,
class Traits,
class Allocator>
1326 const_buffer
buffer(
const std::basic_string<T, Traits, Allocator> &data,
1327 size_t n_bytes) noexcept
1329 return detail::buffer_contiguous_sequence(data, n_bytes);
1332 #if CPPZMQ_HAS_STRING_VIEW
1334 template<
class T,
class Traits>
1335 const_buffer
buffer(std::basic_string_view<T, Traits> data) noexcept
1337 return detail::buffer_contiguous_sequence(data);
1339 template<
class T,
class Traits>
1340 const_buffer
buffer(std::basic_string_view<T, Traits> data,
size_t n_bytes) noexcept
1342 return detail::buffer_contiguous_sequence(data, n_bytes);
1349 template<
class Char,
size_t N>
1350 constexpr const_buffer str_buffer(
const Char (&data)[N]) noexcept
1353 #ifdef ZMQ_EXTENDED_CONSTEXPR
1354 assert(data[N - 1] == Char{0});
1356 return const_buffer(
static_cast<const Char *
>(data), (N - 1) *
sizeof(Char));
1361 constexpr const_buffer
operator"" _zbuf(
const char *str,
size_t len) noexcept
1363 return const_buffer(str, len *
sizeof(
char));
1365 constexpr const_buffer
operator"" _zbuf(
const wchar_t *str,
size_t len) noexcept
1367 return const_buffer(str, len *
sizeof(
wchar_t));
1369 constexpr const_buffer
operator"" _zbuf(
const char16_t *str,
size_t len) noexcept
1371 return const_buffer(str, len *
sizeof(char16_t));
1373 constexpr const_buffer
operator"" _zbuf(
const char32_t *str,
size_t len) noexcept
1375 return const_buffer(str, len *
sizeof(char32_t));
1380 enum class socket_type : int
1384 dealer = ZMQ_DEALER,
1385 router = ZMQ_ROUTER,
1392 #if defined(ZMQ_BUILD_DRAFT_API) && ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 0)
1393 server = ZMQ_SERVER,
1394 client = ZMQ_CLIENT,
1397 gather = ZMQ_GATHER,
1398 scatter = ZMQ_SCATTER,
1401 #if defined(ZMQ_BUILD_DRAFT_API) && ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 3, 3)
1403 channel = ZMQ_CHANNEL,
1405 #if ZMQ_VERSION_MAJOR >= 4
1406 stream = ZMQ_STREAM,
1419 template<
int Opt,
class T,
bool BoolUnit = false>
struct integral_option
1427 template<
int Opt,
int NullTerm = 1>
struct array_option
1431 #define ZMQ_DEFINE_INTEGRAL_OPT(OPT, NAME, TYPE) \
1432 using NAME##_t = integral_option<OPT, TYPE, false>; \
1433 ZMQ_INLINE_VAR ZMQ_CONSTEXPR_VAR NAME##_t NAME {}
1434 #define ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(OPT, NAME, TYPE) \
1435 using NAME##_t = integral_option<OPT, TYPE, true>; \
1436 ZMQ_INLINE_VAR ZMQ_CONSTEXPR_VAR NAME##_t NAME {}
1437 #define ZMQ_DEFINE_ARRAY_OPT(OPT, NAME) \
1438 using NAME##_t = array_option<OPT>; \
1439 ZMQ_INLINE_VAR ZMQ_CONSTEXPR_VAR NAME##_t NAME {}
1440 #define ZMQ_DEFINE_ARRAY_OPT_BINARY(OPT, NAME) \
1441 using NAME##_t = array_option<OPT, 0>; \
1442 ZMQ_INLINE_VAR ZMQ_CONSTEXPR_VAR NAME##_t NAME {}
1443 #define ZMQ_DEFINE_ARRAY_OPT_BIN_OR_Z85(OPT, NAME) \
1444 using NAME##_t = array_option<OPT, 2>; \
1445 ZMQ_INLINE_VAR ZMQ_CONSTEXPR_VAR NAME##_t NAME {}
1451 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_AFFINITY, affinity, uint64_t);
1454 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_BACKLOG, backlog,
int);
1456 #ifdef ZMQ_BINDTODEVICE
1457 ZMQ_DEFINE_ARRAY_OPT_BINARY(ZMQ_BINDTODEVICE, bindtodevice);
1460 ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_CONFLATE, conflate,
int);
1462 #ifdef ZMQ_CONNECT_ROUTING_ID
1463 ZMQ_DEFINE_ARRAY_OPT(ZMQ_CONNECT_ROUTING_ID, connect_routing_id);
1465 #ifdef ZMQ_CONNECT_TIMEOUT
1466 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_CONNECT_TIMEOUT, connect_timeout,
int);
1468 #ifdef ZMQ_CURVE_PUBLICKEY
1469 ZMQ_DEFINE_ARRAY_OPT_BIN_OR_Z85(ZMQ_CURVE_PUBLICKEY, curve_publickey);
1471 #ifdef ZMQ_CURVE_SECRETKEY
1472 ZMQ_DEFINE_ARRAY_OPT_BIN_OR_Z85(ZMQ_CURVE_SECRETKEY, curve_secretkey);
1474 #ifdef ZMQ_CURVE_SERVER
1475 ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_CURVE_SERVER, curve_server,
int);
1477 #ifdef ZMQ_CURVE_SERVERKEY
1478 ZMQ_DEFINE_ARRAY_OPT_BIN_OR_Z85(ZMQ_CURVE_SERVERKEY, curve_serverkey);
1481 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_EVENTS, events,
int);
1484 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_FD, fd, ::
zmq::fd_t);
1486 #ifdef ZMQ_GSSAPI_PLAINTEXT
1487 ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_GSSAPI_PLAINTEXT, gssapi_plaintext,
int);
1489 #ifdef ZMQ_GSSAPI_SERVER
1490 ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_GSSAPI_SERVER, gssapi_server,
int);
1492 #ifdef ZMQ_GSSAPI_SERVICE_PRINCIPAL
1493 ZMQ_DEFINE_ARRAY_OPT(ZMQ_GSSAPI_SERVICE_PRINCIPAL, gssapi_service_principal);
1495 #ifdef ZMQ_GSSAPI_SERVICE_PRINCIPAL_NAMETYPE
1496 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_GSSAPI_SERVICE_PRINCIPAL_NAMETYPE,
1497 gssapi_service_principal_nametype,
1500 #ifdef ZMQ_GSSAPI_PRINCIPAL
1501 ZMQ_DEFINE_ARRAY_OPT(ZMQ_GSSAPI_PRINCIPAL, gssapi_principal);
1503 #ifdef ZMQ_GSSAPI_PRINCIPAL_NAMETYPE
1504 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_GSSAPI_PRINCIPAL_NAMETYPE,
1505 gssapi_principal_nametype,
1508 #ifdef ZMQ_HANDSHAKE_IVL
1509 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_HANDSHAKE_IVL, handshake_ivl,
int);
1511 #ifdef ZMQ_HEARTBEAT_IVL
1512 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_HEARTBEAT_IVL, heartbeat_ivl,
int);
1514 #ifdef ZMQ_HEARTBEAT_TIMEOUT
1515 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_HEARTBEAT_TIMEOUT, heartbeat_timeout,
int);
1517 #ifdef ZMQ_HEARTBEAT_TTL
1518 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_HEARTBEAT_TTL, heartbeat_ttl,
int);
1520 #ifdef ZMQ_IMMEDIATE
1521 ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_IMMEDIATE, immediate,
int);
1523 #ifdef ZMQ_INVERT_MATCHING
1524 ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_INVERT_MATCHING, invert_matching,
int);
1527 ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_IPV6, ipv6,
int);
1529 #ifdef ZMQ_LAST_ENDPOINT
1530 ZMQ_DEFINE_ARRAY_OPT(ZMQ_LAST_ENDPOINT, last_endpoint);
1533 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_LINGER, linger,
int);
1535 #ifdef ZMQ_MAXMSGSIZE
1536 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_MAXMSGSIZE, maxmsgsize, int64_t);
1538 #ifdef ZMQ_MECHANISM
1539 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_MECHANISM, mechanism,
int);
1542 ZMQ_DEFINE_ARRAY_OPT(ZMQ_METADATA, metadata);
1544 #ifdef ZMQ_MULTICAST_HOPS
1545 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_MULTICAST_HOPS, multicast_hops,
int);
1547 #ifdef ZMQ_MULTICAST_LOOP
1548 ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_MULTICAST_LOOP, multicast_loop,
int);
1550 #ifdef ZMQ_MULTICAST_MAXTPDU
1551 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_MULTICAST_MAXTPDU, multicast_maxtpdu,
int);
1553 #ifdef ZMQ_ONLY_FIRST_SUBSCRIBE
1554 ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_ONLY_FIRST_SUBSCRIBE, only_first_subscribe,
int);
1556 #ifdef ZMQ_PLAIN_SERVER
1557 ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_PLAIN_SERVER, plain_server,
int);
1559 #ifdef ZMQ_PLAIN_PASSWORD
1560 ZMQ_DEFINE_ARRAY_OPT(ZMQ_PLAIN_PASSWORD, plain_password);
1562 #ifdef ZMQ_PLAIN_USERNAME
1563 ZMQ_DEFINE_ARRAY_OPT(ZMQ_PLAIN_USERNAME, plain_username);
1566 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_USE_FD, use_fd,
int);
1568 #ifdef ZMQ_PROBE_ROUTER
1569 ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_PROBE_ROUTER, probe_router,
int);
1572 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_RATE, rate,
int);
1575 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_RCVBUF, rcvbuf,
int);
1578 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_RCVHWM, rcvhwm,
int);
1581 ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_RCVMORE, rcvmore,
int);
1584 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_RCVTIMEO, rcvtimeo,
int);
1586 #ifdef ZMQ_RECONNECT_IVL
1587 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_RECONNECT_IVL, reconnect_ivl,
int);
1589 #ifdef ZMQ_RECONNECT_IVL_MAX
1590 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_RECONNECT_IVL_MAX, reconnect_ivl_max,
int);
1592 #ifdef ZMQ_RECOVERY_IVL
1593 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_RECOVERY_IVL, recovery_ivl,
int);
1595 #ifdef ZMQ_REQ_CORRELATE
1596 ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_REQ_CORRELATE, req_correlate,
int);
1598 #ifdef ZMQ_REQ_RELAXED
1599 ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_REQ_RELAXED, req_relaxed,
int);
1601 #ifdef ZMQ_ROUTER_HANDOVER
1602 ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_ROUTER_HANDOVER, router_handover,
int);
1604 #ifdef ZMQ_ROUTER_MANDATORY
1605 ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_ROUTER_MANDATORY, router_mandatory,
int);
1607 #ifdef ZMQ_ROUTER_NOTIFY
1608 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_ROUTER_NOTIFY, router_notify,
int);
1610 #ifdef ZMQ_ROUTING_ID
1611 ZMQ_DEFINE_ARRAY_OPT_BINARY(ZMQ_ROUTING_ID, routing_id);
1614 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_SNDBUF, sndbuf,
int);
1617 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_SNDHWM, sndhwm,
int);
1620 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_SNDTIMEO, sndtimeo,
int);
1622 #ifdef ZMQ_SOCKS_PROXY
1623 ZMQ_DEFINE_ARRAY_OPT(ZMQ_SOCKS_PROXY, socks_proxy);
1625 #ifdef ZMQ_STREAM_NOTIFY
1626 ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_STREAM_NOTIFY, stream_notify,
int);
1628 #ifdef ZMQ_SUBSCRIBE
1629 ZMQ_DEFINE_ARRAY_OPT(ZMQ_SUBSCRIBE, subscribe);
1631 #ifdef ZMQ_TCP_KEEPALIVE
1632 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_TCP_KEEPALIVE, tcp_keepalive,
int);
1634 #ifdef ZMQ_TCP_KEEPALIVE_CNT
1635 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_TCP_KEEPALIVE_CNT, tcp_keepalive_cnt,
int);
1637 #ifdef ZMQ_TCP_KEEPALIVE_IDLE
1638 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_TCP_KEEPALIVE_IDLE, tcp_keepalive_idle,
int);
1640 #ifdef ZMQ_TCP_KEEPALIVE_INTVL
1641 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_TCP_KEEPALIVE_INTVL, tcp_keepalive_intvl,
int);
1643 #ifdef ZMQ_TCP_MAXRT
1644 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_TCP_MAXRT, tcp_maxrt,
int);
1646 #ifdef ZMQ_THREAD_SAFE
1647 ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_THREAD_SAFE, thread_safe,
int);
1650 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_TOS, tos,
int);
1653 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_TYPE, type,
int);
1655 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_TYPE, socket_type, socket_type);
1658 #ifdef ZMQ_UNSUBSCRIBE
1659 ZMQ_DEFINE_ARRAY_OPT(ZMQ_UNSUBSCRIBE, unsubscribe);
1661 #ifdef ZMQ_VMCI_BUFFER_SIZE
1662 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_VMCI_BUFFER_SIZE, vmci_buffer_size, uint64_t);
1664 #ifdef ZMQ_VMCI_BUFFER_MIN_SIZE
1665 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_VMCI_BUFFER_MIN_SIZE, vmci_buffer_min_size, uint64_t);
1667 #ifdef ZMQ_VMCI_BUFFER_MAX_SIZE
1668 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_VMCI_BUFFER_MAX_SIZE, vmci_buffer_max_size, uint64_t);
1670 #ifdef ZMQ_VMCI_CONNECT_TIMEOUT
1671 ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_VMCI_CONNECT_TIMEOUT, vmci_connect_timeout,
int);
1673 #ifdef ZMQ_XPUB_VERBOSE
1674 ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_XPUB_VERBOSE, xpub_verbose,
int);
1676 #ifdef ZMQ_XPUB_VERBOSER
1677 ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_XPUB_VERBOSER, xpub_verboser,
int);
1679 #ifdef ZMQ_XPUB_MANUAL
1680 ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_XPUB_MANUAL, xpub_manual,
int);
1682 #ifdef ZMQ_XPUB_NODROP
1683 ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_XPUB_NODROP, xpub_nodrop,
int);
1685 #ifdef ZMQ_XPUB_WELCOME_MSG
1686 ZMQ_DEFINE_ARRAY_OPT(ZMQ_XPUB_WELCOME_MSG, xpub_welcome_msg);
1688 #ifdef ZMQ_ZAP_ENFORCE_DOMAIN
1689 ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_ZAP_ENFORCE_DOMAIN, zap_enforce_domain,
int);
1691 #ifdef ZMQ_ZAP_DOMAIN
1692 ZMQ_DEFINE_ARRAY_OPT(ZMQ_ZAP_DOMAIN, zap_domain);
1707 template<
typename T>
1717 int rc = zmq_setsockopt(_handle, option_, optval_, optvallen_);
1725 int rc = zmq_getsockopt(_handle, option_, optval_, optvallen_);
1730 template<
typename T>
1735 size_t optlen =
sizeof(T);
1743 template<
int Opt,
class T,
bool BoolUnit>
1744 void set(sockopt::integral_option<Opt, T, BoolUnit>,
const T &val)
1752 template<
int Opt,
class T>
1753 void set(sockopt::integral_option<Opt, T, true>,
bool val)
1762 template<
int Opt,
int NullTerm>
1763 void set(sockopt::array_option<Opt, NullTerm>,
const char *buf)
1770 template<
int Opt,
int NullTerm>
1771 void set(sockopt::array_option<Opt, NullTerm>, const_buffer buf)
1778 template<
int Opt,
int NullTerm>
1779 void set(sockopt::array_option<Opt, NullTerm>,
const std::string &buf)
1784 #if CPPZMQ_HAS_STRING_VIEW
1787 template<
int Opt,
int NullTerm>
1796 template<
int Opt,
class T,
bool BoolUnit>
1801 size_t size =
sizeof val;
1803 assert(
size ==
sizeof val);
1809 template<
int Opt,
int NullTerm>
1811 mutable_buffer buf)
const
1813 size_t size = buf.size();
1822 template<
int Opt,
int NullTerm>
1824 size_t init_size = 1024)
const
1827 if (init_size == 1024) {
1831 std::string str(init_size,
'\0');
1832 size_t size =
get(sockopt::array_option<Opt>{},
buffer(str));
1835 assert(str[
size - 1] ==
'\0');
1841 assert(str[
size - 1] ==
'\0');
1850 void bind(std::string
const &addr) {
bind(addr.c_str()); }
1854 int rc = zmq_bind(_handle, addr_);
1863 int rc = zmq_unbind(_handle, addr_);
1872 int rc = zmq_connect(_handle, addr_);
1881 int rc = zmq_disconnect(_handle, addr_);
1886 ZMQ_DEPRECATED(
"from 4.7.1, use handle() != nullptr or operator bool")
1892 int nbytes = zmq_send(_handle, buf_, len_,
flags_);
1894 return static_cast<size_t>(nbytes);
1895 if (zmq_errno() == EAGAIN)
1904 int nbytes = zmq_msg_send(msg_.handle(), _handle,
flags_);
1907 if (zmq_errno() == EAGAIN)
1912 template<
typename T>
1914 "from 4.4.1, use send taking message_t or buffer (for contiguous "
1915 "ranges), and send_flags")
1919 int nbytes = zmq_msg_send(msg.
handle(), _handle,
flags_);
1922 if (zmq_errno() == EAGAIN)
1927 #ifdef ZMQ_HAS_RVALUE_REFS
1933 return send(msg_,
static_cast<send_flags
>(
flags_)).has_value();
1941 send_result_t
send(const_buffer buf, send_flags flags = send_flags::none)
1944 zmq_send(_handle, buf.data(), buf.size(),
static_cast<int>(flags));
1946 return static_cast<size_t>(nbytes);
1947 if (zmq_errno() == EAGAIN)
1952 send_result_t
send(message_t &msg, send_flags flags)
1954 int nbytes = zmq_msg_send(msg.handle(), _handle,
static_cast<int>(flags));
1956 return static_cast<size_t>(nbytes);
1957 if (zmq_errno() == EAGAIN)
1962 send_result_t
send(message_t &&msg, send_flags flags)
1964 return send(msg, flags);
1969 "from 4.3.1, use recv taking a mutable_buffer and recv_flags")
1970 size_t recv(
void *buf_,
size_t len_,
int flags_ = 0)
1972 int nbytes = zmq_recv(_handle, buf_, len_,
flags_);
1974 return static_cast<size_t>(nbytes);
1975 if (zmq_errno() == EAGAIN)
1981 "from 4.3.1, use recv taking a reference to message_t and recv_flags")
1982 bool recv(message_t *msg_,
int flags_ = 0)
1984 int nbytes = zmq_msg_recv(msg_->handle(), _handle,
flags_);
1987 if (zmq_errno() == EAGAIN)
1994 recv_buffer_result_t recv(mutable_buffer buf,
1995 recv_flags flags = recv_flags::none)
1998 zmq_recv(_handle, buf.data(), buf.size(),
static_cast<int>(flags));
2000 return recv_buffer_size{
2001 (std::min)(
static_cast<size_t>(nbytes), buf.size()),
2002 static_cast<size_t>(nbytes)};
2004 if (zmq_errno() == EAGAIN)
2010 recv_result_t recv(message_t &msg, recv_flags flags = recv_flags::none)
2013 zmq_msg_recv(msg.handle(), _handle,
static_cast<int>(flags));
2015 assert(msg.size() ==
static_cast<size_t>(nbytes));
2016 return static_cast<size_t>(nbytes);
2018 if (zmq_errno() == EAGAIN)
2024 #if defined(ZMQ_BUILD_DRAFT_API) && ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 0)
2025 void join(
const char *group)
2027 int rc = zmq_join(_handle, group);
2032 void leave(
const char *group)
2034 int rc = zmq_leave(_handle, group);
2052 void set_option(
int option_,
const void *optval_,
size_t optvallen_)
2054 int rc = zmq_setsockopt(_handle, option_, optval_, optvallen_);
2059 void get_option(
int option_,
void *optval_,
size_t *optvallen_)
const
2061 int rc = zmq_getsockopt(_handle, option_, optval_, optvallen_);
2097 return sr.handle() ==
nullptr;
2101 return sr.handle() ==
nullptr;
2105 return !(sr ==
nullptr);
2109 return !(sr ==
nullptr);
2115 return std::equal_to<const void *>()(a.handle(), b.handle());
2123 return std::less<const void *>()(a.handle(), b.handle());
2143 template<>
struct hash<
zmq::socket_ref>
2147 return hash<void *>()(sr.handle());
2164 ctxptr(context_.handle())
2172 socket_t(context_, static_cast<int>(type_))
2177 #ifdef ZMQ_HAS_RVALUE_REFS
2204 int rc = zmq_close(_handle);
2243 int rc = zmq_proxy(frontend, backend,
capture);
2251 int rc = zmq_proxy(frontend.handle(), backend.handle(),
capture.handle());
2256 #ifdef ZMQ_HAS_PROXY_STEERABLE
2257 ZMQ_DEPRECATED(
"from 4.3.1, use proxy_steerable taking socket_t objects")
2261 int rc = zmq_proxy_steerable(frontend, backend,
capture,
control);
2271 int rc = zmq_proxy_steerable(frontend.handle(), backend.handle(),
2285 #ifdef ZMQ_HAS_RVALUE_REFS
2306 monitor(socket, addr.c_str(), events);
2311 init(socket, addr_, events);
2317 void init(
socket_t &socket, std::string
const &addr,
int events = ZMQ_EVENT_ALL)
2319 init(socket, addr.c_str(), events);
2324 int rc = zmq_socket_monitor(socket.handle(), addr_, events);
2346 zmq::poll(&items[0], 1, std::chrono::milliseconds(timeout));
2351 if (items[0].revents & ZMQ_POLLIN) {
2353 if (rc == -1 && zmq_errno() == ETERM)
2361 #if ZMQ_VERSION_MAJOR >= 4
2362 const char *data =
static_cast<const char *
>(eventMsg.
data());
2364 memcpy(&msgEvent.
event, data,
sizeof(uint16_t));
2365 data +=
sizeof(uint16_t);
2366 memcpy(&msgEvent.
value, data,
sizeof(int32_t));
2372 #ifdef ZMQ_NEW_MONITOR_EVENT_LAYOUT
2375 if (rc == -1 && zmq_errno() == ETERM) {
2380 std::string address = addrMsg.
to_string();
2383 std::string address =
event->data.connected.addr;
2386 #ifdef ZMQ_EVENT_MONITOR_STOPPED
2387 if (event->event == ZMQ_EVENT_MONITOR_STOPPED) {
2393 switch (event->event) {
2394 case ZMQ_EVENT_CONNECTED:
2397 case ZMQ_EVENT_CONNECT_DELAYED:
2400 case ZMQ_EVENT_CONNECT_RETRIED:
2403 case ZMQ_EVENT_LISTENING:
2406 case ZMQ_EVENT_BIND_FAILED:
2409 case ZMQ_EVENT_ACCEPTED:
2412 case ZMQ_EVENT_ACCEPT_FAILED:
2415 case ZMQ_EVENT_CLOSED:
2418 case ZMQ_EVENT_CLOSE_FAILED:
2421 case ZMQ_EVENT_DISCONNECTED:
2424 #if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 3, 0) || (defined(ZMQ_BUILD_DRAFT_API) && ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 3))
2425 case ZMQ_EVENT_HANDSHAKE_FAILED_NO_DETAIL:
2428 case ZMQ_EVENT_HANDSHAKE_FAILED_PROTOCOL:
2431 case ZMQ_EVENT_HANDSHAKE_FAILED_AUTH:
2434 case ZMQ_EVENT_HANDSHAKE_SUCCEEDED:
2437 #elif defined(ZMQ_BUILD_DRAFT_API) && ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 1)
2438 case ZMQ_EVENT_HANDSHAKE_FAILED:
2439 on_event_handshake_failed(*event, address.c_str());
2441 case ZMQ_EVENT_HANDSHAKE_SUCCEED:
2442 on_event_handshake_succeed(*event, address.c_str());
2453 #ifdef ZMQ_EVENT_MONITOR_STOPPED
2515 #if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 3)
2540 #elif ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 1)
2541 virtual void on_event_handshake_failed(
const zmq_event_t &event_,
2547 virtual void on_event_handshake_succeed(
const zmq_event_t &event_,
2575 #if defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) && defined(ZMQ_HAVE_POLLER)
2578 enum class event_flags : short
2581 pollin = ZMQ_POLLIN,
2582 pollout = ZMQ_POLLOUT,
2583 pollerr = ZMQ_POLLERR,
2584 pollpri = ZMQ_POLLPRI
2587 constexpr event_flags
operator|(event_flags a, event_flags b) noexcept
2589 return detail::enum_bit_or(a, b);
2591 constexpr event_flags
operator&(event_flags a, event_flags b) noexcept
2593 return detail::enum_bit_and(a, b);
2595 constexpr event_flags
operator^(event_flags a, event_flags b) noexcept
2597 return detail::enum_bit_xor(a, b);
2599 constexpr event_flags
operator~(event_flags a) noexcept
2601 return detail::enum_bit_not(a);
2604 struct no_user_data;
2607 template<
class T = no_user_data>
struct poller_event
2615 template<
typename T = no_user_data>
class poller_t
2618 using event_type = poller_event<T>;
2620 poller_t() : poller_ptr(zmq_poller_new())
2627 typename Dummy =
void,
2632 add_impl(socket, events, user_data);
2637 add_impl(socket, events,
nullptr);
2642 if (0 != zmq_poller_remove(poller_ptr.get(), socket.handle())) {
2650 != zmq_poller_modify(poller_ptr.get(), socket.handle(),
2651 static_cast<short>(events))) {
2656 size_t wait_all(std::vector<event_type> &poller_events,
2657 const std::chrono::milliseconds timeout)
2659 int rc = zmq_poller_wait_all(
2661 reinterpret_cast<zmq_poller_event_t *
>(poller_events.data()),
2662 static_cast<int>(poller_events.size()),
2663 static_cast<long>(timeout.count()));
2665 return static_cast<size_t>(rc);
2667 #if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 3)
2668 if (zmq_errno() == EAGAIN)
2670 if (zmq_errno() == ETIMEDOUT)
2677 #if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 3, 3)
2678 size_t size() const noexcept
2680 int rc = zmq_poller_size(
const_cast<void *
>(poller_ptr.get()));
2682 return static_cast<size_t>(std::max(rc, 0));
2687 struct destroy_poller_t
2689 void operator()(
void *ptr) noexcept
2691 int rc = zmq_poller_destroy(&ptr);
2696 std::unique_ptr<void, destroy_poller_t> poller_ptr;
2698 void add_impl(
zmq::socket_ref socket, event_flags events, T *user_data)
2701 != zmq_poller_add(poller_ptr.get(), socket.handle(), user_data,
2702 static_cast<short>(events))) {
2707 #endif // defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) && defined(ZMQ_HAVE_POLLER)
2711 return os << msg.
str();
2716 #endif // __ZMQ_HPP_INCLUDED__