From 2b6958788276f99a2217d967de947f2e8dff78af Mon Sep 17 00:00:00 2001 From: mberk-yilmaz Date: Wed, 18 Mar 2026 12:48:20 +0300 Subject: [PATCH 1/5] addon: add const overloads for multipart_t front/back Add const-qualified overloads for multipart_t::front() and back() in `zmq_addon.hpp`. Note on API shape: - In a container-style API, non-const overloads would typically return `message_t&`. - This change intentionally preserves existing non-const return types (`const message_t&`) for backward-compatibility and to avoid broadening mutability semantics in this PR. Also extend `tests/multipart.cpp` with compile-time and runtime checks for const/non-const access paths. No behavioral change intended. --- tests/multipart.cpp | 29 +++++++++++++++++++++++++++-- zmq_addon.hpp | 6 ++++++ 2 files changed, 33 insertions(+), 2 deletions(-) diff --git a/tests/multipart.cpp b/tests/multipart.cpp index 6901517..4af4948 100644 --- a/tests/multipart.cpp +++ b/tests/multipart.cpp @@ -1,6 +1,8 @@ #include #include +#include + #ifdef ZMQ_HAS_RVALUE_REFS #ifdef ZMQ_CPP17 @@ -17,6 +19,22 @@ static_assert(std::is_invocable::value, "Can't construct with socket_ref"); +static_assert( + std::is_same().front()), + const zmq::message_t &>::value, + "multipart_t::front() should keep returning const message_t&"); +static_assert( + std::is_same().front()), + const zmq::message_t &>::value, + "multipart_t::front() const should return const message_t&"); +static_assert( + std::is_same().back()), + const zmq::message_t &>::value, + "multipart_t::back() should keep returning const message_t&"); +static_assert( + std::is_same().back()), + const zmq::message_t &>::value, + "multipart_t::back() const should return const message_t&"); /// \todo split this up into separate test cases /// @@ -106,11 +124,18 @@ TEST_CASE("multipart legacy test", "[multipart]") multipart.pushmem("Frame0", 6); assert(multipart.size() == 10); - const message_t &front_msg = multipart.front(); + const message_t &front_msg_nonconst = multipart.front(); + assert(&front_msg_nonconst == &multipart[0]); + + const multipart_t &const_multipart = multipart; + const message_t &front_msg = const_multipart.front(); assert(multipart.size() == 10); assert(std::string(front_msg.data(), front_msg.size()) == "Frame0"); - const message_t &back_msg = multipart.back(); + const message_t &back_msg_nonconst = multipart.back(); + assert(&back_msg_nonconst == &multipart[multipart.size() - 1]); + + const message_t &back_msg = const_multipart.back(); assert(multipart.size() == 10); assert(std::string(back_msg.data(), back_msg.size()) == "Frame9"); diff --git a/zmq_addon.hpp b/zmq_addon.hpp index 168735d..04c9966 100644 --- a/zmq_addon.hpp +++ b/zmq_addon.hpp @@ -594,9 +594,15 @@ class multipart_t // get message part from front const message_t &front() { return m_parts.front(); } + // get message part from front + const message_t &front() const { return m_parts.front(); } + // get message part from back const message_t &back() { return m_parts.back(); } + // get message part from back + const message_t &back() const { return m_parts.back(); } + // Get pointer to a specific message part const message_t *peek(size_t index) const { return &m_parts[index]; } From 1d691c21a73f516580a6c59039f78b2451aada9b Mon Sep 17 00:00:00 2001 From: mberk-yilmaz Date: Wed, 18 Mar 2026 14:31:29 +0300 Subject: [PATCH 2/5] fix: applied clang-format to fix style. No functional changes. --- tests/multipart.cpp | 21 +++++++++------------ 1 file changed, 9 insertions(+), 12 deletions(-) diff --git a/tests/multipart.cpp b/tests/multipart.cpp index 4af4948..1004410 100644 --- a/tests/multipart.cpp +++ b/tests/multipart.cpp @@ -19,22 +19,19 @@ static_assert(std::is_invocable::value, "Can't construct with socket_ref"); -static_assert( - std::is_same().front()), - const zmq::message_t &>::value, - "multipart_t::front() should keep returning const message_t&"); +static_assert(std::is_same().front()), + const zmq::message_t &>::value, + "multipart_t::front() should keep returning const message_t&"); static_assert( std::is_same().front()), const zmq::message_t &>::value, "multipart_t::front() const should return const message_t&"); -static_assert( - std::is_same().back()), - const zmq::message_t &>::value, - "multipart_t::back() should keep returning const message_t&"); -static_assert( - std::is_same().back()), - const zmq::message_t &>::value, - "multipart_t::back() const should return const message_t&"); +static_assert(std::is_same().back()), + const zmq::message_t &>::value, + "multipart_t::back() should keep returning const message_t&"); +static_assert(std::is_same().back()), + const zmq::message_t &>::value, + "multipart_t::back() const should return const message_t&"); /// \todo split this up into separate test cases /// From 57cfa2308be8732228c7571b11cd5432df551abc Mon Sep 17 00:00:00 2001 From: mberk-yilmaz Date: Thu, 26 Mar 2026 18:54:17 +0300 Subject: [PATCH 3/5] feat: add constexpr constructors for socket_base and socket_ref additionally added test for constexpr. --- tests/socket.cpp | 8 ++++++++ tests/socket_ref.cpp | 8 ++++++++ zmq.hpp | 34 +++++++++++++++++++++++++--------- 3 files changed, 41 insertions(+), 9 deletions(-) diff --git a/tests/socket.cpp b/tests/socket.cpp index cc1f9ca..04cff6c 100644 --- a/tests/socket.cpp +++ b/tests/socket.cpp @@ -14,6 +14,14 @@ TEST_CASE("socket default ctor", "[socket]") zmq::socket_t socket; } +#if defined(ZMQ_CPP11) && defined(ZMQ_CONSTEXPR_FN) +TEST_CASE("socket_base constexpr init", "[socket]") +{ + constexpr zmq::detail::socket_base sb; + (void) sb; +} +#endif + TEST_CASE("socket create destroy", "[socket]") { zmq::context_t context; diff --git a/tests/socket_ref.cpp b/tests/socket_ref.cpp index 83db550..914a748 100644 --- a/tests/socket_ref.cpp +++ b/tests/socket_ref.cpp @@ -19,6 +19,14 @@ TEST_CASE("socket_ref default init", "[socket_ref]") CHECK(sr.handle() == nullptr); } +#if defined(ZMQ_CPP11) && defined(ZMQ_CONSTEXPR_FN) +TEST_CASE("socket_ref constexpr init", "[socket_ref]") +{ + constexpr zmq::socket_ref sr; + (void) sr; +} +#endif + TEST_CASE("socket_ref create from nullptr", "[socket_ref]") { zmq::socket_ref sr = nullptr; diff --git a/zmq.hpp b/zmq.hpp index 3a755fc..a5fa9ad 100644 --- a/zmq.hpp +++ b/zmq.hpp @@ -308,7 +308,7 @@ class error_t : public std::exception { return zmq_strerror(errnum); } - int num() const ZMQ_NOTHROW { return errnum; } + ZMQ_CONSTEXPR_FN int num() const ZMQ_NOTHROW { return errnum; } private: int errnum; @@ -751,8 +751,12 @@ class message_t std::swap(msg, other.msg); } +#ifdef ZMQ_EXTENDED_CONSTEXPR + ZMQ_NODISCARD ZMQ_EXTENDED_CONSTEXPR zmq_msg_t *handle() ZMQ_NOTHROW { return &msg; } +#else ZMQ_NODISCARD zmq_msg_t *handle() ZMQ_NOTHROW { return &msg; } - ZMQ_NODISCARD const zmq_msg_t *handle() const ZMQ_NOTHROW { return &msg; } +#endif + ZMQ_NODISCARD ZMQ_CONSTEXPR_FN const zmq_msg_t *handle() const ZMQ_NOTHROW { return &msg; } private: // The underlying message @@ -910,11 +914,19 @@ class context_t // Be careful with this, it's probably only useful for // using the C api together with an existing C++ api. // Normally you should never need to use this. +#ifdef ZMQ_EXTENDED_CONSTEXPR + ZMQ_EXPLICIT ZMQ_EXTENDED_CONSTEXPR operator void *() ZMQ_NOTHROW { return ptr; } +#else ZMQ_EXPLICIT operator void *() ZMQ_NOTHROW { return ptr; } +#endif - ZMQ_EXPLICIT operator void const *() const ZMQ_NOTHROW { return ptr; } + ZMQ_EXPLICIT ZMQ_CONSTEXPR_FN operator void const *() const ZMQ_NOTHROW { return ptr; } +#ifdef ZMQ_EXTENDED_CONSTEXPR + ZMQ_NODISCARD ZMQ_EXTENDED_CONSTEXPR void *handle() ZMQ_NOTHROW { return ptr; } +#else ZMQ_NODISCARD void *handle() ZMQ_NOTHROW { return ptr; } +#endif ZMQ_DEPRECATED("from 4.7.0, use handle() != nullptr instead") operator bool() const ZMQ_NOTHROW { return ptr != ZMQ_NULLPTR; } @@ -1765,8 +1777,8 @@ namespace detail class socket_base { public: - socket_base() ZMQ_NOTHROW : _handle(ZMQ_NULLPTR) {} - ZMQ_EXPLICIT socket_base(void *handle) ZMQ_NOTHROW : _handle(handle) {} + ZMQ_CONSTEXPR_FN socket_base() ZMQ_NOTHROW : _handle(ZMQ_NULLPTR) {} + ZMQ_EXPLICIT ZMQ_CONSTEXPR_FN socket_base(void *handle) ZMQ_NOTHROW : _handle(handle) {} template ZMQ_CPP11_DEPRECATED("from 4.7.0, use `set` taking option from zmq::sockopt") @@ -2164,11 +2176,11 @@ ZMQ_CONSTEXPR_VAR from_handle_t from_handle = class socket_ref : public detail::socket_base { public: - socket_ref() ZMQ_NOTHROW : detail::socket_base() {} + ZMQ_CONSTEXPR_FN socket_ref() ZMQ_NOTHROW : detail::socket_base() {} #ifdef ZMQ_CPP11 - socket_ref(std::nullptr_t) ZMQ_NOTHROW : detail::socket_base() {} + ZMQ_CONSTEXPR_FN socket_ref(std::nullptr_t) ZMQ_NOTHROW : detail::socket_base() {} #endif - socket_ref(from_handle_t /*fh*/, void *handle) ZMQ_NOTHROW + ZMQ_CONSTEXPR_FN socket_ref(from_handle_t /*fh*/, void *handle) ZMQ_NOTHROW : detail::socket_base(handle) { } @@ -2281,9 +2293,13 @@ class socket_t : public detail::socket_base ~socket_t() ZMQ_NOTHROW { close(); } +#ifdef ZMQ_EXTENDED_CONSTEXPR + ZMQ_EXTENDED_CONSTEXPR operator void *() ZMQ_NOTHROW { return _handle; } +#else operator void *() ZMQ_NOTHROW { return _handle; } +#endif - operator void const *() const ZMQ_NOTHROW { return _handle; } + ZMQ_CONSTEXPR_FN operator void const *() const ZMQ_NOTHROW { return _handle; } void close() ZMQ_NOTHROW { From 1be49115a2dec0d3993ab4ef9871889de0031c7a Mon Sep 17 00:00:00 2001 From: mberk-yilmaz Date: Thu, 26 Mar 2026 20:36:32 +0300 Subject: [PATCH 4/5] feat: constexpr extend safe compile-time observers across C++11/14/17 - map ZMQ_EXTENDED_CONSTEXPR to constexpr under existing compiler guards - add constexpr to safe state observers in context_t/socket_base/socket_ref paths - add constexpr to recv_buffer_size::truncated and fallback trivial_optional observers/ctor - strengthen compile-time tests with static_assert checks in context/socket/socket_ref tests - keep risky/non-portable areas (buffer pointer arithmetic, pointer ordering semantics) unchanged --- tests/context.cpp | 20 +++++++++++++++ tests/socket.cpp | 3 ++- tests/socket_ref.cpp | 3 ++- zmq.hpp | 59 ++++++++++++++++++++++++++++++-------------- 4 files changed, 64 insertions(+), 21 deletions(-) diff --git a/tests/context.cpp b/tests/context.cpp index 4f8dae8..f56b356 100644 --- a/tests/context.cpp +++ b/tests/context.cpp @@ -6,6 +6,26 @@ static_assert(std::is_nothrow_swappable::value, "context_t should be nothrow swappable"); #endif +#ifdef ZMQ_CPP11 +constexpr zmq::recv_buffer_size truncated_size{0u, 1u}; +constexpr zmq::recv_buffer_size full_size{1u, 1u}; +static_assert(truncated_size.truncated(), + "recv_buffer_size::truncated should be constexpr for truncated buffers"); +static_assert(!full_size.truncated(), + "recv_buffer_size::truncated should be constexpr for full buffers"); + +#if !CPPZMQ_HAS_OPTIONAL +constexpr zmq::detail::trivial_optional empty_optional; +constexpr zmq::detail::trivial_optional value_optional(42u); +static_assert(!empty_optional.has_value(), + "trivial_optional::has_value should be constexpr for empty state"); +static_assert(value_optional.has_value(), + "trivial_optional::has_value should be constexpr for value state"); +static_assert(static_cast(value_optional), + "trivial_optional::operator bool should be constexpr"); +#endif +#endif + TEST_CASE("context construct default and destroy", "[context]") { zmq::context_t context; diff --git a/tests/socket.cpp b/tests/socket.cpp index 04cff6c..4a03f60 100644 --- a/tests/socket.cpp +++ b/tests/socket.cpp @@ -18,7 +18,8 @@ TEST_CASE("socket default ctor", "[socket]") TEST_CASE("socket_base constexpr init", "[socket]") { constexpr zmq::detail::socket_base sb; - (void) sb; + static_assert(sb.handle() == nullptr, "socket_base handle should be constexpr"); + static_assert(!sb, "socket_base bool conversion should be constexpr"); } #endif diff --git a/tests/socket_ref.cpp b/tests/socket_ref.cpp index 914a748..bc8f5d5 100644 --- a/tests/socket_ref.cpp +++ b/tests/socket_ref.cpp @@ -23,7 +23,8 @@ TEST_CASE("socket_ref default init", "[socket_ref]") TEST_CASE("socket_ref constexpr init", "[socket_ref]") { constexpr zmq::socket_ref sr; - (void) sr; + static_assert(sr.handle() == nullptr, "socket_ref handle should be constexpr"); + static_assert(sr == nullptr, "socket_ref nullptr comparison should be constexpr"); } #endif diff --git a/zmq.hpp b/zmq.hpp index a5fa9ad..6f2de24 100644 --- a/zmq.hpp +++ b/zmq.hpp @@ -105,7 +105,7 @@ #endif #if defined(ZMQ_CPP14) && (!defined(_MSC_VER) || _MSC_VER > 1900) \ && (!defined(__GNUC__) || __GNUC__ > 5 || (__GNUC__ == 5 && __GNUC_MINOR__ > 3)) -#define ZMQ_EXTENDED_CONSTEXPR +#define ZMQ_EXTENDED_CONSTEXPR constexpr #endif #if defined(ZMQ_CPP17) #define ZMQ_INLINE_VAR inline @@ -929,7 +929,7 @@ class context_t #endif ZMQ_DEPRECATED("from 4.7.0, use handle() != nullptr instead") - operator bool() const ZMQ_NOTHROW { return ptr != ZMQ_NULLPTR; } + ZMQ_CONSTEXPR_FN operator bool() const ZMQ_NOTHROW { return ptr != ZMQ_NULLPTR; } void swap(context_t &other) ZMQ_NOTHROW { std::swap(ptr, other.ptr); } @@ -952,7 +952,7 @@ 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 + ZMQ_NODISCARD ZMQ_CONSTEXPR_FN bool truncated() const noexcept { return size != untruncated_size; } @@ -977,7 +977,7 @@ template class trivial_optional using value_type = T; trivial_optional() = default; - trivial_optional(T value) noexcept : _value(value), _has_value(true) {} + ZMQ_CONSTEXPR_FN trivial_optional(T value) noexcept : _value(value), _has_value(true) {} const T *operator->() const noexcept { @@ -1014,8 +1014,8 @@ template class trivial_optional return _value; } - explicit operator bool() const noexcept { return _has_value; } - bool has_value() const noexcept { return _has_value; } + ZMQ_CONSTEXPR_FN explicit operator bool() const noexcept { return _has_value; } + ZMQ_CONSTEXPR_FN bool has_value() const noexcept { return _has_value; } private: T _value{}; @@ -1960,7 +1960,10 @@ class socket_base } ZMQ_DEPRECATED("from 4.7.1, use handle() != nullptr or operator bool") - bool connected() const ZMQ_NOTHROW { return (_handle != ZMQ_NULLPTR); } + ZMQ_CONSTEXPR_FN bool connected() const ZMQ_NOTHROW + { + return (_handle != ZMQ_NULLPTR); + } ZMQ_CPP11_DEPRECATED("from 4.3.1, use send taking a const_buffer and send_flags") size_t send(const void *buf_, size_t len_, int flags_ = 0) @@ -2132,13 +2135,27 @@ class socket_base } #endif +#ifdef ZMQ_EXTENDED_CONSTEXPR + ZMQ_NODISCARD ZMQ_EXTENDED_CONSTEXPR void *handle() ZMQ_NOTHROW { return _handle; } +#else ZMQ_NODISCARD void *handle() ZMQ_NOTHROW { return _handle; } - ZMQ_NODISCARD const void *handle() const ZMQ_NOTHROW { return _handle; } +#endif + ZMQ_NODISCARD ZMQ_CONSTEXPR_FN const void *handle() const ZMQ_NOTHROW { return _handle; } - ZMQ_EXPLICIT operator bool() const ZMQ_NOTHROW { return _handle != ZMQ_NULLPTR; } + ZMQ_EXPLICIT ZMQ_CONSTEXPR_FN operator bool() const ZMQ_NOTHROW + { + return _handle != ZMQ_NULLPTR; + } // note: non-const operator bool can be removed once // operator void* is removed from socket_t - ZMQ_EXPLICIT operator bool() ZMQ_NOTHROW { return _handle != ZMQ_NULLPTR; } +#ifdef ZMQ_EXTENDED_CONSTEXPR + ZMQ_EXPLICIT ZMQ_EXTENDED_CONSTEXPR operator bool() ZMQ_NOTHROW +#else + ZMQ_EXPLICIT operator bool() ZMQ_NOTHROW +#endif + { + return _handle != ZMQ_NULLPTR; + } protected: void *_handle; @@ -2187,31 +2204,35 @@ class socket_ref : public detail::socket_base }; #ifdef ZMQ_CPP11 -inline bool operator==(socket_ref sr, std::nullptr_t /*p*/) ZMQ_NOTHROW +inline ZMQ_CONSTEXPR_FN bool operator==(const socket_ref sr, + std::nullptr_t /*p*/) ZMQ_NOTHROW { return sr.handle() == nullptr; } -inline bool operator==(std::nullptr_t /*p*/, socket_ref sr) ZMQ_NOTHROW +inline ZMQ_CONSTEXPR_FN bool operator==(std::nullptr_t /*p*/, + const socket_ref sr) ZMQ_NOTHROW { return sr.handle() == nullptr; } -inline bool operator!=(socket_ref sr, std::nullptr_t /*p*/) ZMQ_NOTHROW +inline ZMQ_CONSTEXPR_FN bool operator!=(const socket_ref sr, + std::nullptr_t /*p*/) ZMQ_NOTHROW { return !(sr == nullptr); } -inline bool operator!=(std::nullptr_t /*p*/, socket_ref sr) ZMQ_NOTHROW +inline ZMQ_CONSTEXPR_FN bool operator!=(std::nullptr_t /*p*/, + const socket_ref sr) ZMQ_NOTHROW { return !(sr == nullptr); } #endif -inline bool operator==(const detail::socket_base &a, - const detail::socket_base &b) ZMQ_NOTHROW +inline ZMQ_CONSTEXPR_FN bool operator==(const detail::socket_base &a, + const detail::socket_base &b) ZMQ_NOTHROW { - return std::equal_to()(a.handle(), b.handle()); + return a.handle() == b.handle(); } -inline bool operator!=(const detail::socket_base &a, - const detail::socket_base &b) ZMQ_NOTHROW +inline ZMQ_CONSTEXPR_FN bool operator!=(const detail::socket_base &a, + const detail::socket_base &b) ZMQ_NOTHROW { return !(a == b); } From f406259008be699aa5908cd4b34f70cf5b7a8c1e Mon Sep 17 00:00:00 2001 From: mberk-yilmaz Date: Thu, 26 Mar 2026 20:43:50 +0300 Subject: [PATCH 5/5] fix: applied clang-format to fix style, no functional changes. --- tests/context.cpp | 5 +++-- tests/socket_ref.cpp | 3 ++- zmq.hpp | 39 +++++++++++++++++++++++++++++++-------- 3 files changed, 36 insertions(+), 11 deletions(-) diff --git a/tests/context.cpp b/tests/context.cpp index f56b356..c33e231 100644 --- a/tests/context.cpp +++ b/tests/context.cpp @@ -9,8 +9,9 @@ static_assert(std::is_nothrow_swappable::value, #ifdef ZMQ_CPP11 constexpr zmq::recv_buffer_size truncated_size{0u, 1u}; constexpr zmq::recv_buffer_size full_size{1u, 1u}; -static_assert(truncated_size.truncated(), - "recv_buffer_size::truncated should be constexpr for truncated buffers"); +static_assert( + truncated_size.truncated(), + "recv_buffer_size::truncated should be constexpr for truncated buffers"); static_assert(!full_size.truncated(), "recv_buffer_size::truncated should be constexpr for full buffers"); diff --git a/tests/socket_ref.cpp b/tests/socket_ref.cpp index bc8f5d5..8f77f6c 100644 --- a/tests/socket_ref.cpp +++ b/tests/socket_ref.cpp @@ -24,7 +24,8 @@ TEST_CASE("socket_ref constexpr init", "[socket_ref]") { constexpr zmq::socket_ref sr; static_assert(sr.handle() == nullptr, "socket_ref handle should be constexpr"); - static_assert(sr == nullptr, "socket_ref nullptr comparison should be constexpr"); + static_assert(sr == nullptr, + "socket_ref nullptr comparison should be constexpr"); } #endif diff --git a/zmq.hpp b/zmq.hpp index 6f2de24..c45dfff 100644 --- a/zmq.hpp +++ b/zmq.hpp @@ -752,11 +752,17 @@ class message_t } #ifdef ZMQ_EXTENDED_CONSTEXPR - ZMQ_NODISCARD ZMQ_EXTENDED_CONSTEXPR zmq_msg_t *handle() ZMQ_NOTHROW { return &msg; } + ZMQ_NODISCARD ZMQ_EXTENDED_CONSTEXPR zmq_msg_t *handle() ZMQ_NOTHROW + { + return &msg; + } #else ZMQ_NODISCARD zmq_msg_t *handle() ZMQ_NOTHROW { return &msg; } #endif - ZMQ_NODISCARD ZMQ_CONSTEXPR_FN const zmq_msg_t *handle() const ZMQ_NOTHROW { return &msg; } + ZMQ_NODISCARD ZMQ_CONSTEXPR_FN const zmq_msg_t *handle() const ZMQ_NOTHROW + { + return &msg; + } private: // The underlying message @@ -920,7 +926,10 @@ class context_t ZMQ_EXPLICIT operator void *() ZMQ_NOTHROW { return ptr; } #endif - ZMQ_EXPLICIT ZMQ_CONSTEXPR_FN operator void const *() const ZMQ_NOTHROW { return ptr; } + ZMQ_EXPLICIT ZMQ_CONSTEXPR_FN operator void const *() const ZMQ_NOTHROW + { + return ptr; + } #ifdef ZMQ_EXTENDED_CONSTEXPR ZMQ_NODISCARD ZMQ_EXTENDED_CONSTEXPR void *handle() ZMQ_NOTHROW { return ptr; } @@ -977,7 +986,10 @@ template class trivial_optional using value_type = T; trivial_optional() = default; - ZMQ_CONSTEXPR_FN trivial_optional(T value) noexcept : _value(value), _has_value(true) {} + ZMQ_CONSTEXPR_FN trivial_optional(T value) noexcept : + _value(value), _has_value(true) + { + } const T *operator->() const noexcept { @@ -1778,7 +1790,10 @@ class socket_base { public: ZMQ_CONSTEXPR_FN socket_base() ZMQ_NOTHROW : _handle(ZMQ_NULLPTR) {} - ZMQ_EXPLICIT ZMQ_CONSTEXPR_FN socket_base(void *handle) ZMQ_NOTHROW : _handle(handle) {} + ZMQ_EXPLICIT ZMQ_CONSTEXPR_FN socket_base(void *handle) ZMQ_NOTHROW + : _handle(handle) + { + } template ZMQ_CPP11_DEPRECATED("from 4.7.0, use `set` taking option from zmq::sockopt") @@ -2136,11 +2151,17 @@ class socket_base #endif #ifdef ZMQ_EXTENDED_CONSTEXPR - ZMQ_NODISCARD ZMQ_EXTENDED_CONSTEXPR void *handle() ZMQ_NOTHROW { return _handle; } + ZMQ_NODISCARD ZMQ_EXTENDED_CONSTEXPR void *handle() ZMQ_NOTHROW + { + return _handle; + } #else ZMQ_NODISCARD void *handle() ZMQ_NOTHROW { return _handle; } #endif - ZMQ_NODISCARD ZMQ_CONSTEXPR_FN const void *handle() const ZMQ_NOTHROW { return _handle; } + ZMQ_NODISCARD ZMQ_CONSTEXPR_FN const void *handle() const ZMQ_NOTHROW + { + return _handle; + } ZMQ_EXPLICIT ZMQ_CONSTEXPR_FN operator bool() const ZMQ_NOTHROW { @@ -2195,7 +2216,9 @@ class socket_ref : public detail::socket_base public: ZMQ_CONSTEXPR_FN socket_ref() ZMQ_NOTHROW : detail::socket_base() {} #ifdef ZMQ_CPP11 - ZMQ_CONSTEXPR_FN socket_ref(std::nullptr_t) ZMQ_NOTHROW : detail::socket_base() {} + ZMQ_CONSTEXPR_FN socket_ref(std::nullptr_t) ZMQ_NOTHROW : detail::socket_base() + { + } #endif ZMQ_CONSTEXPR_FN socket_ref(from_handle_t /*fh*/, void *handle) ZMQ_NOTHROW : detail::socket_base(handle)