diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..7e3a08b
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,3 @@
+cmake-build-debug/
+.idea
+/cmake-build-debug/
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..04e4460
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,87 @@
+cmake_minimum_required(VERSION 3.5.1)
+project(v2x_gw)
+
+# Default to C99
+if(NOT CMAKE_C_STANDARD)
+ set(CMAKE_C_STANDARD 99)
+endif()
+
+# Default to C++14
+if(NOT CMAKE_CXX_STANDARD)
+ set(CMAKE_CXX_STANDARD 14)
+endif()
+
+# compile options
+# - activation will lead to a shitload of warnings of unused variables in autogenerated vcits lib
+#if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+# add_compile_options(-Wall -Wextra -Wpedantic)
+#endif()
+
+# ZeroMQ configuration
+# - activate relative paths for libraries (use that for deployment; WARNING: don't use with --symlink-install -> lib won't be found by file)
+# - set lib location for building and linking
+# - copy the lib files
+#set(CMAKE_INSTALL_RPATH "$ORIGIN")
+#set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
+set(ZEROMQ_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ext/libzmq/include")
+set(ZEROMQ_LIBRARIES "${CMAKE_CURRENT_SOURCE_DIR}/ext/libzmq/libzmq.so")
+install(FILES
+ "${CMAKE_CURRENT_SOURCE_DIR}/ext/libzmq/libzmq.so"
+ "${CMAKE_CURRENT_SOURCE_DIR}/ext/libzmq/libzmq.so.5"
+ "${CMAKE_CURRENT_SOURCE_DIR}/ext/libzmq/libzmq.so.5.2.4"
+ DESTINATION lib/${PROJECT_NAME}/
+ )
+
+# find dependencies
+find_package(ament_cmake REQUIRED)
+find_package(ament_cmake_auto REQUIRED)
+find_package(ament_index_cpp REQUIRED)
+find_package(rclcpp REQUIRED)
+find_package(eigen3_cmake_module)
+find_package(geometry_msgs REQUIRED)
+find_package(nav_msgs REQUIRED)
+find_package(visualization_msgs REQUIRED)
+find_package(diagnostic_msgs REQUIRED)
+find_package(tf2 REQUIRED)
+find_package(tf2_ros REQUIRED)
+find_package(std_msgs REQUIRED)
+find_package(dbw_ford_msgs REQUIRED)
+find_package(v2x_msgs REQUIRED)
+
+#pkg_check_modules(vcits REQUIRED)
+add_subdirectory(vcits)
+
+# add executable and sources
+ament_auto_add_executable(v2x_gw src/V2XGateway.cpp
+ src/server/V2XServer.cpp
+ src/server/V2XZMQServer.cpp
+ src/handler/V2XMHandler.cpp
+ src/handler/CAMHandler.cpp
+ src/handler/CPMHandler.cpp
+ src/handler/DENMHandler.cpp
+ src/handler/ExampleMHandler.cpp
+ )
+
+# reference headers
+target_include_directories(v2x_gw PUBLIC ${CMAKE_INSTALL_PREFIX}/include/
+ include
+ include/server
+ include/handler
+ ${ZEROMQ_INCLUDE_DIR}
+ vcits/asn1c
+ .
+ )
+
+# link libraries
+ament_target_dependencies(v2x_gw rclcpp std_msgs geometry_msgs nav_msgs visualization_msgs diagnostic_msgs dbw_ford_msgs v2x_msgs tf2 tf2_ros)
+
+target_link_libraries(v2x_gw
+ ${ZEROMQ_LIBRARIES}
+ vcits)
+
+# install ros package dependencies
+ament_auto_package(
+ INSTALL_TO_SHARE
+ launch
+ config
+)
diff --git a/FindZeroMQ.cmake b/FindZeroMQ.cmake
new file mode 100644
index 0000000..32acc27
--- /dev/null
+++ b/FindZeroMQ.cmake
@@ -0,0 +1,36 @@
+# ZeroMQ.cmake from http://lists.gforge.inria.fr/pipermail/simgrid-devel/2012-July/001513.html
+
+SET (ZEROMQ_FIND_QUIETLY TRUE)
+SET (ZEROMQ_FIND_REQUIRED FALSE)
+
+IF (NOT ZEROMQ_FOUND)
+ # Search user environment for headers, then default paths
+ FIND_PATH (ZEROMQ_INCLUDE_DIR zmq.hpp
+ PATHS ${ZEROMQROOT}/include $ENV{ZEROMQROOT}/include /usr/local/include
+ NO_DEFAULT_PATH)
+ FIND_PATH (ZEROMQ_INCLUDE_DIR zmq.hpp)
+ GET_FILENAME_COMPONENT (ZEROMQROOT ${ZEROMQ_INCLUDE_DIR} PATH)
+
+ # Search user environment for libraries, then default paths
+ FIND_LIBRARY (ZEROMQ_LIBRARIES zmq
+ PATHS ${ZEROMQROOT}/lib $ENV{ZEROMQROOT}/lib /usr/local/lib
+ NO_DEFAULT_PATH)
+ FIND_LIBRARY (ZEROMQ_LIBRARIES zmq)
+
+ # Set ZEROMQ_FOUND and error out if zmq is not found
+ INCLUDE (FindPackageHandleStandardArgs)
+ FIND_PACKAGE_HANDLE_STANDARD_ARGS (ZEROMQ
+ DEFAULT_MSG ZEROMQ_LIBRARIES ZEROMQ_INCLUDE_DIR)
+
+ IF (ZEROMQ_FOUND)
+ MESSAGE (STATUS "ZeroMQ found: zmq library and zmq.hpp ")
+ MESSAGE (STATUS " * includes: ${ZEROMQ_INCLUDE_DIR}")
+ MESSAGE (STATUS " * libs: ${ZEROMQ_LIBRARIES}")
+ ELSE (ZEROMQ_FOUND)
+ IF(${ZEROMQ_LIBRARIES} STREQUAL "ZEROMQ_LIBRARIES-NOTFOUND")
+ MESSAGE (STATUS "ZeroMQ library does not exist")
+ ELSEIF(${ZEROMQ_INCLUDE_DIR} STREQUAL "ZEROMQ_INCLUDE_DIR-NOTFOUND")
+ MESSAGE (STATUS "ZeroMQ has a problem: zmq.hpp does not exist, try to download it from https://github.com/zeromq/cppzmq/blob/master/zmq.hpp")
+ ENDIF()
+ ENDIF (ZEROMQ_FOUND)
+ENDIF (NOT ZEROMQ_FOUND)
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..2ffd520
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2022, Virtual Vehicle
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..3a0080b
--- /dev/null
+++ b/README.md
@@ -0,0 +1,25 @@
+# V2X Gateway
+The *v2x_gw* is part of the [vehicleCAPTAIN](https://github.com/virtual-vehicle/vehicle_captain) toolbox.
+
+The *v2x_gw* is a central ROS2 node that (i) connects to the vehicleCAPTAIN routing core (ii) converts V2X messages to ROS messages (iii) converts ROS messages to V2X messages.
+
+The vehicleCAPTAIN routing core may be replaced by your implementation for rx/tx of V2X messages.
+
+Version Support:
+* v1.x
+ * v2x_msgs v1.1.0
+ * vcits 1.0
+
+## Copyright
+Please cite the [vehicleCAPTAIN paper](https://TODO_link_to_paper_when_it_is_published) if you used any part of this library for your work.
+
+## Contribution Guidelines
+Feel free to add fixes and new features!
+
+## Authors
+Main Author: [Christoph Pilz](https://github.com/MrMushroom)
+
+## Acknowledgement
+The majority of this work is part of my ([Christoph Pilz](https://www.researchgate.net/profile/Christoph-Pilz)) PhD studies at [Graz University of Technology](https://www.tugraz.at/home) in cooperation with the [Virtual Vehicle Research GmbH](https://www.v2c2.at/).
+
+Features are also integrated across various funded projects (see [vehicleCAPTAIN](https://github.com/virtual-vehicle/vehicle_captain)).
diff --git a/USAGE_GUIDE.md b/USAGE_GUIDE.md
new file mode 100644
index 0000000..d8997e8
--- /dev/null
+++ b/USAGE_GUIDE.md
@@ -0,0 +1,55 @@
+# Usage Guide
+Check out the Requirements below!
+
+Afterwards simply check out the repo and integrate it into your ROS2 environment.
+
+## Requirements
+This node requires the [v2x_msgs](https://github.com/virtual-vehicle/v2x_msgs) library from the [vehicleCAPTAIN](https://github.com/virtual-vehicle/vehicle_captain) toolbox.
+
+This node is designed for the [v2x_routing_core](https://github.com/virtual-vehicle/vehicle_captain_routing_core) from the [vehicleCAPTAIN](https://github.com/virtual-vehicle/vehicle_captain) toolbox.
+However, you may introduce your own V2XServer connection.
+
+Also, check out the ROS2 dependencies (package.xml)!
+
+## In case you want to install ZMQ locally
+
+You may use zmq_setup.sh for setup
+
+In top level "CMakeLists.txt" replace setting of ZMQ libs with "FindZeroMQ.cmake"
+
+### LibZMQ v4.3.4
+```shell
+cd /opt
+git clone https://github.com/zeromq/libzmq.git
+cd /opt/libzmq
+git checkout v4.3.4
+
+apt-get update -qq
+apt-get install -qq --yes --no-install-recommends \
+libkrb5-dev \
+libsodium23
+
+./autogen.sh
+./configure --prefix=/usr/local --with-libgssapi_krb5
+make
+make check
+make install
+
+ldconfig && ldconfig -p | grep libzmq
+```
+
+### CPPZMQ v4.8.0
+WARNING: v4.8.0 recommended, but Ubuntu 18.04 has wrong cmake version!
+WARNING: also for that reason, the -DCPPZMQ_BUILD_TESTS=OFF is required
+```shell
+cd /opt
+git clone https://github.com/zeromq/cppzmq.git
+cd /opt/cppzmq
+git checkout v4.7.1
+
+mkdir build
+cd /opt/cppzmq/build
+
+cmake -DCPPZMQ_BUILD_TESTS=OFF ..
+make install
+```
diff --git a/config/v2x_gw.param.yaml b/config/v2x_gw.param.yaml
new file mode 100644
index 0000000..eef17e3
--- /dev/null
+++ b/config/v2x_gw.param.yaml
@@ -0,0 +1,32 @@
+# config/v2x_gw.param.yaml
+---
+
+# Node-specific parameters
+/**:
+ ros__parameters:
+ server:
+ type: "zmq" # type of the V2X server (supported: "zmq")
+ address: "vcaptain001.local" # hostname or ipv4 of the vehicleCAPTAIN routing core
+ receive_port: 5556 # 5556 is default for receiving from the vehicleCAPTAIN routing core
+ send_port: 5555 # 5555 is default for sending to the vehicleCAPTAIN routing core
+ topic_filter: "v2x." # supported: "v2x." ... get v2x messages (see vehicleCAPTAIN routing core docs)
+ cycle_time_ms: 1 # cycle time leads to communication update interval
+
+ header:
+ station_id: 1337 # this value is pseudonymized and should be unique in a GN communication
+
+ cam:
+ active: true # activate processing of CAM module
+ handler_debug_msg_throttle_ms: 5000 # throttle for debug msgs in milliseconds (throttles <=WARN)
+
+ cpm:
+ active: true # activate processing of CPM module
+ handler_debug_msg_throttle_ms: 5000 # throttle for debug msgs in milliseconds (throttles <=WARN)
+
+ denm:
+ active: true # activate processing of DENM module
+ handler_debug_msg_throttle_ms: 5000 # throttle for debug msgs in milliseconds (throttles <=WARN)
+
+ examplem:
+ active: false # activate processing of ExampleM module
+ handler_debug_msg_throttle_ms: 5000 # throttle for debug msgs in milliseconds (throttles <=WARN)
diff --git a/docs/v2x_gw_node_ros.drawio b/docs/v2x_gw_node_ros.drawio
new file mode 100644
index 0000000..726bd0a
--- /dev/null
+++ b/docs/v2x_gw_node_ros.drawio
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/ext/libzmq/include/zmq/zmq.h b/ext/libzmq/include/zmq/zmq.h
new file mode 100644
index 0000000..d05659f
--- /dev/null
+++ b/ext/libzmq/include/zmq/zmq.h
@@ -0,0 +1,788 @@
+/*
+ Copyright (c) 2007-2016 Contributors as noted in the AUTHORS file
+
+ This file is part of libzmq, the ZeroMQ core engine in C++.
+
+ libzmq is free software; you can redistribute it and/or modify it under
+ the terms of the GNU Lesser General Public License (LGPL) as published
+ by the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ As a special exception, the Contributors give you permission to link
+ this library with independent modules to produce an executable,
+ regardless of the license terms of these independent modules, and to
+ copy and distribute the resulting executable under terms of your choice,
+ provided that you also meet, for each linked independent module, the
+ terms and conditions of the license of that module. An independent
+ module is a module which is not derived from or based on this library.
+ If you modify this library, you must extend this exception to your
+ version of the library.
+
+ libzmq is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ License for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with this program. If not, see .
+
+ *************************************************************************
+ NOTE to contributors. This file comprises the principal public contract
+ for ZeroMQ API users. Any change to this file supplied in a stable
+ release SHOULD not break existing applications.
+ In practice this means that the value of constants must not change, and
+ that old values may not be reused for new constants.
+ *************************************************************************
+*/
+
+#ifndef __ZMQ_H_INCLUDED__
+#define __ZMQ_H_INCLUDED__
+
+/* Version macros for compile-time API version detection */
+#define ZMQ_VERSION_MAJOR 4
+#define ZMQ_VERSION_MINOR 3
+#define ZMQ_VERSION_PATCH 4
+
+#define ZMQ_MAKE_VERSION(major, minor, patch) \
+ ((major) *10000 + (minor) *100 + (patch))
+#define ZMQ_VERSION \
+ ZMQ_MAKE_VERSION (ZMQ_VERSION_MAJOR, ZMQ_VERSION_MINOR, ZMQ_VERSION_PATCH)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined _WIN32_WCE
+#include
+#endif
+#include
+#include
+#if defined _WIN32
+// Set target version to Windows Server 2008, Windows Vista or higher.
+// Windows XP (0x0501) is supported but without client & server socket types.
+#ifndef _WIN32_WINNT
+#define _WIN32_WINNT 0x0600
+#endif
+
+#ifdef __MINGW32__
+// Require Windows XP or higher with MinGW for getaddrinfo().
+#if (_WIN32_WINNT >= 0x0501)
+#else
+#error You need at least Windows XP target
+#endif
+#endif
+#endif
+
+/* Handle DSO symbol visibility */
+#if defined _WIN32
+#if defined ZMQ_STATIC
+#define ZMQ_EXPORT
+#elif defined DLL_EXPORT
+#define ZMQ_EXPORT __declspec(dllexport)
+#else
+#define ZMQ_EXPORT __declspec(dllimport)
+#endif
+#else
+#if defined __SUNPRO_C || defined __SUNPRO_CC
+#define ZMQ_EXPORT __global
+#elif (defined __GNUC__ && __GNUC__ >= 4) || defined __INTEL_COMPILER
+#define ZMQ_EXPORT __attribute__ ((visibility ("default")))
+#else
+#define ZMQ_EXPORT
+#endif
+#endif
+
+/* Define integer types needed for event interface */
+#define ZMQ_DEFINED_STDINT 1
+#if defined ZMQ_HAVE_SOLARIS || defined ZMQ_HAVE_OPENVMS
+#include
+#elif defined _MSC_VER && _MSC_VER < 1600
+#ifndef uint64_t
+typedef unsigned __int64 uint64_t;
+#endif
+#ifndef int32_t
+typedef __int32 int32_t;
+#endif
+#ifndef uint32_t
+typedef unsigned __int32 uint32_t;
+#endif
+#ifndef uint16_t
+typedef unsigned __int16 uint16_t;
+#endif
+#ifndef uint8_t
+typedef unsigned __int8 uint8_t;
+#endif
+#else
+#include
+#endif
+
+// 32-bit AIX's pollfd struct members are called reqevents and rtnevents so it
+// defines compatibility macros for them. Need to include that header first to
+// stop build failures since zmq_pollset_t defines them as events and revents.
+#ifdef ZMQ_HAVE_AIX
+#include
+#endif
+
+
+/******************************************************************************/
+/* 0MQ errors. */
+/******************************************************************************/
+
+/* A number random enough not to collide with different errno ranges on */
+/* different OSes. The assumption is that error_t is at least 32-bit type. */
+#define ZMQ_HAUSNUMERO 156384712
+
+/* On Windows platform some of the standard POSIX errnos are not defined. */
+#ifndef ENOTSUP
+#define ENOTSUP (ZMQ_HAUSNUMERO + 1)
+#endif
+#ifndef EPROTONOSUPPORT
+#define EPROTONOSUPPORT (ZMQ_HAUSNUMERO + 2)
+#endif
+#ifndef ENOBUFS
+#define ENOBUFS (ZMQ_HAUSNUMERO + 3)
+#endif
+#ifndef ENETDOWN
+#define ENETDOWN (ZMQ_HAUSNUMERO + 4)
+#endif
+#ifndef EADDRINUSE
+#define EADDRINUSE (ZMQ_HAUSNUMERO + 5)
+#endif
+#ifndef EADDRNOTAVAIL
+#define EADDRNOTAVAIL (ZMQ_HAUSNUMERO + 6)
+#endif
+#ifndef ECONNREFUSED
+#define ECONNREFUSED (ZMQ_HAUSNUMERO + 7)
+#endif
+#ifndef EINPROGRESS
+#define EINPROGRESS (ZMQ_HAUSNUMERO + 8)
+#endif
+#ifndef ENOTSOCK
+#define ENOTSOCK (ZMQ_HAUSNUMERO + 9)
+#endif
+#ifndef EMSGSIZE
+#define EMSGSIZE (ZMQ_HAUSNUMERO + 10)
+#endif
+#ifndef EAFNOSUPPORT
+#define EAFNOSUPPORT (ZMQ_HAUSNUMERO + 11)
+#endif
+#ifndef ENETUNREACH
+#define ENETUNREACH (ZMQ_HAUSNUMERO + 12)
+#endif
+#ifndef ECONNABORTED
+#define ECONNABORTED (ZMQ_HAUSNUMERO + 13)
+#endif
+#ifndef ECONNRESET
+#define ECONNRESET (ZMQ_HAUSNUMERO + 14)
+#endif
+#ifndef ENOTCONN
+#define ENOTCONN (ZMQ_HAUSNUMERO + 15)
+#endif
+#ifndef ETIMEDOUT
+#define ETIMEDOUT (ZMQ_HAUSNUMERO + 16)
+#endif
+#ifndef EHOSTUNREACH
+#define EHOSTUNREACH (ZMQ_HAUSNUMERO + 17)
+#endif
+#ifndef ENETRESET
+#define ENETRESET (ZMQ_HAUSNUMERO + 18)
+#endif
+
+/* Native 0MQ error codes. */
+#define EFSM (ZMQ_HAUSNUMERO + 51)
+#define ENOCOMPATPROTO (ZMQ_HAUSNUMERO + 52)
+#define ETERM (ZMQ_HAUSNUMERO + 53)
+#define EMTHREAD (ZMQ_HAUSNUMERO + 54)
+
+/* This function retrieves the errno as it is known to 0MQ library. The goal */
+/* of this function is to make the code 100% portable, including where 0MQ */
+/* compiled with certain CRT library (on Windows) is linked to an */
+/* application that uses different CRT library. */
+ZMQ_EXPORT int zmq_errno (void);
+
+/* Resolves system errors and 0MQ errors to human-readable string. */
+ZMQ_EXPORT const char *zmq_strerror (int errnum_);
+
+/* Run-time API version detection */
+ZMQ_EXPORT void zmq_version (int *major_, int *minor_, int *patch_);
+
+/******************************************************************************/
+/* 0MQ infrastructure (a.k.a. context) initialisation & termination. */
+/******************************************************************************/
+
+/* Context options */
+#define ZMQ_IO_THREADS 1
+#define ZMQ_MAX_SOCKETS 2
+#define ZMQ_SOCKET_LIMIT 3
+#define ZMQ_THREAD_PRIORITY 3
+#define ZMQ_THREAD_SCHED_POLICY 4
+#define ZMQ_MAX_MSGSZ 5
+#define ZMQ_MSG_T_SIZE 6
+#define ZMQ_THREAD_AFFINITY_CPU_ADD 7
+#define ZMQ_THREAD_AFFINITY_CPU_REMOVE 8
+#define ZMQ_THREAD_NAME_PREFIX 9
+
+/* Default for new contexts */
+#define ZMQ_IO_THREADS_DFLT 1
+#define ZMQ_MAX_SOCKETS_DFLT 1023
+#define ZMQ_THREAD_PRIORITY_DFLT -1
+#define ZMQ_THREAD_SCHED_POLICY_DFLT -1
+
+ZMQ_EXPORT void *zmq_ctx_new (void);
+ZMQ_EXPORT int zmq_ctx_term (void *context_);
+ZMQ_EXPORT int zmq_ctx_shutdown (void *context_);
+ZMQ_EXPORT int zmq_ctx_set (void *context_, int option_, int optval_);
+ZMQ_EXPORT int zmq_ctx_get (void *context_, int option_);
+
+/* Old (legacy) API */
+ZMQ_EXPORT void *zmq_init (int io_threads_);
+ZMQ_EXPORT int zmq_term (void *context_);
+ZMQ_EXPORT int zmq_ctx_destroy (void *context_);
+
+
+/******************************************************************************/
+/* 0MQ message definition. */
+/******************************************************************************/
+
+/* Some architectures, like sparc64 and some variants of aarch64, enforce pointer
+ * alignment and raise sigbus on violations. Make sure applications allocate
+ * zmq_msg_t on addresses aligned on a pointer-size boundary to avoid this issue.
+ */
+typedef struct zmq_msg_t
+{
+#if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_ARM64))
+ __declspec(align (8)) unsigned char _[64];
+#elif defined(_MSC_VER) \
+ && (defined(_M_IX86) || defined(_M_ARM_ARMV7VE) || defined(_M_ARM))
+ __declspec(align (4)) unsigned char _[64];
+#elif defined(__GNUC__) || defined(__INTEL_COMPILER) \
+ || (defined(__SUNPRO_C) && __SUNPRO_C >= 0x590) \
+ || (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x590)
+ unsigned char _[64] __attribute__ ((aligned (sizeof (void *))));
+#else
+ unsigned char _[64];
+#endif
+} zmq_msg_t;
+
+typedef void(zmq_free_fn) (void *data_, void *hint_);
+
+ZMQ_EXPORT int zmq_msg_init (zmq_msg_t *msg_);
+ZMQ_EXPORT int zmq_msg_init_size (zmq_msg_t *msg_, size_t size_);
+ZMQ_EXPORT int zmq_msg_init_data (
+ zmq_msg_t *msg_, void *data_, size_t size_, zmq_free_fn *ffn_, void *hint_);
+ZMQ_EXPORT int zmq_msg_send (zmq_msg_t *msg_, void *s_, int flags_);
+ZMQ_EXPORT int zmq_msg_recv (zmq_msg_t *msg_, void *s_, int flags_);
+ZMQ_EXPORT int zmq_msg_close (zmq_msg_t *msg_);
+ZMQ_EXPORT int zmq_msg_move (zmq_msg_t *dest_, zmq_msg_t *src_);
+ZMQ_EXPORT int zmq_msg_copy (zmq_msg_t *dest_, zmq_msg_t *src_);
+ZMQ_EXPORT void *zmq_msg_data (zmq_msg_t *msg_);
+ZMQ_EXPORT size_t zmq_msg_size (const zmq_msg_t *msg_);
+ZMQ_EXPORT int zmq_msg_more (const zmq_msg_t *msg_);
+ZMQ_EXPORT int zmq_msg_get (const zmq_msg_t *msg_, int property_);
+ZMQ_EXPORT int zmq_msg_set (zmq_msg_t *msg_, int property_, int optval_);
+ZMQ_EXPORT const char *zmq_msg_gets (const zmq_msg_t *msg_,
+ const char *property_);
+
+/******************************************************************************/
+/* 0MQ socket definition. */
+/******************************************************************************/
+
+/* Socket types. */
+#define ZMQ_PAIR 0
+#define ZMQ_PUB 1
+#define ZMQ_SUB 2
+#define ZMQ_REQ 3
+#define ZMQ_REP 4
+#define ZMQ_DEALER 5
+#define ZMQ_ROUTER 6
+#define ZMQ_PULL 7
+#define ZMQ_PUSH 8
+#define ZMQ_XPUB 9
+#define ZMQ_XSUB 10
+#define ZMQ_STREAM 11
+
+/* Deprecated aliases */
+#define ZMQ_XREQ ZMQ_DEALER
+#define ZMQ_XREP ZMQ_ROUTER
+
+/* Socket options. */
+#define ZMQ_AFFINITY 4
+#define ZMQ_ROUTING_ID 5
+#define ZMQ_SUBSCRIBE 6
+#define ZMQ_UNSUBSCRIBE 7
+#define ZMQ_RATE 8
+#define ZMQ_RECOVERY_IVL 9
+#define ZMQ_SNDBUF 11
+#define ZMQ_RCVBUF 12
+#define ZMQ_RCVMORE 13
+#define ZMQ_FD 14
+#define ZMQ_EVENTS 15
+#define ZMQ_TYPE 16
+#define ZMQ_LINGER 17
+#define ZMQ_RECONNECT_IVL 18
+#define ZMQ_BACKLOG 19
+#define ZMQ_RECONNECT_IVL_MAX 21
+#define ZMQ_MAXMSGSIZE 22
+#define ZMQ_SNDHWM 23
+#define ZMQ_RCVHWM 24
+#define ZMQ_MULTICAST_HOPS 25
+#define ZMQ_RCVTIMEO 27
+#define ZMQ_SNDTIMEO 28
+#define ZMQ_LAST_ENDPOINT 32
+#define ZMQ_ROUTER_MANDATORY 33
+#define ZMQ_TCP_KEEPALIVE 34
+#define ZMQ_TCP_KEEPALIVE_CNT 35
+#define ZMQ_TCP_KEEPALIVE_IDLE 36
+#define ZMQ_TCP_KEEPALIVE_INTVL 37
+#define ZMQ_IMMEDIATE 39
+#define ZMQ_XPUB_VERBOSE 40
+#define ZMQ_ROUTER_RAW 41
+#define ZMQ_IPV6 42
+#define ZMQ_MECHANISM 43
+#define ZMQ_PLAIN_SERVER 44
+#define ZMQ_PLAIN_USERNAME 45
+#define ZMQ_PLAIN_PASSWORD 46
+#define ZMQ_CURVE_SERVER 47
+#define ZMQ_CURVE_PUBLICKEY 48
+#define ZMQ_CURVE_SECRETKEY 49
+#define ZMQ_CURVE_SERVERKEY 50
+#define ZMQ_PROBE_ROUTER 51
+#define ZMQ_REQ_CORRELATE 52
+#define ZMQ_REQ_RELAXED 53
+#define ZMQ_CONFLATE 54
+#define ZMQ_ZAP_DOMAIN 55
+#define ZMQ_ROUTER_HANDOVER 56
+#define ZMQ_TOS 57
+#define ZMQ_CONNECT_ROUTING_ID 61
+#define ZMQ_GSSAPI_SERVER 62
+#define ZMQ_GSSAPI_PRINCIPAL 63
+#define ZMQ_GSSAPI_SERVICE_PRINCIPAL 64
+#define ZMQ_GSSAPI_PLAINTEXT 65
+#define ZMQ_HANDSHAKE_IVL 66
+#define ZMQ_SOCKS_PROXY 68
+#define ZMQ_XPUB_NODROP 69
+#define ZMQ_BLOCKY 70
+#define ZMQ_XPUB_MANUAL 71
+#define ZMQ_XPUB_WELCOME_MSG 72
+#define ZMQ_STREAM_NOTIFY 73
+#define ZMQ_INVERT_MATCHING 74
+#define ZMQ_HEARTBEAT_IVL 75
+#define ZMQ_HEARTBEAT_TTL 76
+#define ZMQ_HEARTBEAT_TIMEOUT 77
+#define ZMQ_XPUB_VERBOSER 78
+#define ZMQ_CONNECT_TIMEOUT 79
+#define ZMQ_TCP_MAXRT 80
+#define ZMQ_THREAD_SAFE 81
+#define ZMQ_MULTICAST_MAXTPDU 84
+#define ZMQ_VMCI_BUFFER_SIZE 85
+#define ZMQ_VMCI_BUFFER_MIN_SIZE 86
+#define ZMQ_VMCI_BUFFER_MAX_SIZE 87
+#define ZMQ_VMCI_CONNECT_TIMEOUT 88
+#define ZMQ_USE_FD 89
+#define ZMQ_GSSAPI_PRINCIPAL_NAMETYPE 90
+#define ZMQ_GSSAPI_SERVICE_PRINCIPAL_NAMETYPE 91
+#define ZMQ_BINDTODEVICE 92
+
+/* Message options */
+#define ZMQ_MORE 1
+#define ZMQ_SHARED 3
+
+/* Send/recv options. */
+#define ZMQ_DONTWAIT 1
+#define ZMQ_SNDMORE 2
+
+/* Security mechanisms */
+#define ZMQ_NULL 0
+#define ZMQ_PLAIN 1
+#define ZMQ_CURVE 2
+#define ZMQ_GSSAPI 3
+
+/* RADIO-DISH protocol */
+#define ZMQ_GROUP_MAX_LENGTH 255
+
+/* Deprecated options and aliases */
+#define ZMQ_IDENTITY ZMQ_ROUTING_ID
+#define ZMQ_CONNECT_RID ZMQ_CONNECT_ROUTING_ID
+#define ZMQ_TCP_ACCEPT_FILTER 38
+#define ZMQ_IPC_FILTER_PID 58
+#define ZMQ_IPC_FILTER_UID 59
+#define ZMQ_IPC_FILTER_GID 60
+#define ZMQ_IPV4ONLY 31
+#define ZMQ_DELAY_ATTACH_ON_CONNECT ZMQ_IMMEDIATE
+#define ZMQ_NOBLOCK ZMQ_DONTWAIT
+#define ZMQ_FAIL_UNROUTABLE ZMQ_ROUTER_MANDATORY
+#define ZMQ_ROUTER_BEHAVIOR ZMQ_ROUTER_MANDATORY
+
+/* Deprecated Message options */
+#define ZMQ_SRCFD 2
+
+/******************************************************************************/
+/* GSSAPI definitions */
+/******************************************************************************/
+
+/* GSSAPI principal name types */
+#define ZMQ_GSSAPI_NT_HOSTBASED 0
+#define ZMQ_GSSAPI_NT_USER_NAME 1
+#define ZMQ_GSSAPI_NT_KRB5_PRINCIPAL 2
+
+/******************************************************************************/
+/* 0MQ socket events and monitoring */
+/******************************************************************************/
+
+/* Socket transport events (TCP, IPC and TIPC only) */
+
+#define ZMQ_EVENT_CONNECTED 0x0001
+#define ZMQ_EVENT_CONNECT_DELAYED 0x0002
+#define ZMQ_EVENT_CONNECT_RETRIED 0x0004
+#define ZMQ_EVENT_LISTENING 0x0008
+#define ZMQ_EVENT_BIND_FAILED 0x0010
+#define ZMQ_EVENT_ACCEPTED 0x0020
+#define ZMQ_EVENT_ACCEPT_FAILED 0x0040
+#define ZMQ_EVENT_CLOSED 0x0080
+#define ZMQ_EVENT_CLOSE_FAILED 0x0100
+#define ZMQ_EVENT_DISCONNECTED 0x0200
+#define ZMQ_EVENT_MONITOR_STOPPED 0x0400
+#define ZMQ_EVENT_ALL 0xFFFF
+/* Unspecified system errors during handshake. Event value is an errno. */
+#define ZMQ_EVENT_HANDSHAKE_FAILED_NO_DETAIL 0x0800
+/* Handshake complete successfully with successful authentication (if *
+ * enabled). Event value is unused. */
+#define ZMQ_EVENT_HANDSHAKE_SUCCEEDED 0x1000
+/* Protocol errors between ZMTP peers or between server and ZAP handler. *
+ * Event value is one of ZMQ_PROTOCOL_ERROR_* */
+#define ZMQ_EVENT_HANDSHAKE_FAILED_PROTOCOL 0x2000
+/* Failed authentication requests. Event value is the numeric ZAP status *
+ * code, i.e. 300, 400 or 500. */
+#define ZMQ_EVENT_HANDSHAKE_FAILED_AUTH 0x4000
+#define ZMQ_PROTOCOL_ERROR_ZMTP_UNSPECIFIED 0x10000000
+#define ZMQ_PROTOCOL_ERROR_ZMTP_UNEXPECTED_COMMAND 0x10000001
+#define ZMQ_PROTOCOL_ERROR_ZMTP_INVALID_SEQUENCE 0x10000002
+#define ZMQ_PROTOCOL_ERROR_ZMTP_KEY_EXCHANGE 0x10000003
+#define ZMQ_PROTOCOL_ERROR_ZMTP_MALFORMED_COMMAND_UNSPECIFIED 0x10000011
+#define ZMQ_PROTOCOL_ERROR_ZMTP_MALFORMED_COMMAND_MESSAGE 0x10000012
+#define ZMQ_PROTOCOL_ERROR_ZMTP_MALFORMED_COMMAND_HELLO 0x10000013
+#define ZMQ_PROTOCOL_ERROR_ZMTP_MALFORMED_COMMAND_INITIATE 0x10000014
+#define ZMQ_PROTOCOL_ERROR_ZMTP_MALFORMED_COMMAND_ERROR 0x10000015
+#define ZMQ_PROTOCOL_ERROR_ZMTP_MALFORMED_COMMAND_READY 0x10000016
+#define ZMQ_PROTOCOL_ERROR_ZMTP_MALFORMED_COMMAND_WELCOME 0x10000017
+#define ZMQ_PROTOCOL_ERROR_ZMTP_INVALID_METADATA 0x10000018
+// the following two may be due to erroneous configuration of a peer
+#define ZMQ_PROTOCOL_ERROR_ZMTP_CRYPTOGRAPHIC 0x11000001
+#define ZMQ_PROTOCOL_ERROR_ZMTP_MECHANISM_MISMATCH 0x11000002
+#define ZMQ_PROTOCOL_ERROR_ZAP_UNSPECIFIED 0x20000000
+#define ZMQ_PROTOCOL_ERROR_ZAP_MALFORMED_REPLY 0x20000001
+#define ZMQ_PROTOCOL_ERROR_ZAP_BAD_REQUEST_ID 0x20000002
+#define ZMQ_PROTOCOL_ERROR_ZAP_BAD_VERSION 0x20000003
+#define ZMQ_PROTOCOL_ERROR_ZAP_INVALID_STATUS_CODE 0x20000004
+#define ZMQ_PROTOCOL_ERROR_ZAP_INVALID_METADATA 0x20000005
+#define ZMQ_PROTOCOL_ERROR_WS_UNSPECIFIED 0x30000000
+
+ZMQ_EXPORT void *zmq_socket (void *, int type_);
+ZMQ_EXPORT int zmq_close (void *s_);
+ZMQ_EXPORT int
+zmq_setsockopt (void *s_, int option_, const void *optval_, size_t optvallen_);
+ZMQ_EXPORT int
+zmq_getsockopt (void *s_, int option_, void *optval_, size_t *optvallen_);
+ZMQ_EXPORT int zmq_bind (void *s_, const char *addr_);
+ZMQ_EXPORT int zmq_connect (void *s_, const char *addr_);
+ZMQ_EXPORT int zmq_unbind (void *s_, const char *addr_);
+ZMQ_EXPORT int zmq_disconnect (void *s_, const char *addr_);
+ZMQ_EXPORT int zmq_send (void *s_, const void *buf_, size_t len_, int flags_);
+ZMQ_EXPORT int
+zmq_send_const (void *s_, const void *buf_, size_t len_, int flags_);
+ZMQ_EXPORT int zmq_recv (void *s_, void *buf_, size_t len_, int flags_);
+ZMQ_EXPORT int zmq_socket_monitor (void *s_, const char *addr_, int events_);
+
+/******************************************************************************/
+/* Hide socket fd type; this was before zmq_poller_event_t typedef below */
+/******************************************************************************/
+
+#if defined _WIN32
+// Windows uses a pointer-sized unsigned integer to store the socket fd.
+#if defined _WIN64
+typedef unsigned __int64 zmq_fd_t;
+#else
+typedef unsigned int zmq_fd_t;
+#endif
+#else
+typedef int zmq_fd_t;
+#endif
+
+/******************************************************************************/
+/* Deprecated I/O multiplexing. Prefer using zmq_poller API */
+/******************************************************************************/
+
+#define ZMQ_POLLIN 1
+#define ZMQ_POLLOUT 2
+#define ZMQ_POLLERR 4
+#define ZMQ_POLLPRI 8
+
+typedef struct zmq_pollitem_t
+{
+ void *socket;
+ zmq_fd_t fd;
+ short events;
+ short revents;
+} zmq_pollitem_t;
+
+#define ZMQ_POLLITEMS_DFLT 16
+
+ZMQ_EXPORT int zmq_poll (zmq_pollitem_t *items_, int nitems_, long timeout_);
+
+/******************************************************************************/
+/* Message proxying */
+/******************************************************************************/
+
+ZMQ_EXPORT int zmq_proxy (void *frontend_, void *backend_, void *capture_);
+ZMQ_EXPORT int zmq_proxy_steerable (void *frontend_,
+ void *backend_,
+ void *capture_,
+ void *control_);
+
+/******************************************************************************/
+/* Probe library capabilities */
+/******************************************************************************/
+
+#define ZMQ_HAS_CAPABILITIES 1
+ZMQ_EXPORT int zmq_has (const char *capability_);
+
+/* Deprecated aliases */
+#define ZMQ_STREAMER 1
+#define ZMQ_FORWARDER 2
+#define ZMQ_QUEUE 3
+
+/* Deprecated methods */
+ZMQ_EXPORT int zmq_device (int type_, void *frontend_, void *backend_);
+ZMQ_EXPORT int zmq_sendmsg (void *s_, zmq_msg_t *msg_, int flags_);
+ZMQ_EXPORT int zmq_recvmsg (void *s_, zmq_msg_t *msg_, int flags_);
+struct iovec;
+ZMQ_EXPORT int
+zmq_sendiov (void *s_, struct iovec *iov_, size_t count_, int flags_);
+ZMQ_EXPORT int
+zmq_recviov (void *s_, struct iovec *iov_, size_t *count_, int flags_);
+
+/******************************************************************************/
+/* Encryption functions */
+/******************************************************************************/
+
+/* Encode data with Z85 encoding. Returns encoded data */
+ZMQ_EXPORT char *
+zmq_z85_encode (char *dest_, const uint8_t *data_, size_t size_);
+
+/* Decode data with Z85 encoding. Returns decoded data */
+ZMQ_EXPORT uint8_t *zmq_z85_decode (uint8_t *dest_, const char *string_);
+
+/* Generate z85-encoded public and private keypair with tweetnacl/libsodium. */
+/* Returns 0 on success. */
+ZMQ_EXPORT int zmq_curve_keypair (char *z85_public_key_, char *z85_secret_key_);
+
+/* Derive the z85-encoded public key from the z85-encoded secret key. */
+/* Returns 0 on success. */
+ZMQ_EXPORT int zmq_curve_public (char *z85_public_key_,
+ const char *z85_secret_key_);
+
+/******************************************************************************/
+/* Atomic utility methods */
+/******************************************************************************/
+
+ZMQ_EXPORT void *zmq_atomic_counter_new (void);
+ZMQ_EXPORT void zmq_atomic_counter_set (void *counter_, int value_);
+ZMQ_EXPORT int zmq_atomic_counter_inc (void *counter_);
+ZMQ_EXPORT int zmq_atomic_counter_dec (void *counter_);
+ZMQ_EXPORT int zmq_atomic_counter_value (void *counter_);
+ZMQ_EXPORT void zmq_atomic_counter_destroy (void **counter_p_);
+
+/******************************************************************************/
+/* Scheduling timers */
+/******************************************************************************/
+
+#define ZMQ_HAVE_TIMERS
+
+typedef void(zmq_timer_fn) (int timer_id, void *arg);
+
+ZMQ_EXPORT void *zmq_timers_new (void);
+ZMQ_EXPORT int zmq_timers_destroy (void **timers_p);
+ZMQ_EXPORT int
+zmq_timers_add (void *timers, size_t interval, zmq_timer_fn handler, void *arg);
+ZMQ_EXPORT int zmq_timers_cancel (void *timers, int timer_id);
+ZMQ_EXPORT int
+zmq_timers_set_interval (void *timers, int timer_id, size_t interval);
+ZMQ_EXPORT int zmq_timers_reset (void *timers, int timer_id);
+ZMQ_EXPORT long zmq_timers_timeout (void *timers);
+ZMQ_EXPORT int zmq_timers_execute (void *timers);
+
+
+/******************************************************************************/
+/* These functions are not documented by man pages -- use at your own risk. */
+/* If you need these to be part of the formal ZMQ API, then (a) write a man */
+/* page, and (b) write a test case in tests. */
+/******************************************************************************/
+
+/* Helper functions are used by perf tests so that they don't have to care */
+/* about minutiae of time-related functions on different OS platforms. */
+
+/* Starts the stopwatch. Returns the handle to the watch. */
+ZMQ_EXPORT void *zmq_stopwatch_start (void);
+
+/* Returns the number of microseconds elapsed since the stopwatch was */
+/* started, but does not stop or deallocate the stopwatch. */
+ZMQ_EXPORT unsigned long zmq_stopwatch_intermediate (void *watch_);
+
+/* Stops the stopwatch. Returns the number of microseconds elapsed since */
+/* the stopwatch was started, and deallocates that watch. */
+ZMQ_EXPORT unsigned long zmq_stopwatch_stop (void *watch_);
+
+/* Sleeps for specified number of seconds. */
+ZMQ_EXPORT void zmq_sleep (int seconds_);
+
+typedef void(zmq_thread_fn) (void *);
+
+/* Start a thread. Returns a handle to the thread. */
+ZMQ_EXPORT void *zmq_threadstart (zmq_thread_fn *func_, void *arg_);
+
+/* Wait for thread to complete then free up resources. */
+ZMQ_EXPORT void zmq_threadclose (void *thread_);
+
+
+/******************************************************************************/
+/* These functions are DRAFT and disabled in stable releases, and subject to */
+/* change at ANY time until declared stable. */
+/******************************************************************************/
+
+#ifdef ZMQ_BUILD_DRAFT_API
+
+/* DRAFT Socket types. */
+#define ZMQ_SERVER 12
+#define ZMQ_CLIENT 13
+#define ZMQ_RADIO 14
+#define ZMQ_DISH 15
+#define ZMQ_GATHER 16
+#define ZMQ_SCATTER 17
+#define ZMQ_DGRAM 18
+#define ZMQ_PEER 19
+#define ZMQ_CHANNEL 20
+
+/* DRAFT Socket options. */
+#define ZMQ_ZAP_ENFORCE_DOMAIN 93
+#define ZMQ_LOOPBACK_FASTPATH 94
+#define ZMQ_METADATA 95
+#define ZMQ_MULTICAST_LOOP 96
+#define ZMQ_ROUTER_NOTIFY 97
+#define ZMQ_XPUB_MANUAL_LAST_VALUE 98
+#define ZMQ_SOCKS_USERNAME 99
+#define ZMQ_SOCKS_PASSWORD 100
+#define ZMQ_IN_BATCH_SIZE 101
+#define ZMQ_OUT_BATCH_SIZE 102
+#define ZMQ_WSS_KEY_PEM 103
+#define ZMQ_WSS_CERT_PEM 104
+#define ZMQ_WSS_TRUST_PEM 105
+#define ZMQ_WSS_HOSTNAME 106
+#define ZMQ_WSS_TRUST_SYSTEM 107
+#define ZMQ_ONLY_FIRST_SUBSCRIBE 108
+#define ZMQ_RECONNECT_STOP 109
+#define ZMQ_HELLO_MSG 110
+#define ZMQ_DISCONNECT_MSG 111
+#define ZMQ_PRIORITY 112
+
+/* DRAFT ZMQ_RECONNECT_STOP options */
+#define ZMQ_RECONNECT_STOP_CONN_REFUSED 0x1
+#define ZMQ_RECONNECT_STOP_HANDSHAKE_FAILED 0x2
+#define ZMQ_RECONNECT_STOP_AFTER_DISCONNECT 0x3
+
+/* DRAFT Context options */
+#define ZMQ_ZERO_COPY_RECV 10
+
+/* DRAFT Context methods. */
+ZMQ_EXPORT int zmq_ctx_set_ext (void *context_,
+ int option_,
+ const void *optval_,
+ size_t optvallen_);
+ZMQ_EXPORT int zmq_ctx_get_ext (void *context_,
+ int option_,
+ void *optval_,
+ size_t *optvallen_);
+
+/* DRAFT Socket methods. */
+ZMQ_EXPORT int zmq_join (void *s, const char *group);
+ZMQ_EXPORT int zmq_leave (void *s, const char *group);
+ZMQ_EXPORT uint32_t zmq_connect_peer (void *s_, const char *addr_);
+
+/* DRAFT Msg methods. */
+ZMQ_EXPORT int zmq_msg_set_routing_id (zmq_msg_t *msg, uint32_t routing_id);
+ZMQ_EXPORT uint32_t zmq_msg_routing_id (zmq_msg_t *msg);
+ZMQ_EXPORT int zmq_msg_set_group (zmq_msg_t *msg, const char *group);
+ZMQ_EXPORT const char *zmq_msg_group (zmq_msg_t *msg);
+ZMQ_EXPORT int
+zmq_msg_init_buffer (zmq_msg_t *msg_, const void *buf_, size_t size_);
+
+/* DRAFT Msg property names. */
+#define ZMQ_MSG_PROPERTY_ROUTING_ID "Routing-Id"
+#define ZMQ_MSG_PROPERTY_SOCKET_TYPE "Socket-Type"
+#define ZMQ_MSG_PROPERTY_USER_ID "User-Id"
+#define ZMQ_MSG_PROPERTY_PEER_ADDRESS "Peer-Address"
+
+/* Router notify options */
+#define ZMQ_NOTIFY_CONNECT 1
+#define ZMQ_NOTIFY_DISCONNECT 2
+
+/******************************************************************************/
+/* Poller polling on sockets,fd and thread-safe sockets */
+/******************************************************************************/
+
+#define ZMQ_HAVE_POLLER
+
+typedef struct zmq_poller_event_t
+{
+ void *socket;
+ zmq_fd_t fd;
+ void *user_data;
+ short events;
+} zmq_poller_event_t;
+
+ZMQ_EXPORT void *zmq_poller_new (void);
+ZMQ_EXPORT int zmq_poller_destroy (void **poller_p);
+ZMQ_EXPORT int zmq_poller_size (void *poller);
+ZMQ_EXPORT int
+zmq_poller_add (void *poller, void *socket, void *user_data, short events);
+ZMQ_EXPORT int zmq_poller_modify (void *poller, void *socket, short events);
+ZMQ_EXPORT int zmq_poller_remove (void *poller, void *socket);
+ZMQ_EXPORT int
+zmq_poller_wait (void *poller, zmq_poller_event_t *event, long timeout);
+ZMQ_EXPORT int zmq_poller_wait_all (void *poller,
+ zmq_poller_event_t *events,
+ int n_events,
+ long timeout);
+ZMQ_EXPORT int zmq_poller_fd (void *poller, zmq_fd_t *fd);
+
+ZMQ_EXPORT int
+zmq_poller_add_fd (void *poller, zmq_fd_t fd, void *user_data, short events);
+ZMQ_EXPORT int zmq_poller_modify_fd (void *poller, zmq_fd_t fd, short events);
+ZMQ_EXPORT int zmq_poller_remove_fd (void *poller, zmq_fd_t fd);
+
+ZMQ_EXPORT int zmq_socket_get_peer_state (void *socket,
+ const void *routing_id,
+ size_t routing_id_size);
+
+/* DRAFT Socket monitoring events */
+#define ZMQ_EVENT_PIPES_STATS 0x10000
+
+#define ZMQ_CURRENT_EVENT_VERSION 1
+#define ZMQ_CURRENT_EVENT_VERSION_DRAFT 2
+
+#define ZMQ_EVENT_ALL_V1 ZMQ_EVENT_ALL
+#define ZMQ_EVENT_ALL_V2 ZMQ_EVENT_ALL_V1 | ZMQ_EVENT_PIPES_STATS
+
+ZMQ_EXPORT int zmq_socket_monitor_versioned (
+ void *s_, const char *addr_, uint64_t events_, int event_version_, int type_);
+ZMQ_EXPORT int zmq_socket_monitor_pipes_stats (void *s);
+
+#endif // ZMQ_BUILD_DRAFT_API
+
+
+#undef ZMQ_EXPORT
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/ext/libzmq/include/zmq/zmq.hpp b/ext/libzmq/include/zmq/zmq.hpp
new file mode 100644
index 0000000..8da9a2d
--- /dev/null
+++ b/ext/libzmq/include/zmq/zmq.hpp
@@ -0,0 +1,2708 @@
+/*
+ Copyright (c) 2016-2017 ZeroMQ community
+ Copyright (c) 2009-2011 250bpm s.r.o.
+ Copyright (c) 2011 Botond Ballo
+ Copyright (c) 2007-2009 iMatix Corporation
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to
+ deal in the Software without restriction, including without limitation the
+ rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ sell copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ IN THE SOFTWARE.
+*/
+
+#ifndef __ZMQ_HPP_INCLUDED__
+#define __ZMQ_HPP_INCLUDED__
+
+#ifdef _WIN32
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#endif
+
+// included here for _HAS_CXX* macros
+#include
+
+#if defined(_MSVC_LANG)
+#define CPPZMQ_LANG _MSVC_LANG
+#else
+#define CPPZMQ_LANG __cplusplus
+#endif
+// overwrite if specific language macros indicate higher version
+#if defined(_HAS_CXX14) && _HAS_CXX14 && CPPZMQ_LANG < 201402L
+#undef CPPZMQ_LANG
+#define CPPZMQ_LANG 201402L
+#endif
+#if defined(_HAS_CXX17) && _HAS_CXX17 && CPPZMQ_LANG < 201703L
+#undef CPPZMQ_LANG
+#define CPPZMQ_LANG 201703L
+#endif
+
+// macros defined if has a specific standard or greater
+#if CPPZMQ_LANG >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1900)
+#define ZMQ_CPP11
+#endif
+#if CPPZMQ_LANG >= 201402L
+#define ZMQ_CPP14
+#endif
+#if CPPZMQ_LANG >= 201703L
+#define ZMQ_CPP17
+#endif
+
+#if defined(ZMQ_CPP14) && !defined(_MSC_VER)
+#define ZMQ_DEPRECATED(msg) [[deprecated(msg)]]
+#elif defined(_MSC_VER)
+#define ZMQ_DEPRECATED(msg) __declspec(deprecated(msg))
+#elif defined(__GNUC__)
+#define ZMQ_DEPRECATED(msg) __attribute__((deprecated(msg)))
+#endif
+
+#if defined(ZMQ_CPP17)
+#define ZMQ_NODISCARD [[nodiscard]]
+#else
+#define ZMQ_NODISCARD
+#endif
+
+#if defined(ZMQ_CPP11)
+#define ZMQ_NOTHROW noexcept
+#define ZMQ_EXPLICIT explicit
+#define ZMQ_OVERRIDE override
+#define ZMQ_NULLPTR nullptr
+#define ZMQ_CONSTEXPR_FN constexpr
+#define ZMQ_CONSTEXPR_VAR constexpr
+#define ZMQ_CPP11_DEPRECATED(msg) ZMQ_DEPRECATED(msg)
+#else
+#define ZMQ_NOTHROW throw()
+#define ZMQ_EXPLICIT
+#define ZMQ_OVERRIDE
+#define ZMQ_NULLPTR 0
+#define ZMQ_CONSTEXPR_FN
+#define ZMQ_CONSTEXPR_VAR const
+#define ZMQ_CPP11_DEPRECATED(msg)
+#endif
+#if defined(ZMQ_CPP14) && (!defined(_MSC_VER) || _MSC_VER > 1900)
+#define ZMQ_EXTENDED_CONSTEXPR
+#endif
+#if defined(ZMQ_CPP17)
+#define ZMQ_INLINE_VAR inline
+#define ZMQ_CONSTEXPR_IF constexpr
+#else
+#define ZMQ_INLINE_VAR
+#define ZMQ_CONSTEXPR_IF
+#endif
+
+#include
+#include
+
+#include
+#include
+#include
+#include
+#include
+#include
+#ifdef ZMQ_CPP11
+#include
+#include
+#include
+#include
+#endif
+
+#if defined(__has_include) && defined(ZMQ_CPP17)
+#define CPPZMQ_HAS_INCLUDE_CPP17(X) __has_include(X)
+#else
+#define CPPZMQ_HAS_INCLUDE_CPP17(X) 0
+#endif
+
+#if CPPZMQ_HAS_INCLUDE_CPP17() && !defined(CPPZMQ_HAS_OPTIONAL)
+#define CPPZMQ_HAS_OPTIONAL 1
+#endif
+#ifndef CPPZMQ_HAS_OPTIONAL
+#define CPPZMQ_HAS_OPTIONAL 0
+#elif CPPZMQ_HAS_OPTIONAL
+#include
+#endif
+
+#if CPPZMQ_HAS_INCLUDE_CPP17() && !defined(CPPZMQ_HAS_STRING_VIEW)
+#define CPPZMQ_HAS_STRING_VIEW 1
+#endif
+#ifndef CPPZMQ_HAS_STRING_VIEW
+#define CPPZMQ_HAS_STRING_VIEW 0
+#elif CPPZMQ_HAS_STRING_VIEW
+#include
+#endif
+
+/* Version macros for compile-time API version detection */
+#define CPPZMQ_VERSION_MAJOR 4
+#define CPPZMQ_VERSION_MINOR 8
+#define CPPZMQ_VERSION_PATCH 0
+
+#define CPPZMQ_VERSION \
+ ZMQ_MAKE_VERSION(CPPZMQ_VERSION_MAJOR, CPPZMQ_VERSION_MINOR, \
+ CPPZMQ_VERSION_PATCH)
+
+// Detect whether the compiler supports C++11 rvalue references.
+#if (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 2)) \
+ && defined(__GXX_EXPERIMENTAL_CXX0X__))
+#define ZMQ_HAS_RVALUE_REFS
+#define ZMQ_DELETED_FUNCTION = delete
+#elif defined(__clang__)
+#if __has_feature(cxx_rvalue_references)
+#define ZMQ_HAS_RVALUE_REFS
+#endif
+
+#if __has_feature(cxx_deleted_functions)
+#define ZMQ_DELETED_FUNCTION = delete
+#else
+#define ZMQ_DELETED_FUNCTION
+#endif
+#elif defined(_MSC_VER) && (_MSC_VER >= 1900)
+#define ZMQ_HAS_RVALUE_REFS
+#define ZMQ_DELETED_FUNCTION = delete
+#elif defined(_MSC_VER) && (_MSC_VER >= 1600)
+#define ZMQ_HAS_RVALUE_REFS
+#define ZMQ_DELETED_FUNCTION
+#else
+#define ZMQ_DELETED_FUNCTION
+#endif
+
+#if defined(ZMQ_CPP11) && !defined(__llvm__) && !defined(__INTEL_COMPILER) \
+ && defined(__GNUC__) && __GNUC__ < 5
+#define ZMQ_CPP11_PARTIAL
+#elif defined(__GLIBCXX__) && __GLIBCXX__ < 20160805
+//the date here is the last date of gcc 4.9.4, which
+// effectively means libstdc++ from gcc 5.5 and higher won't trigger this branch
+#define ZMQ_CPP11_PARTIAL
+#endif
+
+#ifdef ZMQ_CPP11
+#ifdef ZMQ_CPP11_PARTIAL
+#define ZMQ_IS_TRIVIALLY_COPYABLE(T) __has_trivial_copy(T)
+#else
+#include
+#define ZMQ_IS_TRIVIALLY_COPYABLE(T) std::is_trivially_copyable::value
+#endif
+#endif
+
+#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(3, 3, 0)
+#define ZMQ_NEW_MONITOR_EVENT_LAYOUT
+#endif
+
+#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 1, 0)
+#define ZMQ_HAS_PROXY_STEERABLE
+/* Socket event data */
+typedef struct
+{
+ uint16_t event; // id of the event as bitfield
+ int32_t value; // value is either error code, fd or reconnect interval
+} zmq_event_t;
+#endif
+
+// Avoid using deprecated message receive function when possible
+#if ZMQ_VERSION < ZMQ_MAKE_VERSION(3, 2, 0)
+#define zmq_msg_recv(msg, socket, flags) zmq_recvmsg(socket, msg, flags)
+#endif
+
+
+// In order to prevent unused variable warnings when building in non-debug
+// mode use this macro to make assertions.
+#ifndef NDEBUG
+#define ZMQ_ASSERT(expression) assert(expression)
+#else
+#define ZMQ_ASSERT(expression) (void) (expression)
+#endif
+
+namespace zmq
+{
+#ifdef ZMQ_CPP11
+namespace detail
+{
+namespace ranges
+{
+using std::begin;
+using std::end;
+template auto begin(T &&r) -> decltype(begin(std::forward(r)))
+{
+ return begin(std::forward(r));
+}
+template auto end(T &&r) -> decltype(end(std::forward(r)))
+{
+ return end(std::forward(r));
+}
+} // namespace ranges
+
+template using void_t = void;
+
+template
+using iter_value_t = typename std::iterator_traits::value_type;
+
+template
+using range_iter_t = decltype(
+ ranges::begin(std::declval::type &>()));
+
+template using range_value_t = iter_value_t>;
+
+template struct is_range : std::false_type
+{
+};
+
+template
+struct is_range<
+ T,
+ void_t::type &>())
+ == ranges::end(std::declval::type &>()))>>
+ : std::true_type
+{
+};
+
+} // namespace detail
+#endif
+
+typedef zmq_free_fn free_fn;
+typedef zmq_pollitem_t pollitem_t;
+
+// duplicate definition from libzmq 4.3.3
+#if defined _WIN32
+#if defined _WIN64
+typedef unsigned __int64 fd_t;
+#else
+typedef unsigned int fd_t;
+#endif
+#else
+typedef int fd_t;
+#endif
+
+class error_t : public std::exception
+{
+ public:
+ error_t() ZMQ_NOTHROW : errnum(zmq_errno()) {}
+ explicit error_t(int err) ZMQ_NOTHROW : errnum(err) {}
+ virtual const char *what() const ZMQ_NOTHROW ZMQ_OVERRIDE
+ {
+ return zmq_strerror(errnum);
+ }
+ int num() const ZMQ_NOTHROW { return errnum; }
+
+ private:
+ int errnum;
+};
+
+namespace detail {
+inline int poll(zmq_pollitem_t *items_, size_t nitems_, long timeout_)
+{
+ int rc = zmq_poll(items_, static_cast(nitems_), timeout_);
+ if (rc < 0)
+ throw error_t();
+ return rc;
+}
+}
+
+#ifdef ZMQ_CPP11
+ZMQ_DEPRECATED("from 4.8.0, use poll taking std::chrono::duration instead of long")
+inline int poll(zmq_pollitem_t *items_, size_t nitems_, long timeout_)
+#else
+inline int poll(zmq_pollitem_t *items_, size_t nitems_, long timeout_ = -1)
+#endif
+{
+ return detail::poll(items_, nitems_, timeout_);
+}
+
+ZMQ_DEPRECATED("from 4.3.1, use poll taking non-const items")
+inline int poll(zmq_pollitem_t const *items_, size_t nitems_, long timeout_ = -1)
+{
+ return detail::poll(const_cast(items_), nitems_, timeout_);
+}
+
+#ifdef ZMQ_CPP11
+ZMQ_DEPRECATED("from 4.3.1, use poll taking non-const items")
+inline int
+poll(zmq_pollitem_t const *items, size_t nitems, std::chrono::milliseconds timeout)
+{
+ return detail::poll(const_cast(items), nitems,
+ static_cast(timeout.count()));
+}
+
+ZMQ_DEPRECATED("from 4.3.1, use poll taking non-const items")
+inline int poll(std::vector const &items,
+ std::chrono::milliseconds timeout)
+{
+ return detail::poll(const_cast(items.data()), items.size(),
+ static_cast(timeout.count()));
+}
+
+ZMQ_DEPRECATED("from 4.3.1, use poll taking non-const items")
+inline int poll(std::vector const &items, long timeout_ = -1)
+{
+ return detail::poll(const_cast(items.data()), items.size(), timeout_);
+}
+
+inline int
+poll(zmq_pollitem_t *items, size_t nitems, std::chrono::milliseconds timeout = std::chrono::milliseconds{-1})
+{
+ return detail::poll(items, nitems, static_cast(timeout.count()));
+}
+
+inline int poll(std::vector &items,
+ std::chrono::milliseconds timeout = std::chrono::milliseconds{-1})
+{
+ return detail::poll(items.data(), items.size(), static_cast(timeout.count()));
+}
+
+ZMQ_DEPRECATED("from 4.3.1, use poll taking std::chrono::duration instead of long")
+inline int poll(std::vector &items, long timeout_)
+{
+ return detail::poll(items.data(), items.size(), timeout_);
+}
+
+template
+inline int poll(std::array &items,
+ std::chrono::milliseconds timeout = std::chrono::milliseconds{-1})
+{
+ return detail::poll(items.data(), items.size(), static_cast(timeout.count()));
+}
+#endif
+
+
+inline void version(int *major_, int *minor_, int *patch_)
+{
+ zmq_version(major_, minor_, patch_);
+}
+
+#ifdef ZMQ_CPP11
+inline std::tuple version()
+{
+ std::tuple v;
+ zmq_version(&std::get<0>(v), &std::get<1>(v), &std::get<2>(v));
+ return v;
+}
+
+#if !defined(ZMQ_CPP11_PARTIAL)
+namespace detail
+{
+template struct is_char_type
+{
+ // true if character type for string literals in C++11
+ static constexpr bool value =
+ std::is_same::value || std::is_same::value
+ || std::is_same::value || std::is_same::value;
+};
+}
+#endif
+
+#endif
+
+class message_t
+{
+ public:
+ message_t() ZMQ_NOTHROW
+ {
+ int rc = zmq_msg_init(&msg);
+ ZMQ_ASSERT(rc == 0);
+ }
+
+ explicit message_t(size_t size_)
+ {
+ int rc = zmq_msg_init_size(&msg, size_);
+ if (rc != 0)
+ throw error_t();
+ }
+
+ template message_t(ForwardIter first, ForwardIter last)
+ {
+ typedef typename std::iterator_traits::value_type value_t;
+
+ assert(std::distance(first, last) >= 0);
+ size_t const size_ =
+ static_cast(std::distance(first, last)) * sizeof(value_t);
+ int const rc = zmq_msg_init_size(&msg, size_);
+ if (rc != 0)
+ throw error_t();
+ std::copy(first, last, data());
+ }
+
+ message_t(const void *data_, size_t size_)
+ {
+ int rc = zmq_msg_init_size(&msg, size_);
+ if (rc != 0)
+ throw error_t();
+ if (size_) {
+ // this constructor allows (nullptr, 0),
+ // memcpy with a null pointer is UB
+ memcpy(data(), data_, size_);
+ }
+ }
+
+ message_t(void *data_, size_t size_, free_fn *ffn_, void *hint_ = ZMQ_NULLPTR)
+ {
+ int rc = zmq_msg_init_data(&msg, data_, size_, ffn_, hint_);
+ if (rc != 0)
+ throw error_t();
+ }
+
+ // overload set of string-like types and generic containers
+#if defined(ZMQ_CPP11) && !defined(ZMQ_CPP11_PARTIAL)
+ // NOTE this constructor will include the null terminator
+ // when called with a string literal.
+ // An overload taking const char* can not be added because
+ // it would be preferred over this function and break compatiblity.
+ template<
+ class Char,
+ size_t N,
+ typename = typename std::enable_if::value>::type>
+ ZMQ_DEPRECATED("from 4.7.0, use constructors taking iterators, (pointer, size) "
+ "or strings instead")
+ explicit message_t(const Char (&data)[N]) :
+ message_t(detail::ranges::begin(data), detail::ranges::end(data))
+ {
+ }
+
+ template::value
+ && ZMQ_IS_TRIVIALLY_COPYABLE(detail::range_value_t)
+ && !detail::is_char_type>::value
+ && !std::is_same::value>::type>
+ explicit message_t(const Range &rng) :
+ message_t(detail::ranges::begin(rng), detail::ranges::end(rng))
+ {
+ }
+
+ explicit message_t(const std::string &str) : message_t(str.data(), str.size()) {}
+
+#if CPPZMQ_HAS_STRING_VIEW
+ explicit message_t(std::string_view str) : message_t(str.data(), str.size()) {}
+#endif
+
+#endif
+
+#ifdef ZMQ_HAS_RVALUE_REFS
+ message_t(message_t &&rhs) ZMQ_NOTHROW : msg(rhs.msg)
+ {
+ int rc = zmq_msg_init(&rhs.msg);
+ ZMQ_ASSERT(rc == 0);
+ }
+
+ message_t &operator=(message_t &&rhs) ZMQ_NOTHROW
+ {
+ std::swap(msg, rhs.msg);
+ return *this;
+ }
+#endif
+
+ ~message_t() ZMQ_NOTHROW
+ {
+ int rc = zmq_msg_close(&msg);
+ ZMQ_ASSERT(rc == 0);
+ }
+
+ void rebuild()
+ {
+ int rc = zmq_msg_close(&msg);
+ if (rc != 0)
+ throw error_t();
+ rc = zmq_msg_init(&msg);
+ ZMQ_ASSERT(rc == 0);
+ }
+
+ void rebuild(size_t size_)
+ {
+ int rc = zmq_msg_close(&msg);
+ if (rc != 0)
+ throw error_t();
+ rc = zmq_msg_init_size(&msg, size_);
+ if (rc != 0)
+ throw error_t();
+ }
+
+ void rebuild(const void *data_, size_t size_)
+ {
+ int rc = zmq_msg_close(&msg);
+ if (rc != 0)
+ throw error_t();
+ rc = zmq_msg_init_size(&msg, size_);
+ if (rc != 0)
+ throw error_t();
+ memcpy(data(), data_, size_);
+ }
+
+ void rebuild(void *data_, size_t size_, free_fn *ffn_, void *hint_ = ZMQ_NULLPTR)
+ {
+ int rc = zmq_msg_close(&msg);
+ if (rc != 0)
+ throw error_t();
+ rc = zmq_msg_init_data(&msg, data_, size_, ffn_, hint_);
+ if (rc != 0)
+ throw error_t();
+ }
+
+ ZMQ_DEPRECATED("from 4.3.1, use move taking non-const reference instead")
+ void move(message_t const *msg_)
+ {
+ int rc = zmq_msg_move(&msg, const_cast(msg_->handle()));
+ if (rc != 0)
+ throw error_t();
+ }
+
+ void move(message_t &msg_)
+ {
+ int rc = zmq_msg_move(&msg, msg_.handle());
+ if (rc != 0)
+ throw error_t();
+ }
+
+ ZMQ_DEPRECATED("from 4.3.1, use copy taking non-const reference instead")
+ void copy(message_t const *msg_)
+ {
+ int rc = zmq_msg_copy(&msg, const_cast(msg_->handle()));
+ if (rc != 0)
+ throw error_t();
+ }
+
+ void copy(message_t &msg_)
+ {
+ int rc = zmq_msg_copy(&msg, msg_.handle());
+ if (rc != 0)
+ throw error_t();
+ }
+
+ bool more() const ZMQ_NOTHROW
+ {
+ int rc = zmq_msg_more(const_cast(&msg));
+ return rc != 0;
+ }
+
+ void *data() ZMQ_NOTHROW { return zmq_msg_data(&msg); }
+
+ const void *data() const ZMQ_NOTHROW
+ {
+ return zmq_msg_data(const_cast(&msg));
+ }
+
+ size_t size() const ZMQ_NOTHROW
+ {
+ return zmq_msg_size(const_cast(&msg));
+ }
+
+ ZMQ_NODISCARD bool empty() const ZMQ_NOTHROW { return size() == 0u; }
+
+ template T *data() ZMQ_NOTHROW { return static_cast(data()); }
+
+ template T const *data() const ZMQ_NOTHROW
+ {
+ return static_cast(data());
+ }
+
+ ZMQ_DEPRECATED("from 4.3.0, use operator== instead")
+ bool equal(const message_t *other) const ZMQ_NOTHROW { return *this == *other; }
+
+ bool operator==(const message_t &other) const ZMQ_NOTHROW
+ {
+ const size_t my_size = size();
+ return my_size == other.size() && 0 == memcmp(data(), other.data(), my_size);
+ }
+
+ bool operator!=(const message_t &other) const ZMQ_NOTHROW
+ {
+ return !(*this == other);
+ }
+
+#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(3, 2, 0)
+ int get(int property_)
+ {
+ int value = zmq_msg_get(&msg, property_);
+ if (value == -1)
+ throw error_t();
+ return value;
+ }
+#endif
+
+#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 1, 0)
+ const char *gets(const char *property_)
+ {
+ const char *value = zmq_msg_gets(&msg, property_);
+ if (value == ZMQ_NULLPTR)
+ throw error_t();
+ return value;
+ }
+#endif
+
+#if defined(ZMQ_BUILD_DRAFT_API) && ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 0)
+ uint32_t routing_id() const
+ {
+ return zmq_msg_routing_id(const_cast(&msg));
+ }
+
+ void set_routing_id(uint32_t routing_id)
+ {
+ int rc = zmq_msg_set_routing_id(&msg, routing_id);
+ if (rc != 0)
+ throw error_t();
+ }
+
+ const char *group() const
+ {
+ return zmq_msg_group(const_cast(&msg));
+ }
+
+ void set_group(const char *group)
+ {
+ int rc = zmq_msg_set_group(&msg, group);
+ if (rc != 0)
+ throw error_t();
+ }
+#endif
+
+ // interpret message content as a string
+ std::string to_string() const
+ {
+ return std::string(static_cast(data()), size());
+ }
+#if CPPZMQ_HAS_STRING_VIEW
+ // interpret message content as a string
+ std::string_view to_string_view() const noexcept
+ {
+ return std::string_view(static_cast(data()), size());
+ }
+#endif
+
+ /** Dump content to string for debugging.
+ * Ascii chars are readable, the rest is printed as hex.
+ * Probably ridiculously slow.
+ * Use to_string() or to_string_view() for
+ * interpreting the message as a string.
+ */
+ std::string str() const
+ {
+ // Partly mutuated from the same method in zmq::multipart_t
+ std::stringstream os;
+
+ const unsigned char *msg_data = this->data();
+ unsigned char byte;
+ size_t size = this->size();
+ int is_ascii[2] = {0, 0};
+
+ os << "zmq::message_t [size " << std::dec << std::setw(3)
+ << std::setfill('0') << size << "] (";
+ // Totally arbitrary
+ if (size >= 1000) {
+ os << "... too big to print)";
+ } else {
+ while (size--) {
+ byte = *msg_data++;
+
+ is_ascii[1] = (byte >= 32 && byte < 127);
+ if (is_ascii[1] != is_ascii[0])
+ os << " "; // Separate text/non text
+
+ if (is_ascii[1]) {
+ os << byte;
+ } else {
+ os << std::hex << std::uppercase << std::setw(2)
+ << std::setfill('0') << static_cast(byte);
+ }
+ is_ascii[0] = is_ascii[1];
+ }
+ os << ")";
+ }
+ return os.str();
+ }
+
+ void swap(message_t &other) ZMQ_NOTHROW
+ {
+ // this assumes zmq::msg_t from libzmq is trivially relocatable
+ std::swap(msg, other.msg);
+ }
+
+ ZMQ_NODISCARD zmq_msg_t *handle() ZMQ_NOTHROW { return &msg; }
+ ZMQ_NODISCARD const zmq_msg_t *handle() const ZMQ_NOTHROW { return &msg; }
+
+ private:
+ // The underlying message
+ zmq_msg_t msg;
+
+ // Disable implicit message copying, so that users won't use shared
+ // messages (less efficient) without being aware of the fact.
+ message_t(const message_t &) ZMQ_DELETED_FUNCTION;
+ void operator=(const message_t &) ZMQ_DELETED_FUNCTION;
+};
+
+inline void swap(message_t &a, message_t &b) ZMQ_NOTHROW
+{
+ a.swap(b);
+}
+
+#ifdef ZMQ_CPP11
+enum class ctxopt
+{
+#ifdef ZMQ_BLOCKY
+ blocky = ZMQ_BLOCKY,
+#endif
+#ifdef ZMQ_IO_THREADS
+ io_threads = ZMQ_IO_THREADS,
+#endif
+#ifdef ZMQ_THREAD_SCHED_POLICY
+ thread_sched_policy = ZMQ_THREAD_SCHED_POLICY,
+#endif
+#ifdef ZMQ_THREAD_PRIORITY
+ thread_priority = ZMQ_THREAD_PRIORITY,
+#endif
+#ifdef ZMQ_THREAD_AFFINITY_CPU_ADD
+ thread_affinity_cpu_add = ZMQ_THREAD_AFFINITY_CPU_ADD,
+#endif
+#ifdef ZMQ_THREAD_AFFINITY_CPU_REMOVE
+ thread_affinity_cpu_remove = ZMQ_THREAD_AFFINITY_CPU_REMOVE,
+#endif
+#ifdef ZMQ_THREAD_NAME_PREFIX
+ thread_name_prefix = ZMQ_THREAD_NAME_PREFIX,
+#endif
+#ifdef ZMQ_MAX_MSGSZ
+ max_msgsz = ZMQ_MAX_MSGSZ,
+#endif
+#ifdef ZMQ_ZERO_COPY_RECV
+ zero_copy_recv = ZMQ_ZERO_COPY_RECV,
+#endif
+#ifdef ZMQ_MAX_SOCKETS
+ max_sockets = ZMQ_MAX_SOCKETS,
+#endif
+#ifdef ZMQ_SOCKET_LIMIT
+ socket_limit = ZMQ_SOCKET_LIMIT,
+#endif
+#ifdef ZMQ_IPV6
+ ipv6 = ZMQ_IPV6,
+#endif
+#ifdef ZMQ_MSG_T_SIZE
+ msg_t_size = ZMQ_MSG_T_SIZE
+#endif
+};
+#endif
+
+class context_t
+{
+ public:
+ context_t()
+ {
+ ptr = zmq_ctx_new();
+ if (ptr == ZMQ_NULLPTR)
+ throw error_t();
+ }
+
+
+ explicit context_t(int io_threads_, int max_sockets_ = ZMQ_MAX_SOCKETS_DFLT)
+ {
+ ptr = zmq_ctx_new();
+ if (ptr == ZMQ_NULLPTR)
+ throw error_t();
+
+ int rc = zmq_ctx_set(ptr, ZMQ_IO_THREADS, io_threads_);
+ ZMQ_ASSERT(rc == 0);
+
+ rc = zmq_ctx_set(ptr, ZMQ_MAX_SOCKETS, max_sockets_);
+ ZMQ_ASSERT(rc == 0);
+ }
+
+#ifdef ZMQ_HAS_RVALUE_REFS
+ context_t(context_t &&rhs) ZMQ_NOTHROW : ptr(rhs.ptr) { rhs.ptr = ZMQ_NULLPTR; }
+ context_t &operator=(context_t &&rhs) ZMQ_NOTHROW
+ {
+ close();
+ std::swap(ptr, rhs.ptr);
+ return *this;
+ }
+#endif
+
+ ~context_t() ZMQ_NOTHROW { close(); }
+
+ ZMQ_CPP11_DEPRECATED("from 4.7.0, use set taking zmq::ctxopt instead")
+ int setctxopt(int option_, int optval_)
+ {
+ int rc = zmq_ctx_set(ptr, option_, optval_);
+ ZMQ_ASSERT(rc == 0);
+ return rc;
+ }
+
+ ZMQ_CPP11_DEPRECATED("from 4.7.0, use get taking zmq::ctxopt instead")
+ int getctxopt(int option_) { return zmq_ctx_get(ptr, option_); }
+
+#ifdef ZMQ_CPP11
+ void set(ctxopt option, int optval)
+ {
+ int rc = zmq_ctx_set(ptr, static_cast(option), optval);
+ if (rc == -1)
+ throw error_t();
+ }
+
+ ZMQ_NODISCARD int get(ctxopt option)
+ {
+ int rc = zmq_ctx_get(ptr, static_cast(option));
+ // some options have a default value of -1
+ // which is unfortunate, and may result in errors
+ // that don't make sense
+ if (rc == -1)
+ throw error_t();
+ return rc;
+ }
+#endif
+
+ // Terminates context (see also shutdown()).
+ void close() ZMQ_NOTHROW
+ {
+ if (ptr == ZMQ_NULLPTR)
+ return;
+
+ int rc;
+ do {
+ rc = zmq_ctx_term(ptr);
+ } while (rc == -1 && errno == EINTR);
+
+ ZMQ_ASSERT(rc == 0);
+ ptr = ZMQ_NULLPTR;
+ }
+
+ // Shutdown context in preparation for termination (close()).
+ // Causes all blocking socket operations and any further
+ // socket operations to return with ETERM.
+ void shutdown() ZMQ_NOTHROW
+ {
+ if (ptr == ZMQ_NULLPTR)
+ return;
+ int rc = zmq_ctx_shutdown(ptr);
+ ZMQ_ASSERT(rc == 0);
+ }
+
+ // 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.
+ ZMQ_EXPLICIT operator void *() ZMQ_NOTHROW { return ptr; }
+
+ ZMQ_EXPLICIT operator void const *() const ZMQ_NOTHROW { return ptr; }
+
+ ZMQ_NODISCARD void *handle() ZMQ_NOTHROW { return ptr; }
+
+ ZMQ_DEPRECATED("from 4.7.0, use handle() != nullptr instead")
+ operator bool() const ZMQ_NOTHROW { return ptr != ZMQ_NULLPTR; }
+
+ void swap(context_t &other) ZMQ_NOTHROW { std::swap(ptr, other.ptr); }
+
+ private:
+ void *ptr;
+
+ context_t(const context_t &) ZMQ_DELETED_FUNCTION;
+ void operator=(const context_t &) ZMQ_DELETED_FUNCTION;
+};
+
+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;
+ }
+};
+
+#if CPPZMQ_HAS_OPTIONAL
+
+using send_result_t = std::optional;
+using recv_result_t = std::optional;
+using recv_buffer_result_t = std::optional;
+
+#else
+
+namespace detail
+{
+// A C++11 type emulating the most basic
+// operations of std::optional for trivial types
+template class trivial_optional
+{
+ public:
+ static_assert(std::is_trivial::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};
+};
+} // namespace detail
+
+using send_result_t = detail::trivial_optional;
+using recv_result_t = detail::trivial_optional;
+using recv_buffer_result_t = detail::trivial_optional;
+
+#endif
+
+namespace detail
+{
+template constexpr T enum_bit_or(T a, T b) noexcept
+{
+ static_assert(std::is_enum::value, "must be enum");
+ using U = typename std::underlying_type::type;
+ return static_cast(static_cast(a) | static_cast(b));
+}
+template constexpr T enum_bit_and(T a, T b) noexcept
+{
+ static_assert(std::is_enum::value, "must be enum");
+ using U = typename std::underlying_type::type;
+ return static_cast(static_cast(a) & static_cast(b));
+}
+template constexpr T enum_bit_xor(T a, T b) noexcept
+{
+ static_assert(std::is_enum::value, "must be enum");
+ using U = typename std::underlying_type::type;
+ return static_cast(static_cast(a) ^ static_cast(b));
+}
+template constexpr T enum_bit_not(T a) noexcept
+{
+ static_assert(std::is_enum::value, "must be enum");
+ using U = typename std::underlying_type::type;
+ return static_cast(~static_cast(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_EXTENDED_CONSTEXPR
+ 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(_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(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_EXTENDED_CONSTEXPR
+ 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(_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(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 struct is_buffer
+{
+ static constexpr bool value =
+ std::is_same::value || std::is_same::value;
+};
+
+template 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 =
+ ZMQ_IS_TRIVIALLY_COPYABLE(T) && std::is_standard_layout::value;
+};
+
+template constexpr auto seq_size(const C &c) noexcept -> decltype(c.size())
+{
+ return c.size();
+}
+template
+constexpr size_t seq_size(const T (&/*array*/)[N]) noexcept
+{
+ return N;
+}
+
+template
+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::type>::type;
+ static_assert(detail::is_pod_like::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
+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::type>::type;
+ static_assert(detail::is_pod_like::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 mutable_buffer buffer(T (&data)[N]) noexcept
+{
+ return detail::buffer_contiguous_sequence(data);
+}
+template
+mutable_buffer buffer(T (&data)[N], size_t n_bytes) noexcept
+{
+ return detail::buffer_contiguous_sequence(data, n_bytes);
+}
+template const_buffer buffer(const T (&data)[N]) noexcept
+{
+ return detail::buffer_contiguous_sequence(data);
+}
+template
+const_buffer buffer(const T (&data)[N], size_t n_bytes) noexcept
+{
+ return detail::buffer_contiguous_sequence(data, n_bytes);
+}
+// std::array
+template mutable_buffer buffer(std::array &data) noexcept
+{
+ return detail::buffer_contiguous_sequence(data);
+}
+template
+mutable_buffer buffer(std::array &data, size_t n_bytes) noexcept
+{
+ return detail::buffer_contiguous_sequence(data, n_bytes);
+}
+template
+const_buffer buffer(std::array &data) noexcept
+{
+ return detail::buffer_contiguous_sequence(data);
+}
+template
+const_buffer buffer(std::array &data, size_t n_bytes) noexcept
+{
+ return detail::buffer_contiguous_sequence(data, n_bytes);
+}
+template
+const_buffer buffer(const std::array &data) noexcept
+{
+ return detail::buffer_contiguous_sequence(data);
+}
+template
+const_buffer buffer(const std::array &data, size_t n_bytes) noexcept
+{
+ return detail::buffer_contiguous_sequence(data, n_bytes);
+}
+// std::vector
+template
+mutable_buffer buffer(std::vector &data) noexcept
+{
+ return detail::buffer_contiguous_sequence(data);
+}
+template
+mutable_buffer buffer(std::vector &data, size_t n_bytes) noexcept
+{
+ return detail::buffer_contiguous_sequence(data, n_bytes);
+}
+template
+const_buffer buffer(const std::vector &data) noexcept
+{
+ return detail::buffer_contiguous_sequence(data);
+}
+template
+const_buffer buffer(const std::vector &data, size_t n_bytes) noexcept
+{
+ return detail::buffer_contiguous_sequence(data, n_bytes);
+}
+// std::basic_string
+template
+mutable_buffer buffer(std::basic_string &data) noexcept
+{
+ return detail::buffer_contiguous_sequence(data);
+}
+template
+mutable_buffer buffer(std::basic_string &data,
+ size_t n_bytes) noexcept
+{
+ return detail::buffer_contiguous_sequence(data, n_bytes);
+}
+template
+const_buffer buffer(const std::basic_string &data) noexcept
+{
+ return detail::buffer_contiguous_sequence(data);
+}
+template
+const_buffer buffer(const std::basic_string &data,
+ size_t n_bytes) noexcept
+{
+ return detail::buffer_contiguous_sequence(data, n_bytes);
+}
+
+#if CPPZMQ_HAS_STRING_VIEW
+// std::basic_string_view
+template
+const_buffer buffer(std::basic_string_view data) noexcept
+{
+ return detail::buffer_contiguous_sequence(data);
+}
+template
+const_buffer buffer(std::basic_string_view data, size_t n_bytes) noexcept
+{
+ return detail::buffer_contiguous_sequence(data, n_bytes);
+}
+#endif
+
+// Buffer for a string literal (null terminated)
+// where the buffer size excludes the terminating character.
+// Equivalent to zmq::buffer(std::string_view("...")).
+template
+constexpr const_buffer str_buffer(const Char (&data)[N]) noexcept
+{
+ static_assert(detail::is_pod_like::value, "Char must be POD");
+#ifdef ZMQ_EXTENDED_CONSTEXPR
+ assert(data[N - 1] == Char{0});
+#endif
+ return const_buffer(static_cast(data), (N - 1) * sizeof(Char));
+}
+
+namespace literals
+{
+constexpr const_buffer operator"" _zbuf(const char *str, size_t len) noexcept
+{
+ return const_buffer(str, len * sizeof(char));
+}
+constexpr const_buffer operator"" _zbuf(const wchar_t *str, size_t len) noexcept
+{
+ return const_buffer(str, len * sizeof(wchar_t));
+}
+constexpr const_buffer operator"" _zbuf(const char16_t *str, size_t len) noexcept
+{
+ return const_buffer(str, len * sizeof(char16_t));
+}
+constexpr const_buffer operator"" _zbuf(const char32_t *str, size_t len) noexcept
+{
+ return const_buffer(str, len * sizeof(char32_t));
+}
+}
+
+namespace sockopt
+{
+// There are two types of options,
+// integral type with known compiler time size (int, bool, int64_t, uint64_t)
+// and arrays with dynamic size (strings, binary data).
+
+// BoolUnit: if true accepts values of type bool (but passed as T into libzmq)
+template struct integral_option
+{
+};
+
+// NullTerm:
+// 0: binary data
+// 1: null-terminated string (`getsockopt` size includes null)
+// 2: binary (size 32) or Z85 encoder string of size 41 (null included)
+template struct array_option
+{
+};
+
+#define ZMQ_DEFINE_INTEGRAL_OPT(OPT, NAME, TYPE) \
+ using NAME##_t = integral_option; \
+ ZMQ_INLINE_VAR ZMQ_CONSTEXPR_VAR NAME##_t NAME {}
+#define ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(OPT, NAME, TYPE) \
+ using NAME##_t = integral_option; \
+ ZMQ_INLINE_VAR ZMQ_CONSTEXPR_VAR NAME##_t NAME {}
+#define ZMQ_DEFINE_ARRAY_OPT(OPT, NAME) \
+ using NAME##_t = array_option; \
+ ZMQ_INLINE_VAR ZMQ_CONSTEXPR_VAR NAME##_t NAME {}
+#define ZMQ_DEFINE_ARRAY_OPT_BINARY(OPT, NAME) \
+ using NAME##_t = array_option; \
+ ZMQ_INLINE_VAR ZMQ_CONSTEXPR_VAR NAME##_t NAME {}
+#define ZMQ_DEFINE_ARRAY_OPT_BIN_OR_Z85(OPT, NAME) \
+ using NAME##_t = array_option; \
+ ZMQ_INLINE_VAR ZMQ_CONSTEXPR_VAR NAME##_t NAME {}
+
+// deprecated, use zmq::fd_t
+using cppzmq_fd_t = ::zmq::fd_t;
+
+#ifdef ZMQ_AFFINITY
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_AFFINITY, affinity, uint64_t);
+#endif
+#ifdef ZMQ_BACKLOG
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_BACKLOG, backlog, int);
+#endif
+#ifdef ZMQ_BINDTODEVICE
+ZMQ_DEFINE_ARRAY_OPT_BINARY(ZMQ_BINDTODEVICE, bindtodevice);
+#endif
+#ifdef ZMQ_CONFLATE
+ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_CONFLATE, conflate, int);
+#endif
+#ifdef ZMQ_CONNECT_ROUTING_ID
+ZMQ_DEFINE_ARRAY_OPT(ZMQ_CONNECT_ROUTING_ID, connect_routing_id);
+#endif
+#ifdef ZMQ_CONNECT_TIMEOUT
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_CONNECT_TIMEOUT, connect_timeout, int);
+#endif
+#ifdef ZMQ_CURVE_PUBLICKEY
+ZMQ_DEFINE_ARRAY_OPT_BIN_OR_Z85(ZMQ_CURVE_PUBLICKEY, curve_publickey);
+#endif
+#ifdef ZMQ_CURVE_SECRETKEY
+ZMQ_DEFINE_ARRAY_OPT_BIN_OR_Z85(ZMQ_CURVE_SECRETKEY, curve_secretkey);
+#endif
+#ifdef ZMQ_CURVE_SERVER
+ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_CURVE_SERVER, curve_server, int);
+#endif
+#ifdef ZMQ_CURVE_SERVERKEY
+ZMQ_DEFINE_ARRAY_OPT_BIN_OR_Z85(ZMQ_CURVE_SERVERKEY, curve_serverkey);
+#endif
+#ifdef ZMQ_EVENTS
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_EVENTS, events, int);
+#endif
+#ifdef ZMQ_FD
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_FD, fd, ::zmq::fd_t);
+#endif
+#ifdef ZMQ_GSSAPI_PLAINTEXT
+ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_GSSAPI_PLAINTEXT, gssapi_plaintext, int);
+#endif
+#ifdef ZMQ_GSSAPI_SERVER
+ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_GSSAPI_SERVER, gssapi_server, int);
+#endif
+#ifdef ZMQ_GSSAPI_SERVICE_PRINCIPAL
+ZMQ_DEFINE_ARRAY_OPT(ZMQ_GSSAPI_SERVICE_PRINCIPAL, gssapi_service_principal);
+#endif
+#ifdef ZMQ_GSSAPI_SERVICE_PRINCIPAL_NAMETYPE
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_GSSAPI_SERVICE_PRINCIPAL_NAMETYPE,
+ gssapi_service_principal_nametype,
+ int);
+#endif
+#ifdef ZMQ_GSSAPI_PRINCIPAL
+ZMQ_DEFINE_ARRAY_OPT(ZMQ_GSSAPI_PRINCIPAL, gssapi_principal);
+#endif
+#ifdef ZMQ_GSSAPI_PRINCIPAL_NAMETYPE
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_GSSAPI_PRINCIPAL_NAMETYPE,
+ gssapi_principal_nametype,
+ int);
+#endif
+#ifdef ZMQ_HANDSHAKE_IVL
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_HANDSHAKE_IVL, handshake_ivl, int);
+#endif
+#ifdef ZMQ_HEARTBEAT_IVL
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_HEARTBEAT_IVL, heartbeat_ivl, int);
+#endif
+#ifdef ZMQ_HEARTBEAT_TIMEOUT
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_HEARTBEAT_TIMEOUT, heartbeat_timeout, int);
+#endif
+#ifdef ZMQ_HEARTBEAT_TTL
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_HEARTBEAT_TTL, heartbeat_ttl, int);
+#endif
+#ifdef ZMQ_IMMEDIATE
+ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_IMMEDIATE, immediate, int);
+#endif
+#ifdef ZMQ_INVERT_MATCHING
+ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_INVERT_MATCHING, invert_matching, int);
+#endif
+#ifdef ZMQ_IPV6
+ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_IPV6, ipv6, int);
+#endif
+#ifdef ZMQ_LAST_ENDPOINT
+ZMQ_DEFINE_ARRAY_OPT(ZMQ_LAST_ENDPOINT, last_endpoint);
+#endif
+#ifdef ZMQ_LINGER
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_LINGER, linger, int);
+#endif
+#ifdef ZMQ_MAXMSGSIZE
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_MAXMSGSIZE, maxmsgsize, int64_t);
+#endif
+#ifdef ZMQ_MECHANISM
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_MECHANISM, mechanism, int);
+#endif
+#ifdef ZMQ_METADATA
+ZMQ_DEFINE_ARRAY_OPT(ZMQ_METADATA, metadata);
+#endif
+#ifdef ZMQ_MULTICAST_HOPS
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_MULTICAST_HOPS, multicast_hops, int);
+#endif
+#ifdef ZMQ_MULTICAST_LOOP
+ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_MULTICAST_LOOP, multicast_loop, int);
+#endif
+#ifdef ZMQ_MULTICAST_MAXTPDU
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_MULTICAST_MAXTPDU, multicast_maxtpdu, int);
+#endif
+#ifdef ZMQ_PLAIN_SERVER
+ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_PLAIN_SERVER, plain_server, int);
+#endif
+#ifdef ZMQ_PLAIN_PASSWORD
+ZMQ_DEFINE_ARRAY_OPT(ZMQ_PLAIN_PASSWORD, plain_password);
+#endif
+#ifdef ZMQ_PLAIN_USERNAME
+ZMQ_DEFINE_ARRAY_OPT(ZMQ_PLAIN_USERNAME, plain_username);
+#endif
+#ifdef ZMQ_USE_FD
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_USE_FD, use_fd, int);
+#endif
+#ifdef ZMQ_PROBE_ROUTER
+ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_PROBE_ROUTER, probe_router, int);
+#endif
+#ifdef ZMQ_RATE
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_RATE, rate, int);
+#endif
+#ifdef ZMQ_RCVBUF
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_RCVBUF, rcvbuf, int);
+#endif
+#ifdef ZMQ_RCVHWM
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_RCVHWM, rcvhwm, int);
+#endif
+#ifdef ZMQ_RCVMORE
+ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_RCVMORE, rcvmore, int);
+#endif
+#ifdef ZMQ_RCVTIMEO
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_RCVTIMEO, rcvtimeo, int);
+#endif
+#ifdef ZMQ_RECONNECT_IVL
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_RECONNECT_IVL, reconnect_ivl, int);
+#endif
+#ifdef ZMQ_RECONNECT_IVL_MAX
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_RECONNECT_IVL_MAX, reconnect_ivl_max, int);
+#endif
+#ifdef ZMQ_RECOVERY_IVL
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_RECOVERY_IVL, recovery_ivl, int);
+#endif
+#ifdef ZMQ_REQ_CORRELATE
+ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_REQ_CORRELATE, req_correlate, int);
+#endif
+#ifdef ZMQ_REQ_RELAXED
+ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_REQ_RELAXED, req_relaxed, int);
+#endif
+#ifdef ZMQ_ROUTER_HANDOVER
+ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_ROUTER_HANDOVER, router_handover, int);
+#endif
+#ifdef ZMQ_ROUTER_MANDATORY
+ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_ROUTER_MANDATORY, router_mandatory, int);
+#endif
+#ifdef ZMQ_ROUTER_NOTIFY
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_ROUTER_NOTIFY, router_notify, int);
+#endif
+#ifdef ZMQ_ROUTING_ID
+ZMQ_DEFINE_ARRAY_OPT_BINARY(ZMQ_ROUTING_ID, routing_id);
+#endif
+#ifdef ZMQ_SNDBUF
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_SNDBUF, sndbuf, int);
+#endif
+#ifdef ZMQ_SNDHWM
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_SNDHWM, sndhwm, int);
+#endif
+#ifdef ZMQ_SNDTIMEO
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_SNDTIMEO, sndtimeo, int);
+#endif
+#ifdef ZMQ_SOCKS_PROXY
+ZMQ_DEFINE_ARRAY_OPT(ZMQ_SOCKS_PROXY, socks_proxy);
+#endif
+#ifdef ZMQ_STREAM_NOTIFY
+ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_STREAM_NOTIFY, stream_notify, int);
+#endif
+#ifdef ZMQ_SUBSCRIBE
+ZMQ_DEFINE_ARRAY_OPT(ZMQ_SUBSCRIBE, subscribe);
+#endif
+#ifdef ZMQ_TCP_KEEPALIVE
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_TCP_KEEPALIVE, tcp_keepalive, int);
+#endif
+#ifdef ZMQ_TCP_KEEPALIVE_CNT
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_TCP_KEEPALIVE_CNT, tcp_keepalive_cnt, int);
+#endif
+#ifdef ZMQ_TCP_KEEPALIVE_IDLE
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_TCP_KEEPALIVE_IDLE, tcp_keepalive_idle, int);
+#endif
+#ifdef ZMQ_TCP_KEEPALIVE_INTVL
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_TCP_KEEPALIVE_INTVL, tcp_keepalive_intvl, int);
+#endif
+#ifdef ZMQ_TCP_MAXRT
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_TCP_MAXRT, tcp_maxrt, int);
+#endif
+#ifdef ZMQ_THREAD_SAFE
+ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_THREAD_SAFE, thread_safe, int);
+#endif
+#ifdef ZMQ_TOS
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_TOS, tos, int);
+#endif
+#ifdef ZMQ_TYPE
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_TYPE, type, int);
+#endif
+#ifdef ZMQ_UNSUBSCRIBE
+ZMQ_DEFINE_ARRAY_OPT(ZMQ_UNSUBSCRIBE, unsubscribe);
+#endif
+#ifdef ZMQ_VMCI_BUFFER_SIZE
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_VMCI_BUFFER_SIZE, vmci_buffer_size, uint64_t);
+#endif
+#ifdef ZMQ_VMCI_BUFFER_MIN_SIZE
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_VMCI_BUFFER_MIN_SIZE, vmci_buffer_min_size, uint64_t);
+#endif
+#ifdef ZMQ_VMCI_BUFFER_MAX_SIZE
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_VMCI_BUFFER_MAX_SIZE, vmci_buffer_max_size, uint64_t);
+#endif
+#ifdef ZMQ_VMCI_CONNECT_TIMEOUT
+ZMQ_DEFINE_INTEGRAL_OPT(ZMQ_VMCI_CONNECT_TIMEOUT, vmci_connect_timeout, int);
+#endif
+#ifdef ZMQ_XPUB_VERBOSE
+ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_XPUB_VERBOSE, xpub_verbose, int);
+#endif
+#ifdef ZMQ_XPUB_VERBOSER
+ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_XPUB_VERBOSER, xpub_verboser, int);
+#endif
+#ifdef ZMQ_XPUB_MANUAL
+ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_XPUB_MANUAL, xpub_manual, int);
+#endif
+#ifdef ZMQ_XPUB_NODROP
+ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_XPUB_NODROP, xpub_nodrop, int);
+#endif
+#ifdef ZMQ_XPUB_WELCOME_MSG
+ZMQ_DEFINE_ARRAY_OPT(ZMQ_XPUB_WELCOME_MSG, xpub_welcome_msg);
+#endif
+#ifdef ZMQ_ZAP_ENFORCE_DOMAIN
+ZMQ_DEFINE_INTEGRAL_BOOL_UNIT_OPT(ZMQ_ZAP_ENFORCE_DOMAIN, zap_enforce_domain, int);
+#endif
+#ifdef ZMQ_ZAP_DOMAIN
+ZMQ_DEFINE_ARRAY_OPT(ZMQ_ZAP_DOMAIN, zap_domain);
+#endif
+
+} // namespace sockopt
+#endif // ZMQ_CPP11
+
+
+namespace detail
+{
+class socket_base
+{
+ public:
+ socket_base() ZMQ_NOTHROW : _handle(ZMQ_NULLPTR) {}
+ ZMQ_EXPLICIT socket_base(void *handle) ZMQ_NOTHROW : _handle(handle) {}
+
+ template
+ ZMQ_CPP11_DEPRECATED("from 4.7.0, use `set` taking option from zmq::sockopt")
+ void setsockopt(int option_, T const &optval)
+ {
+ setsockopt(option_, &optval, sizeof(T));
+ }
+
+ ZMQ_CPP11_DEPRECATED("from 4.7.0, use `set` taking option from zmq::sockopt")
+ void setsockopt(int option_, const void *optval_, size_t optvallen_)
+ {
+ int rc = zmq_setsockopt(_handle, option_, optval_, optvallen_);
+ if (rc != 0)
+ throw error_t();
+ }
+
+ ZMQ_CPP11_DEPRECATED("from 4.7.0, use `get` taking option from zmq::sockopt")
+ void getsockopt(int option_, void *optval_, size_t *optvallen_) const
+ {
+ int rc = zmq_getsockopt(_handle, option_, optval_, optvallen_);
+ if (rc != 0)
+ throw error_t();
+ }
+
+ template
+ ZMQ_CPP11_DEPRECATED("from 4.7.0, use `get` taking option from zmq::sockopt")
+ T getsockopt(int option_) const
+ {
+ T optval;
+ size_t optlen = sizeof(T);
+ getsockopt(option_, &optval, &optlen);
+ return optval;
+ }
+
+#ifdef ZMQ_CPP11
+ // Set integral socket option, e.g.
+ // `socket.set(zmq::sockopt::linger, 0)`
+ template
+ void set(sockopt::integral_option, const T &val)
+ {
+ static_assert(std::is_integral::value, "T must be integral");
+ set_option(Opt, &val, sizeof val);
+ }
+
+ // Set integral socket option from boolean, e.g.
+ // `socket.set(zmq::sockopt::immediate, false)`
+ template
+ void set(sockopt::integral_option, bool val)
+ {
+ static_assert(std::is_integral::value, "T must be integral");
+ T rep_val = val;
+ set_option(Opt, &rep_val, sizeof rep_val);
+ }
+
+ // Set array socket option, e.g.
+ // `socket.set(zmq::sockopt::plain_username, "foo123")`
+ template
+ void set(sockopt::array_option, const char *buf)
+ {
+ set_option(Opt, buf, std::strlen(buf));
+ }
+
+ // Set array socket option, e.g.
+ // `socket.set(zmq::sockopt::routing_id, zmq::buffer(id))`
+ template
+ void set(sockopt::array_option, const_buffer buf)
+ {
+ set_option(Opt, buf.data(), buf.size());
+ }
+
+ // Set array socket option, e.g.
+ // `socket.set(zmq::sockopt::routing_id, id_str)`
+ template
+ void set(sockopt::array_option, const std::string &buf)
+ {
+ set_option(Opt, buf.data(), buf.size());
+ }
+
+#if CPPZMQ_HAS_STRING_VIEW
+ // Set array socket option, e.g.
+ // `socket.set(zmq::sockopt::routing_id, id_str)`
+ template
+ void set(sockopt::array_option, std::string_view buf)
+ {
+ set_option(Opt, buf.data(), buf.size());
+ }
+#endif
+
+ // Get scalar socket option, e.g.
+ // `auto opt = socket.get(zmq::sockopt::linger)`
+ template
+ ZMQ_NODISCARD T get(sockopt::integral_option) const
+ {
+ static_assert(std::is_integral::value, "T must be integral");
+ T val;
+ size_t size = sizeof val;
+ get_option(Opt, &val, &size);
+ assert(size == sizeof val);
+ return val;
+ }
+
+ // Get array socket option, writes to buf, returns option size in bytes, e.g.
+ // `size_t optsize = socket.get(zmq::sockopt::routing_id, zmq::buffer(id))`
+ template
+ ZMQ_NODISCARD size_t get(sockopt::array_option,
+ mutable_buffer buf) const
+ {
+ size_t size = buf.size();
+ get_option(Opt, buf.data(), &size);
+ return size;
+ }
+
+ // Get array socket option as string (initializes the string buffer size to init_size) e.g.
+ // `auto s = socket.get(zmq::sockopt::routing_id)`
+ // Note: removes the null character from null-terminated string options,
+ // i.e. the string size excludes the null character.
+ template
+ ZMQ_NODISCARD std::string get(sockopt::array_option,
+ size_t init_size = 1024) const
+ {
+ if ZMQ_CONSTEXPR_IF (NullTerm == 2) {
+ if (init_size == 1024) {
+ init_size = 41; // get as Z85 string
+ }
+ }
+ std::string str(init_size, '\0');
+ size_t size = get(sockopt::array_option{}, buffer(str));
+ if ZMQ_CONSTEXPR_IF (NullTerm == 1) {
+ if (size > 0) {
+ assert(str[size - 1] == '\0');
+ --size;
+ }
+ } else if ZMQ_CONSTEXPR_IF (NullTerm == 2) {
+ assert(size == 32 || size == 41);
+ if (size == 41) {
+ assert(str[size - 1] == '\0');
+ --size;
+ }
+ }
+ str.resize(size);
+ return str;
+ }
+#endif
+
+ void bind(std::string const &addr) { bind(addr.c_str()); }
+
+ void bind(const char *addr_)
+ {
+ int rc = zmq_bind(_handle, addr_);
+ if (rc != 0)
+ throw error_t();
+ }
+
+ void unbind(std::string const &addr) { unbind(addr.c_str()); }
+
+ void unbind(const char *addr_)
+ {
+ int rc = zmq_unbind(_handle, addr_);
+ if (rc != 0)
+ throw error_t();
+ }
+
+ void connect(std::string const &addr) { connect(addr.c_str()); }
+
+ void connect(const char *addr_)
+ {
+ int rc = zmq_connect(_handle, addr_);
+ if (rc != 0)
+ throw error_t();
+ }
+
+ void disconnect(std::string const &addr) { disconnect(addr.c_str()); }
+
+ void disconnect(const char *addr_)
+ {
+ int rc = zmq_disconnect(_handle, addr_);
+ if (rc != 0)
+ throw error_t();
+ }
+
+ ZMQ_DEPRECATED("from 4.7.1, use handle() != nullptr or operator bool")
+ 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)
+ {
+ int nbytes = zmq_send(_handle, buf_, len_, flags_);
+ if (nbytes >= 0)
+ return static_cast(nbytes);
+ if (zmq_errno() == EAGAIN)
+ return 0;
+ throw error_t();
+ }
+
+ ZMQ_CPP11_DEPRECATED("from 4.3.1, use send taking message_t and send_flags")
+ bool send(message_t &msg_,
+ int flags_ = 0) // default until removed
+ {
+ int nbytes = zmq_msg_send(msg_.handle(), _handle, flags_);
+ if (nbytes >= 0)
+ return true;
+ if (zmq_errno() == EAGAIN)
+ return false;
+ throw error_t();
+ }
+
+ template
+ ZMQ_CPP11_DEPRECATED(
+ "from 4.4.1, use send taking message_t or buffer (for contiguous "
+ "ranges), and send_flags")
+ bool send(T first, T last, int flags_ = 0)
+ {
+ zmq::message_t msg(first, last);
+ int nbytes = zmq_msg_send(msg.handle(), _handle, flags_);
+ if (nbytes >= 0)
+ return true;
+ if (zmq_errno() == EAGAIN)
+ return false;
+ throw error_t();
+ }
+
+#ifdef ZMQ_HAS_RVALUE_REFS
+ ZMQ_CPP11_DEPRECATED("from 4.3.1, use send taking message_t and send_flags")
+ bool send(message_t &&msg_,
+ int flags_ = 0) // default until removed
+ {
+#ifdef ZMQ_CPP11
+ return send(msg_, static_cast(flags_)).has_value();
+#else
+ return send(msg_, flags_);
+#endif
+ }
+#endif
+
+#ifdef ZMQ_CPP11
+ 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(flags));
+ if (nbytes >= 0)
+ return static_cast(nbytes);
+ if (zmq_errno() == EAGAIN)
+ return {};
+ throw error_t();
+ }
+
+ send_result_t send(message_t &msg, send_flags flags)
+ {
+ int nbytes = zmq_msg_send(msg.handle(), _handle, static_cast(flags));
+ if (nbytes >= 0)
+ return static_cast(nbytes);
+ if (zmq_errno() == EAGAIN)
+ return {};
+ throw error_t();
+ }
+
+ send_result_t send(message_t &&msg, send_flags flags)
+ {
+ return send(msg, flags);
+ }
+#endif
+
+ ZMQ_CPP11_DEPRECATED(
+ "from 4.3.1, use recv taking a mutable_buffer and recv_flags")
+ size_t recv(void *buf_, size_t len_, int flags_ = 0)
+ {
+ int nbytes = zmq_recv(_handle, buf_, len_, flags_);
+ if (nbytes >= 0)
+ return static_cast(nbytes);
+ if (zmq_errno() == EAGAIN)
+ return 0;
+ throw error_t();
+ }
+
+ ZMQ_CPP11_DEPRECATED(
+ "from 4.3.1, use recv taking a reference to message_t and recv_flags")
+ bool recv(message_t *msg_, int flags_ = 0)
+ {
+ int nbytes = zmq_msg_recv(msg_->handle(), _handle, flags_);
+ if (nbytes >= 0)
+ return true;
+ if (zmq_errno() == EAGAIN)
+ return false;
+ throw error_t();
+ }
+
+#ifdef ZMQ_CPP11
+ ZMQ_NODISCARD
+ 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(flags));
+ if (nbytes >= 0) {
+ return recv_buffer_size{
+ (std::min)(static_cast(nbytes), buf.size()),
+ static_cast(nbytes)};
+ }
+ if (zmq_errno() == EAGAIN)
+ return {};
+ throw error_t();
+ }
+
+ ZMQ_NODISCARD
+ recv_result_t recv(message_t &msg, recv_flags flags = recv_flags::none)
+ {
+ const int nbytes =
+ zmq_msg_recv(msg.handle(), _handle, static_cast(flags));
+ if (nbytes >= 0) {
+ assert(msg.size() == static_cast(nbytes));
+ return static_cast(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)
+ {
+ int rc = zmq_join(_handle, group);
+ if (rc != 0)
+ throw error_t();
+ }
+
+ void leave(const char *group)
+ {
+ int rc = zmq_leave(_handle, group);
+ if (rc != 0)
+ throw error_t();
+ }
+#endif
+
+ ZMQ_NODISCARD void *handle() ZMQ_NOTHROW { return _handle; }
+ ZMQ_NODISCARD const void *handle() const ZMQ_NOTHROW { return _handle; }
+
+ ZMQ_EXPLICIT 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; }
+
+ protected:
+ void *_handle;
+
+ private:
+ void set_option(int option_, const void *optval_, size_t optvallen_)
+ {
+ int rc = zmq_setsockopt(_handle, option_, optval_, optvallen_);
+ if (rc != 0)
+ throw error_t();
+ }
+
+ void get_option(int option_, void *optval_, size_t *optvallen_) const
+ {
+ int rc = zmq_getsockopt(_handle, option_, optval_, optvallen_);
+ if (rc != 0)
+ throw error_t();
+ }
+};
+} // namespace detail
+
+#ifdef ZMQ_CPP11
+enum class socket_type : int
+{
+ req = ZMQ_REQ,
+ rep = ZMQ_REP,
+ dealer = ZMQ_DEALER,
+ router = ZMQ_ROUTER,
+ pub = ZMQ_PUB,
+ sub = ZMQ_SUB,
+ xpub = ZMQ_XPUB,
+ xsub = ZMQ_XSUB,
+ push = ZMQ_PUSH,
+ pull = ZMQ_PULL,
+#if defined(ZMQ_BUILD_DRAFT_API) && ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 0)
+ server = ZMQ_SERVER,
+ client = ZMQ_CLIENT,
+ radio = ZMQ_RADIO,
+ dish = ZMQ_DISH,
+ gather = ZMQ_GATHER,
+ scatter = ZMQ_SCATTER,
+ dgram = ZMQ_DGRAM,
+#endif
+#if defined(ZMQ_BUILD_DRAFT_API) && ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 3, 3)
+ peer = ZMQ_PEER,
+ channel = ZMQ_CHANNEL,
+#endif
+#if ZMQ_VERSION_MAJOR >= 4
+ stream = ZMQ_STREAM,
+#endif
+ pair = ZMQ_PAIR
+};
+#endif
+
+struct from_handle_t
+{
+ struct _private
+ {
+ }; // disabling use other than with from_handle
+ ZMQ_CONSTEXPR_FN ZMQ_EXPLICIT from_handle_t(_private /*p*/) ZMQ_NOTHROW {}
+};
+
+ZMQ_CONSTEXPR_VAR from_handle_t from_handle =
+ from_handle_t(from_handle_t::_private());
+
+// A non-owning nullable reference to a socket.
+// The reference is invalidated on socket close or destruction.
+class socket_ref : public detail::socket_base
+{
+ public:
+ socket_ref() ZMQ_NOTHROW : detail::socket_base() {}
+#ifdef ZMQ_CPP11
+ socket_ref(std::nullptr_t) ZMQ_NOTHROW : detail::socket_base() {}
+#endif
+ socket_ref(from_handle_t /*fh*/, void *handle) ZMQ_NOTHROW
+ : detail::socket_base(handle)
+ {
+ }
+};
+
+#ifdef ZMQ_CPP11
+inline bool operator==(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
+{
+ return sr.handle() == nullptr;
+}
+inline bool operator!=(socket_ref sr, std::nullptr_t /*p*/) ZMQ_NOTHROW
+{
+ return !(sr == nullptr);
+}
+inline bool operator!=(std::nullptr_t /*p*/, socket_ref sr) ZMQ_NOTHROW
+{
+ return !(sr == nullptr);
+}
+#endif
+
+inline bool operator==(const detail::socket_base& a, const detail::socket_base& b) ZMQ_NOTHROW
+{
+ return std::equal_to()(a.handle(), b.handle());
+}
+inline bool operator!=(const detail::socket_base& a, const detail::socket_base& b) ZMQ_NOTHROW
+{
+ return !(a == b);
+}
+inline bool operator<(const detail::socket_base& a, const detail::socket_base& b) ZMQ_NOTHROW
+{
+ return std::less()(a.handle(), b.handle());
+}
+inline bool operator>(const detail::socket_base& a, const detail::socket_base& b) ZMQ_NOTHROW
+{
+ return b < a;
+}
+inline bool operator<=(const detail::socket_base& a, const detail::socket_base& b) ZMQ_NOTHROW
+{
+ return !(a > b);
+}
+inline bool operator>=(const detail::socket_base& a, const detail::socket_base& b) ZMQ_NOTHROW
+{
+ return !(a < b);
+}
+
+} // namespace zmq
+
+#ifdef ZMQ_CPP11
+namespace std
+{
+template<> struct hash
+{
+ size_t operator()(zmq::socket_ref sr) const ZMQ_NOTHROW
+ {
+ return hash()(sr.handle());
+ }
+};
+} // namespace std
+#endif
+
+namespace zmq
+{
+class socket_t : public detail::socket_base
+{
+ friend class monitor_t;
+
+ public:
+ socket_t() ZMQ_NOTHROW : detail::socket_base(ZMQ_NULLPTR), ctxptr(ZMQ_NULLPTR) {}
+
+ socket_t(context_t &context_, int type_) :
+ detail::socket_base(zmq_socket(context_.handle(), type_)),
+ ctxptr(context_.handle())
+ {
+ if (_handle == ZMQ_NULLPTR)
+ throw error_t();
+ }
+
+#ifdef ZMQ_CPP11
+ socket_t(context_t &context_, socket_type type_) :
+ socket_t(context_, static_cast(type_))
+ {
+ }
+#endif
+
+#ifdef ZMQ_HAS_RVALUE_REFS
+ socket_t(socket_t &&rhs) ZMQ_NOTHROW : detail::socket_base(rhs._handle),
+ ctxptr(rhs.ctxptr)
+ {
+ rhs._handle = ZMQ_NULLPTR;
+ rhs.ctxptr = ZMQ_NULLPTR;
+ }
+ socket_t &operator=(socket_t &&rhs) ZMQ_NOTHROW
+ {
+ close();
+ std::swap(_handle, rhs._handle);
+ std::swap(ctxptr, rhs.ctxptr);
+ return *this;
+ }
+#endif
+
+ ~socket_t() ZMQ_NOTHROW { close(); }
+
+ operator void *() ZMQ_NOTHROW { return _handle; }
+
+ operator void const *() const ZMQ_NOTHROW { return _handle; }
+
+ void close() ZMQ_NOTHROW
+ {
+ if (_handle == ZMQ_NULLPTR)
+ // already closed
+ return;
+ int rc = zmq_close(_handle);
+ ZMQ_ASSERT(rc == 0);
+ _handle = ZMQ_NULLPTR;
+ ctxptr = ZMQ_NULLPTR;
+ }
+
+ void swap(socket_t &other) ZMQ_NOTHROW
+ {
+ std::swap(_handle, other._handle);
+ std::swap(ctxptr, other.ctxptr);
+ }
+
+ operator socket_ref() ZMQ_NOTHROW { return socket_ref(from_handle, _handle); }
+
+ private:
+ void *ctxptr;
+
+ socket_t(const socket_t &) ZMQ_DELETED_FUNCTION;
+ void operator=(const socket_t &) ZMQ_DELETED_FUNCTION;
+
+ // used by monitor_t
+ socket_t(void *context_, int type_) :
+ detail::socket_base(zmq_socket(context_, type_)), ctxptr(context_)
+ {
+ if (_handle == ZMQ_NULLPTR)
+ throw error_t();
+ if (ctxptr == ZMQ_NULLPTR)
+ throw error_t();
+ }
+};
+
+inline void swap(socket_t &a, socket_t &b) ZMQ_NOTHROW
+{
+ a.swap(b);
+}
+
+ZMQ_DEPRECATED("from 4.3.1, use proxy taking socket_t objects")
+inline void proxy(void *frontend, void *backend, void *capture)
+{
+ int rc = zmq_proxy(frontend, backend, capture);
+ if (rc != 0)
+ throw error_t();
+}
+
+inline void
+proxy(socket_ref frontend, socket_ref backend, socket_ref capture = socket_ref())
+{
+ int rc = zmq_proxy(frontend.handle(), backend.handle(), capture.handle());
+ if (rc != 0)
+ throw error_t();
+}
+
+#ifdef ZMQ_HAS_PROXY_STEERABLE
+ZMQ_DEPRECATED("from 4.3.1, use proxy_steerable taking socket_t objects")
+inline void
+proxy_steerable(void *frontend, void *backend, void *capture, void *control)
+{
+ int rc = zmq_proxy_steerable(frontend, backend, capture, control);
+ if (rc != 0)
+ throw error_t();
+}
+
+inline void proxy_steerable(socket_ref frontend,
+ socket_ref backend,
+ socket_ref capture,
+ socket_ref control)
+{
+ int rc = zmq_proxy_steerable(frontend.handle(), backend.handle(),
+ capture.handle(), control.handle());
+ if (rc != 0)
+ throw error_t();
+}
+#endif
+
+class monitor_t
+{
+ public:
+ monitor_t() : _socket(), _monitor_socket() {}
+
+ virtual ~monitor_t() { close(); }
+
+#ifdef ZMQ_HAS_RVALUE_REFS
+ monitor_t(monitor_t &&rhs) ZMQ_NOTHROW : _socket(), _monitor_socket()
+ {
+ std::swap(_socket, rhs._socket);
+ std::swap(_monitor_socket, rhs._monitor_socket);
+ }
+
+ monitor_t &operator=(monitor_t &&rhs) ZMQ_NOTHROW
+ {
+ close();
+ _socket = socket_ref();
+ std::swap(_socket, rhs._socket);
+ std::swap(_monitor_socket, rhs._monitor_socket);
+ return *this;
+ }
+#endif
+
+
+ void
+ monitor(socket_t &socket, std::string const &addr, int events = ZMQ_EVENT_ALL)
+ {
+ monitor(socket, addr.c_str(), events);
+ }
+
+ void monitor(socket_t &socket, const char *addr_, int events = ZMQ_EVENT_ALL)
+ {
+ init(socket, addr_, events);
+ while (true) {
+ check_event(-1);
+ }
+ }
+
+ void init(socket_t &socket, std::string const &addr, int events = ZMQ_EVENT_ALL)
+ {
+ init(socket, addr.c_str(), events);
+ }
+
+ void init(socket_t &socket, const char *addr_, int events = ZMQ_EVENT_ALL)
+ {
+ int rc = zmq_socket_monitor(socket.handle(), addr_, events);
+ if (rc != 0)
+ throw error_t();
+
+ _socket = socket;
+ _monitor_socket = socket_t(socket.ctxptr, ZMQ_PAIR);
+ _monitor_socket.connect(addr_);
+
+ on_monitor_started();
+ }
+
+ bool check_event(int timeout = 0)
+ {
+ assert(_monitor_socket);
+
+ zmq::message_t eventMsg;
+
+ zmq::pollitem_t items[] = {
+ {_monitor_socket.handle(), 0, ZMQ_POLLIN, 0},
+ };
+
+ #ifdef ZMQ_CPP11
+ zmq::poll(&items[0], 1, std::chrono::milliseconds(timeout));
+ #else
+ zmq::poll(&items[0], 1, timeout);
+ #endif
+
+ if (items[0].revents & ZMQ_POLLIN) {
+ int rc = zmq_msg_recv(eventMsg.handle(), _monitor_socket.handle(), 0);
+ if (rc == -1 && zmq_errno() == ETERM)
+ return false;
+ assert(rc != -1);
+
+ } else {
+ return false;
+ }
+
+#if ZMQ_VERSION_MAJOR >= 4
+ const char *data = static_cast(eventMsg.data());
+ zmq_event_t msgEvent;
+ memcpy(&msgEvent.event, data, sizeof(uint16_t));
+ data += sizeof(uint16_t);
+ memcpy(&msgEvent.value, data, sizeof(int32_t));
+ zmq_event_t *event = &msgEvent;
+#else
+ zmq_event_t *event = static_cast(eventMsg.data());
+#endif
+
+#ifdef ZMQ_NEW_MONITOR_EVENT_LAYOUT
+ zmq::message_t addrMsg;
+ int rc = zmq_msg_recv(addrMsg.handle(), _monitor_socket.handle(), 0);
+ if (rc == -1 && zmq_errno() == ETERM) {
+ return false;
+ }
+
+ assert(rc != -1);
+ std::string address = addrMsg.to_string();
+#else
+ // Bit of a hack, but all events in the zmq_event_t union have the same layout so this will work for all event types.
+ std::string address = event->data.connected.addr;
+#endif
+
+#ifdef ZMQ_EVENT_MONITOR_STOPPED
+ if (event->event == ZMQ_EVENT_MONITOR_STOPPED) {
+ return false;
+ }
+
+#endif
+
+ switch (event->event) {
+ case ZMQ_EVENT_CONNECTED:
+ on_event_connected(*event, address.c_str());
+ break;
+ case ZMQ_EVENT_CONNECT_DELAYED:
+ on_event_connect_delayed(*event, address.c_str());
+ break;
+ case ZMQ_EVENT_CONNECT_RETRIED:
+ on_event_connect_retried(*event, address.c_str());
+ break;
+ case ZMQ_EVENT_LISTENING:
+ on_event_listening(*event, address.c_str());
+ break;
+ case ZMQ_EVENT_BIND_FAILED:
+ on_event_bind_failed(*event, address.c_str());
+ break;
+ case ZMQ_EVENT_ACCEPTED:
+ on_event_accepted(*event, address.c_str());
+ break;
+ case ZMQ_EVENT_ACCEPT_FAILED:
+ on_event_accept_failed(*event, address.c_str());
+ break;
+ case ZMQ_EVENT_CLOSED:
+ on_event_closed(*event, address.c_str());
+ break;
+ case ZMQ_EVENT_CLOSE_FAILED:
+ on_event_close_failed(*event, address.c_str());
+ break;
+ case ZMQ_EVENT_DISCONNECTED:
+ on_event_disconnected(*event, address.c_str());
+ break;
+#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 3, 0) || (defined(ZMQ_BUILD_DRAFT_API) && ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 3))
+ case ZMQ_EVENT_HANDSHAKE_FAILED_NO_DETAIL:
+ on_event_handshake_failed_no_detail(*event, address.c_str());
+ break;
+ case ZMQ_EVENT_HANDSHAKE_FAILED_PROTOCOL:
+ on_event_handshake_failed_protocol(*event, address.c_str());
+ break;
+ case ZMQ_EVENT_HANDSHAKE_FAILED_AUTH:
+ on_event_handshake_failed_auth(*event, address.c_str());
+ break;
+ case ZMQ_EVENT_HANDSHAKE_SUCCEEDED:
+ on_event_handshake_succeeded(*event, address.c_str());
+ break;
+#elif defined(ZMQ_BUILD_DRAFT_API) && ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 1)
+ case ZMQ_EVENT_HANDSHAKE_FAILED:
+ on_event_handshake_failed(*event, address.c_str());
+ break;
+ case ZMQ_EVENT_HANDSHAKE_SUCCEED:
+ on_event_handshake_succeed(*event, address.c_str());
+ break;
+#endif
+ default:
+ on_event_unknown(*event, address.c_str());
+ break;
+ }
+
+ return true;
+ }
+
+#ifdef ZMQ_EVENT_MONITOR_STOPPED
+ void abort()
+ {
+ if (_socket)
+ zmq_socket_monitor(_socket.handle(), ZMQ_NULLPTR, 0);
+
+ _socket = socket_ref();
+ }
+#endif
+ virtual void on_monitor_started() {}
+ virtual void on_event_connected(const zmq_event_t &event_, const char *addr_)
+ {
+ (void) event_;
+ (void) addr_;
+ }
+ virtual void on_event_connect_delayed(const zmq_event_t &event_,
+ const char *addr_)
+ {
+ (void) event_;
+ (void) addr_;
+ }
+ virtual void on_event_connect_retried(const zmq_event_t &event_,
+ const char *addr_)
+ {
+ (void) event_;
+ (void) addr_;
+ }
+ virtual void on_event_listening(const zmq_event_t &event_, const char *addr_)
+ {
+ (void) event_;
+ (void) addr_;
+ }
+ virtual void on_event_bind_failed(const zmq_event_t &event_, const char *addr_)
+ {
+ (void) event_;
+ (void) addr_;
+ }
+ virtual void on_event_accepted(const zmq_event_t &event_, const char *addr_)
+ {
+ (void) event_;
+ (void) addr_;
+ }
+ virtual void on_event_accept_failed(const zmq_event_t &event_, const char *addr_)
+ {
+ (void) event_;
+ (void) addr_;
+ }
+ virtual void on_event_closed(const zmq_event_t &event_, const char *addr_)
+ {
+ (void) event_;
+ (void) addr_;
+ }
+ virtual void on_event_close_failed(const zmq_event_t &event_, const char *addr_)
+ {
+ (void) event_;
+ (void) addr_;
+ }
+ virtual void on_event_disconnected(const zmq_event_t &event_, const char *addr_)
+ {
+ (void) event_;
+ (void) addr_;
+ }
+#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 3)
+ virtual void on_event_handshake_failed_no_detail(const zmq_event_t &event_,
+ const char *addr_)
+ {
+ (void) event_;
+ (void) addr_;
+ }
+ virtual void on_event_handshake_failed_protocol(const zmq_event_t &event_,
+ const char *addr_)
+ {
+ (void) event_;
+ (void) addr_;
+ }
+ virtual void on_event_handshake_failed_auth(const zmq_event_t &event_,
+ const char *addr_)
+ {
+ (void) event_;
+ (void) addr_;
+ }
+ virtual void on_event_handshake_succeeded(const zmq_event_t &event_,
+ const char *addr_)
+ {
+ (void) event_;
+ (void) addr_;
+ }
+#elif ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 1)
+ virtual void on_event_handshake_failed(const zmq_event_t &event_,
+ const char *addr_)
+ {
+ (void) event_;
+ (void) addr_;
+ }
+ virtual void on_event_handshake_succeed(const zmq_event_t &event_,
+ const char *addr_)
+ {
+ (void) event_;
+ (void) addr_;
+ }
+#endif
+ virtual void on_event_unknown(const zmq_event_t &event_, const char *addr_)
+ {
+ (void) event_;
+ (void) addr_;
+ }
+
+ private:
+ monitor_t(const monitor_t &) ZMQ_DELETED_FUNCTION;
+ void operator=(const monitor_t &) ZMQ_DELETED_FUNCTION;
+
+ socket_ref _socket;
+ socket_t _monitor_socket;
+
+ void close() ZMQ_NOTHROW
+ {
+ if (_socket)
+ zmq_socket_monitor(_socket.handle(), ZMQ_NULLPTR, 0);
+ _monitor_socket.close();
+ }
+};
+
+#if defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) && defined(ZMQ_HAVE_POLLER)
+
+// polling events
+enum class event_flags : short
+{
+ none = 0,
+ pollin = ZMQ_POLLIN,
+ pollout = ZMQ_POLLOUT,
+ pollerr = ZMQ_POLLERR,
+ pollpri = ZMQ_POLLPRI
+};
+
+constexpr event_flags operator|(event_flags a, event_flags b) noexcept
+{
+ return detail::enum_bit_or(a, b);
+}
+constexpr event_flags operator&(event_flags a, event_flags b) noexcept
+{
+ return detail::enum_bit_and(a, b);
+}
+constexpr event_flags operator^(event_flags a, event_flags b) noexcept
+{
+ return detail::enum_bit_xor(a, b);
+}
+constexpr event_flags operator~(event_flags a) noexcept
+{
+ return detail::enum_bit_not(a);
+}
+
+struct no_user_data;
+
+// layout compatible with zmq_poller_event_t
+template struct poller_event
+{
+ socket_ref socket;
+ ::zmq::fd_t fd;
+ T *user_data;
+ event_flags events;
+};
+
+template class poller_t
+{
+ public:
+ using event_type = poller_event;
+
+ poller_t() : poller_ptr(zmq_poller_new())
+ {
+ if (!poller_ptr)
+ throw error_t();
+ }
+
+ template<
+ typename Dummy = void,
+ typename =
+ typename std::enable_if::value, Dummy>::type>
+ void add(zmq::socket_ref socket, event_flags events, T *user_data)
+ {
+ add_impl(socket, events, user_data);
+ }
+
+ void add(zmq::socket_ref socket, event_flags events)
+ {
+ add_impl(socket, events, nullptr);
+ }
+
+ void remove(zmq::socket_ref socket)
+ {
+ if (0 != zmq_poller_remove(poller_ptr.get(), socket.handle())) {
+ throw error_t();
+ }
+ }
+
+ void modify(zmq::socket_ref socket, event_flags events)
+ {
+ if (0
+ != zmq_poller_modify(poller_ptr.get(), socket.handle(),
+ static_cast(events))) {
+ throw error_t();
+ }
+ }
+
+ size_t wait_all(std::vector &poller_events,
+ const std::chrono::milliseconds timeout)
+ {
+ int rc = zmq_poller_wait_all(
+ poller_ptr.get(),
+ reinterpret_cast(poller_events.data()),
+ static_cast(poller_events.size()),
+ static_cast(timeout.count()));
+ if (rc > 0)
+ return static_cast(rc);
+
+#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 3)
+ if (zmq_errno() == EAGAIN)
+#else
+ if (zmq_errno() == ETIMEDOUT)
+#endif
+ return 0;
+
+ throw error_t();
+ }
+
+#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 3, 3)
+ size_t size() const noexcept
+ {
+ int rc = zmq_poller_size(const_cast(poller_ptr.get()));
+ ZMQ_ASSERT(rc >= 0);
+ return static_cast(std::max(rc, 0));
+ }
+#endif
+
+ private:
+ struct destroy_poller_t
+ {
+ void operator()(void *ptr) noexcept
+ {
+ int rc = zmq_poller_destroy(&ptr);
+ ZMQ_ASSERT(rc == 0);
+ }
+ };
+
+ std::unique_ptr poller_ptr;
+
+ void add_impl(zmq::socket_ref socket, event_flags events, T *user_data)
+ {
+ if (0
+ != zmq_poller_add(poller_ptr.get(), socket.handle(), user_data,
+ static_cast(events))) {
+ throw error_t();
+ }
+ }
+};
+#endif // defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) && defined(ZMQ_HAVE_POLLER)
+
+inline std::ostream &operator<<(std::ostream &os, const message_t &msg)
+{
+ return os << msg.str();
+}
+
+} // namespace zmq
+
+#endif // __ZMQ_HPP_INCLUDED__
diff --git a/ext/libzmq/include/zmq/zmq_addon.hpp b/ext/libzmq/include/zmq/zmq_addon.hpp
new file mode 100644
index 0000000..4c36d6e
--- /dev/null
+++ b/ext/libzmq/include/zmq/zmq_addon.hpp
@@ -0,0 +1,743 @@
+/*
+ Copyright (c) 2016-2017 ZeroMQ community
+ Copyright (c) 2016 VOCA AS / Harald Nøkland
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to
+ deal in the Software without restriction, including without limitation the
+ rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ sell copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ IN THE SOFTWARE.
+*/
+
+#ifndef __ZMQ_ADDON_HPP_INCLUDED__
+#define __ZMQ_ADDON_HPP_INCLUDED__
+
+#include "zmq.hpp"
+
+#include
+#include
+#include
+#include
+#ifdef ZMQ_CPP11
+#include
+#include
+#include
+#endif
+
+namespace zmq
+{
+#ifdef ZMQ_CPP11
+
+namespace detail
+{
+template
+recv_result_t
+recv_multipart_n(socket_ref s, OutputIt out, size_t n, recv_flags flags)
+{
+ size_t msg_count = 0;
+ message_t msg;
+ while (true) {
+ if ZMQ_CONSTEXPR_IF (CheckN) {
+ if (msg_count >= n)
+ throw std::runtime_error(
+ "Too many message parts in recv_multipart_n");
+ }
+ if (!s.recv(msg, flags)) {
+ // zmq ensures atomic delivery of messages
+ assert(msg_count == 0);
+ return {};
+ }
+ ++msg_count;
+ const bool more = msg.more();
+ *out++ = std::move(msg);
+ if (!more)
+ break;
+ }
+ return msg_count;
+}
+
+inline bool is_little_endian()
+{
+ const uint16_t i = 0x01;
+ return *reinterpret_cast(&i) == 0x01;
+}
+
+inline void write_network_order(unsigned char *buf, const uint32_t value)
+{
+ if (is_little_endian()) {
+ ZMQ_CONSTEXPR_VAR uint32_t mask = std::numeric_limits::max();
+ *buf++ = static_cast