diff --git a/CMakeLists.txt b/CMakeLists.txt
index c0644300..c798fc7f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -234,8 +234,10 @@ if (WIN32)
set(LUAJIT_LIBRARIES ${LUAJIT_LIBRARIES} "${DEPS_DIR}/luajit/lib/${ARCH}/lua51.lib")
set(PYTHON_LIBRARY ${PYTHON_LIBRARY} "${DEPS_DIR}/python/lib/${ARCH}/python27.lib")
set(libserialport_LIBRARY ${LIBSERIALPORT_LIBRARY} "${DEPS_DIR}/libserialport/lib/${ARCH}/libserialport-0.lib")
+ set(cppzmq_LIBRARY ${cppzmq_LIBRARY} "${DEPS_DIR}/cppzmq/lib/${ARCH}/libzmq.lib")
endif()
+set(cppzmq_INCLUDE_DIR ${cppzmq_INCLUDE_DIR} "${DEPS_DIR}/cppzmq/include")
set(GLM_INCLUDE_DIR ${GLM_INCLUDE_DIR} "${DEPS_DIR}/glm/")
if (${CMAKE_CXX_COMPILER_ID} STREQUAL MSVC)
@@ -312,7 +314,9 @@ if (WIN32)
endif()
if (WITH_ZMQ)
- target_link_libraries(${PROJECT_NAME} zmq)
+ find_package(cppzmq REQUIRED)
+ include_directories(${cppzmq_INCLUDE_DIR})
+ target_link_libraries(${PROJECT_NAME} ${cppzmq_LIBRARY})
endif()
#target_compile_options(${PROJECT_NAME} PRIVATE -flto)
diff --git a/CMake_modules/Findcppzmq.cmake b/CMake_modules/Findcppzmq.cmake
new file mode 100644
index 00000000..7e5d7c3c
--- /dev/null
+++ b/CMake_modules/Findcppzmq.cmake
@@ -0,0 +1,9 @@
+find_path(cppzmq_INCLUDE_DIR zmq.hpp)
+find_library(cppzmq_LIBRARY zmq)
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(cppzmq DEFAULT_MSG cppzmq_LIBRARY cppzmq_INCLUDE_DIR)
+if(cppzmq_FOUND)
+ set(cppzmq_LIBRARIES ${cppzmq_LIBRARY})
+ set(cppzmq_INCLUDE_DIRS ${cppzmq_INCLUDE_DIR})
+endif()
+
diff --git a/ref/cppzmq/include/zmq.h b/ref/cppzmq/include/zmq.h
new file mode 100644
index 00000000..f5713f80
--- /dev/null
+++ b/ref/cppzmq/include/zmq.h
@@ -0,0 +1,752 @@
+/*
+ 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 2
+
+#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
+#include
+#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))
+ __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 15
+
+/* 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
+
+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_);
+
+
+/******************************************************************************/
+/* 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;
+#if defined _WIN32
+ SOCKET fd;
+#else
+ int fd;
+#endif
+ 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
+
+/* 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
+
+/* DRAFT Context options */
+#define ZMQ_ZERO_COPY_RECV 10
+
+/* DRAFT Socket methods. */
+ZMQ_EXPORT int zmq_join (void *s, const char *group);
+ZMQ_EXPORT int zmq_leave (void *s, const char *group);
+
+/* 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);
+
+/* 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
+
+#if defined _WIN32
+typedef SOCKET zmq_fd_t;
+#else
+typedef int zmq_fd_t;
+#endif
+
+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_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/ref/cppzmq/include/zmq.hpp b/ref/cppzmq/include/zmq.hpp
new file mode 100644
index 00000000..74a0574d
--- /dev/null
+++ b/ref/cppzmq/include/zmq.hpp
@@ -0,0 +1,2120 @@
+/*
+ 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__
+
+// macros defined if has a specific standard or greater
+#if (defined(__cplusplus) && __cplusplus >= 201103L) || (defined(_MSC_VER) && _MSC_VER >= 1900)
+ #define ZMQ_CPP11
+#endif
+#if (defined(__cplusplus) && __cplusplus >= 201402L) || \
+ (defined(_HAS_CXX14) && _HAS_CXX14 == 1) || \
+ (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // _HAS_CXX14 might not be defined when using C++17 on MSVC
+ #define ZMQ_CPP14
+#endif
+#if (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1)
+ #define ZMQ_CPP17
+#endif
+
+#if defined(ZMQ_CPP14)
+#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
+#else
+#define ZMQ_NOTHROW throw()
+#define ZMQ_EXPLICIT
+#define ZMQ_OVERRIDE
+#define ZMQ_NULLPTR 0
+#define ZMQ_CONSTEXPR_FN
+#define ZMQ_CONSTEXPR_VAR const
+#endif
+
+#include
+
+#include
+#include
+
+#include
+#include
+#include
+#include
+#include
+#include
+#ifdef ZMQ_CPP11
+#include
+#include
+#include
+#include
+#endif
+#ifdef ZMQ_CPP17
+#ifdef __has_include
+#if __has_include()
+#include
+#define ZMQ_HAS_OPTIONAL 1
+#endif
+#if __has_include()
+#include
+#define ZMQ_HAS_STRING_VIEW 1
+#endif
+#endif
+
+#endif
+
+/* Version macros for compile-time API version detection */
+#define CPPZMQ_VERSION_MAJOR 4
+#define CPPZMQ_VERSION_MINOR 6
+#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;
+
+class error_t : public std::exception
+{
+ public:
+ error_t() : errnum(zmq_errno()) {}
+ virtual const char *what() const ZMQ_NOTHROW ZMQ_OVERRIDE { return zmq_strerror(errnum); }
+ int num() const { return errnum; }
+
+ private:
+ int errnum;
+};
+
+inline int poll(zmq_pollitem_t *items_, size_t nitems_, long timeout_ = -1)
+{
+ int rc = zmq_poll(items_, static_cast(nitems_), timeout_);
+ if (rc < 0)
+ throw error_t();
+ return rc;
+}
+
+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 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 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 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 poll(const_cast(items.data()), items.size(), timeout_);
+}
+
+inline int
+poll(zmq_pollitem_t *items, size_t nitems, std::chrono::milliseconds timeout)
+{
+ return poll(items, nitems, static_cast(timeout.count()));
+}
+
+inline int poll(std::vector &items,
+ std::chrono::milliseconds timeout)
+{
+ return poll(items.data(), items.size(), static_cast(timeout.count()));
+}
+
+inline int poll(std::vector &items, long timeout_ = -1)
+{
+ return poll(items.data(), items.size(), timeout_);
+}
+#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;
+}
+#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();
+ 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();
+ }
+
+#if defined(ZMQ_CPP11) && !defined(ZMQ_CPP11_PARTIAL)
+ template::value
+ && ZMQ_IS_TRIVIALLY_COPYABLE(detail::range_value_t)
+ && !std::is_same::value>::type>
+ explicit message_t(const Range &rng) :
+ message_t(detail::ranges::begin(rng), detail::ranges::end(rng))
+ {
+ }
+#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());
+ }
+#ifdef ZMQ_CPP17
+ // 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);
+}
+
+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
+
+ int setctxopt(int option_, int optval_)
+ {
+ int rc = zmq_ctx_set(ptr, option_, optval_);
+ ZMQ_ASSERT(rc == 0);
+ return rc;
+ }
+
+ int getctxopt(int option_) { return zmq_ctx_get(ptr, option_); }
+
+ ~context_t() ZMQ_NOTHROW { close(); }
+
+ void close() ZMQ_NOTHROW
+ {
+ if (ptr == ZMQ_NULLPTR)
+ return;
+
+ int rc;
+ do {
+ rc = zmq_ctx_destroy(ptr);
+ } while (rc == -1 && errno == EINTR);
+
+ ZMQ_ASSERT(rc == 0);
+ ptr = ZMQ_NULLPTR;
+ }
+
+ // 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; }
+
+ 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 defined(ZMQ_HAS_OPTIONAL) && (ZMQ_HAS_OPTIONAL > 0)
+
+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_CPP14
+ assert(p != nullptr || n == 0);
+#endif
+ }
+
+ constexpr void *data() const noexcept { return _data; }
+ constexpr size_t size() const noexcept { return _size; }
+ mutable_buffer &operator+=(size_t n) noexcept
+ {
+ // (std::min) is a workaround for when a min macro is defined
+ const auto shift = (std::min)(n, _size);
+ _data = static_cast(_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_CPP14
+ assert(p != nullptr || n == 0);
+#endif
+ }
+ constexpr const_buffer(const mutable_buffer &mb) noexcept :
+ _data(mb.data()),
+ _size(mb.size())
+ {
+ }
+
+ constexpr const void *data() const noexcept { return _data; }
+ constexpr size_t size() const noexcept { return _size; }
+ const_buffer &operator+=(size_t n) noexcept
+ {
+ const auto shift = (std::min)(n, _size);
+ _data = static_cast(_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 defined(ZMQ_HAS_STRING_VIEW) && (ZMQ_HAS_STRING_VIEW > 0)
+// 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_CPP14
+ 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));
+ }
+}
+
+#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 void setsockopt(int option_, T const &optval)
+ {
+ setsockopt(option_, &optval, sizeof(T));
+ }
+
+ void setsockopt(int option_, const void *optval_, size_t optvallen_)
+ {
+ int rc = zmq_setsockopt(_handle, option_, optval_, optvallen_);
+ if (rc != 0)
+ throw error_t();
+ }
+
+ 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 T getsockopt(int option_) const
+ {
+ T optval;
+ size_t optlen = sizeof(T);
+ getsockopt(option_, &optval, &optlen);
+ return optval;
+ }
+
+ 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();
+ }
+
+ bool connected() const ZMQ_NOTHROW { return (_handle != ZMQ_NULLPTR); }
+
+#ifdef ZMQ_CPP11
+ ZMQ_DEPRECATED("from 4.3.1, use send taking a const_buffer and send_flags")
+#endif
+ size_t send(const void *buf_, size_t len_, int flags_ = 0)
+ {
+ int nbytes = zmq_send(_handle, buf_, len_, flags_);
+ if (nbytes >= 0)
+ return static_cast(nbytes);
+ if (zmq_errno() == EAGAIN)
+ return 0;
+ throw error_t();
+ }
+
+#ifdef ZMQ_CPP11
+ ZMQ_DEPRECATED("from 4.3.1, use send taking message_t and send_flags")
+#endif
+ bool send(message_t &msg_,
+ int flags_ = 0) // default until removed
+ {
+ int nbytes = zmq_msg_send(msg_.handle(), _handle, flags_);
+ if (nbytes >= 0)
+ return true;
+ if (zmq_errno() == EAGAIN)
+ return false;
+ throw error_t();
+ }
+
+ template
+#ifdef ZMQ_CPP11
+ ZMQ_DEPRECATED("from 4.4.1, use send taking message_t or buffer (for contiguous ranges), and send_flags")
+#endif
+ 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
+#ifdef ZMQ_CPP11
+ ZMQ_DEPRECATED("from 4.3.1, use send taking message_t and send_flags")
+#endif
+ bool send(message_t &&msg_,
+ int flags_ = 0) // default until removed
+ {
+ #ifdef ZMQ_CPP11
+ return send(msg_, static_cast(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
+
+#ifdef ZMQ_CPP11
+ ZMQ_DEPRECATED("from 4.3.1, use recv taking a mutable_buffer and recv_flags")
+#endif
+ size_t recv(void *buf_, size_t len_, int flags_ = 0)
+ {
+ int nbytes = zmq_recv(_handle, buf_, len_, flags_);
+ if (nbytes >= 0)
+ return static_cast(nbytes);
+ if (zmq_errno() == EAGAIN)
+ return 0;
+ throw error_t();
+ }
+
+#ifdef ZMQ_CPP11
+ ZMQ_DEPRECATED("from 4.3.1, use recv taking a reference to message_t and recv_flags")
+#endif
+ bool recv(message_t *msg_, int flags_ = 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;
+};
+} // 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,
+#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==(socket_ref a, socket_ref b) ZMQ_NOTHROW
+{
+ return std::equal_to()(a.handle(), b.handle());
+}
+inline bool operator!=(socket_ref a, socket_ref b) ZMQ_NOTHROW
+{
+ return !(a == b);
+}
+inline bool operator<(socket_ref a, socket_ref b) ZMQ_NOTHROW
+{
+ return std::less()(a.handle(), b.handle());
+}
+inline bool operator>(socket_ref a, socket_ref b) ZMQ_NOTHROW
+{
+ return b < a;
+}
+inline bool operator<=(socket_ref a, socket_ref b) ZMQ_NOTHROW
+{
+ return !(a > b);
+}
+inline bool operator>=(socket_ref a, socket_ref 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(static_cast(context_), type_))
+ , ctxptr(static_cast(context_))
+ {
+ 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);
+ 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;
+ }
+
+ 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();
+ }
+};
+
+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_msg_t eventMsg;
+ zmq_msg_init(&eventMsg);
+
+ zmq::pollitem_t items[] = {
+ {_monitor_socket.handle(), 0, ZMQ_POLLIN, 0},
+ };
+
+ zmq::poll(&items[0], 1, timeout);
+
+ if (items[0].revents & ZMQ_POLLIN) {
+ int rc = zmq_msg_recv(&eventMsg, _monitor_socket.handle(), 0);
+ if (rc == -1 && zmq_errno() == ETERM)
+ return false;
+ assert(rc != -1);
+
+ } else {
+ zmq_msg_close(&eventMsg);
+ return false;
+ }
+
+#if ZMQ_VERSION_MAJOR >= 4
+ const char *data = static_cast(zmq_msg_data(&eventMsg));
+ 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(zmq_msg_data(&eventMsg));
+#endif
+
+#ifdef ZMQ_NEW_MONITOR_EVENT_LAYOUT
+ zmq_msg_t addrMsg;
+ zmq_msg_init(&addrMsg);
+ int rc = zmq_msg_recv(&addrMsg, _monitor_socket.handle(), 0);
+ if (rc == -1 && zmq_errno() == ETERM) {
+ zmq_msg_close(&eventMsg);
+ return false;
+ }
+
+ assert(rc != -1);
+ const char *str = static_cast(zmq_msg_data(&addrMsg));
+ std::string address(str, str + zmq_msg_size(&addrMsg));
+ zmq_msg_close(&addrMsg);
+#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) {
+ zmq_msg_close(&eventMsg);
+ 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;
+#ifdef ZMQ_BUILD_DRAFT_API
+#if 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 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
+#endif
+ default:
+ on_event_unknown(*event, address.c_str());
+ break;
+ }
+ zmq_msg_close(&eventMsg);
+
+ 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;
+#ifdef _WIN32
+ SOCKET fd;
+#else
+ int fd;
+#endif
+ 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();
+ }
+
+ 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/ref/cppzmq/include/zmq_addon.hpp b/ref/cppzmq/include/zmq_addon.hpp
new file mode 100644
index 00000000..86acec26
--- /dev/null
+++ b/ref/cppzmq/include/zmq_addon.hpp
@@ -0,0 +1,577 @@
+/*
+ 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
+#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 (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;
+}
+} // namespace detail
+
+/* Receive a multipart message.
+
+ Writes the zmq::message_t objects to OutputIterator out.
+ The out iterator must handle an unspecified number of writes,
+ e.g. by using std::back_inserter.
+
+ Returns: the number of messages received or nullopt (on EAGAIN).
+ Throws: if recv throws. Any exceptions thrown
+ by the out iterator will be propagated and the message
+ may have been only partially received with pending
+ message parts. It is adviced to close this socket in that event.
+*/
+template
+ZMQ_NODISCARD
+recv_result_t recv_multipart(socket_ref s, OutputIt out,
+ recv_flags flags = recv_flags::none)
+{
+ return detail::recv_multipart_n(s, std::move(out), 0, flags);
+}
+
+/* Receive a multipart message.
+
+ Writes at most n zmq::message_t objects to OutputIterator out.
+ If the number of message parts of the incoming message exceeds n
+ then an exception will be thrown.
+
+ Returns: the number of messages received or nullopt (on EAGAIN).
+ Throws: if recv throws. Throws std::runtime_error if the number
+ of message parts exceeds n (exactly n messages will have been written
+ to out). Any exceptions thrown
+ by the out iterator will be propagated and the message
+ may have been only partially received with pending
+ message parts. It is adviced to close this socket in that event.
+*/
+template
+ZMQ_NODISCARD
+recv_result_t recv_multipart_n(socket_ref s, OutputIt out, size_t n,
+ recv_flags flags = recv_flags::none)
+{
+ return detail::recv_multipart_n(s, std::move(out), n, flags);
+}
+
+/* Send a multipart message.
+
+ The range must be a ForwardRange of zmq::message_t,
+ zmq::const_buffer or zmq::mutable_buffer.
+ The flags may be zmq::send_flags::sndmore if there are
+ more message parts to be sent after the call to this function.
+
+ Returns: the number of messages sent (exactly msgs.size()) or nullopt (on EAGAIN).
+ Throws: if send throws. Any exceptions thrown
+ by the msgs range will be propagated and the message
+ may have been only partially sent. It is adviced to close this socket in that event.
+*/
+template::value
+ && (std::is_same, message_t>::value
+ || detail::is_buffer>::value)
+ >::type>
+send_result_t send_multipart(socket_ref s, Range&& msgs,
+ send_flags flags = send_flags::none)
+{
+ using std::begin;
+ using std::end;
+ auto it = begin(msgs);
+ const auto end_it = end(msgs);
+ size_t msg_count = 0;
+ while (it != end_it)
+ {
+ const auto next = std::next(it);
+ const auto msg_flags = flags | (next == end_it ? send_flags::none : send_flags::sndmore);
+ if (!s.send(*it, msg_flags))
+ {
+ // zmq ensures atomic delivery of messages
+ assert(it == begin(msgs));
+ return {};
+ }
+ ++msg_count;
+ it = next;
+ }
+ return msg_count;
+}
+
+#endif
+
+#ifdef ZMQ_HAS_RVALUE_REFS
+
+/*
+ This class handles multipart messaging. It is the C++ equivalent of zmsg.h,
+ which is part of CZMQ (the high-level C binding). Furthermore, it is a major
+ improvement compared to zmsg.hpp, which is part of the examples in the ØMQ
+ Guide. Unnecessary copying is avoided by using move semantics to efficiently
+ add/remove parts.
+*/
+class multipart_t
+{
+ private:
+ std::deque m_parts;
+
+ public:
+ typedef std::deque::iterator iterator;
+ typedef std::deque::const_iterator const_iterator;
+
+ typedef std::deque::reverse_iterator reverse_iterator;
+ typedef std::deque::const_reverse_iterator const_reverse_iterator;
+
+ // Default constructor
+ multipart_t() {}
+
+ // Construct from socket receive
+ multipart_t(socket_t &socket) { recv(socket); }
+
+ // Construct from memory block
+ multipart_t(const void *src, size_t size) { addmem(src, size); }
+
+ // Construct from string
+ multipart_t(const std::string &string) { addstr(string); }
+
+ // Construct from message part
+ multipart_t(message_t &&message) { add(std::move(message)); }
+
+ // Move constructor
+ multipart_t(multipart_t &&other) { m_parts = std::move(other.m_parts); }
+
+ // Move assignment operator
+ multipart_t &operator=(multipart_t &&other)
+ {
+ m_parts = std::move(other.m_parts);
+ return *this;
+ }
+
+ // Destructor
+ virtual ~multipart_t() { clear(); }
+
+ message_t &operator[](size_t n) { return m_parts[n]; }
+
+ const message_t &operator[](size_t n) const { return m_parts[n]; }
+
+ message_t &at(size_t n) { return m_parts.at(n); }
+
+ const message_t &at(size_t n) const { return m_parts.at(n); }
+
+ iterator begin() { return m_parts.begin(); }
+
+ const_iterator begin() const { return m_parts.begin(); }
+
+ const_iterator cbegin() const { return m_parts.cbegin(); }
+
+ reverse_iterator rbegin() { return m_parts.rbegin(); }
+
+ const_reverse_iterator rbegin() const { return m_parts.rbegin(); }
+
+ iterator end() { return m_parts.end(); }
+
+ const_iterator end() const { return m_parts.end(); }
+
+ const_iterator cend() const { return m_parts.cend(); }
+
+ reverse_iterator rend() { return m_parts.rend(); }
+
+ const_reverse_iterator rend() const { return m_parts.rend(); }
+
+ // Delete all parts
+ void clear() { m_parts.clear(); }
+
+ // Get number of parts
+ size_t size() const { return m_parts.size(); }
+
+ // Check if number of parts is zero
+ bool empty() const { return m_parts.empty(); }
+
+ // Receive multipart message from socket
+ bool recv(socket_t &socket, int flags = 0)
+ {
+ clear();
+ bool more = true;
+ while (more) {
+ message_t message;
+ #ifdef ZMQ_CPP11
+ if (!socket.recv(message, static_cast(flags)))
+ return false;
+ #else
+ if (!socket.recv(&message, flags))
+ return false;
+ #endif
+ more = message.more();
+ add(std::move(message));
+ }
+ return true;
+ }
+
+ // Send multipart message to socket
+ bool send(socket_t &socket, int flags = 0)
+ {
+ flags &= ~(ZMQ_SNDMORE);
+ bool more = size() > 0;
+ while (more) {
+ message_t message = pop();
+ more = size() > 0;
+ #ifdef ZMQ_CPP11
+ if (!socket.send(message,
+ static_cast((more ? ZMQ_SNDMORE : 0) | flags)))
+ return false;
+ #else
+ if (!socket.send(message, (more ? ZMQ_SNDMORE : 0) | flags))
+ return false;
+ #endif
+ }
+ clear();
+ return true;
+ }
+
+ // Concatenate other multipart to front
+ void prepend(multipart_t &&other)
+ {
+ while (!other.empty())
+ push(other.remove());
+ }
+
+ // Concatenate other multipart to back
+ void append(multipart_t &&other)
+ {
+ while (!other.empty())
+ add(other.pop());
+ }
+
+ // Push memory block to front
+ void pushmem(const void *src, size_t size)
+ {
+ m_parts.push_front(message_t(src, size));
+ }
+
+ // Push memory block to back
+ void addmem(const void *src, size_t size)
+ {
+ m_parts.push_back(message_t(src, size));
+ }
+
+ // Push string to front
+ void pushstr(const std::string &string)
+ {
+ m_parts.push_front(message_t(string.data(), string.size()));
+ }
+
+ // Push string to back
+ void addstr(const std::string &string)
+ {
+ m_parts.push_back(message_t(string.data(), string.size()));
+ }
+
+ // Push type (fixed-size) to front
+ template void pushtyp(const T &type)
+ {
+ static_assert(!std::is_same::value,
+ "Use pushstr() instead of pushtyp()");
+ m_parts.push_front(message_t(&type, sizeof(type)));
+ }
+
+ // Push type (fixed-size) to back
+ template void addtyp(const T &type)
+ {
+ static_assert(!std::is_same::value,
+ "Use addstr() instead of addtyp()");
+ m_parts.push_back(message_t(&type, sizeof(type)));
+ }
+
+ // Push message part to front
+ void push(message_t &&message) { m_parts.push_front(std::move(message)); }
+
+ // Push message part to back
+ void add(message_t &&message) { m_parts.push_back(std::move(message)); }
+
+ // Pop string from front
+ std::string popstr()
+ {
+ std::string string(m_parts.front().data(), m_parts.front().size());
+ m_parts.pop_front();
+ return string;
+ }
+
+ // Pop type (fixed-size) from front
+ template T poptyp()
+ {
+ static_assert(!std::is_same::value,
+ "Use popstr() instead of poptyp()");
+ if (sizeof(T) != m_parts.front().size())
+ throw std::runtime_error(
+ "Invalid type, size does not match the message size");
+ T type = *m_parts.front().data();
+ m_parts.pop_front();
+ return type;
+ }
+
+ // Pop message part from front
+ message_t pop()
+ {
+ message_t message = std::move(m_parts.front());
+ m_parts.pop_front();
+ return message;
+ }
+
+ // Pop message part from back
+ message_t remove()
+ {
+ message_t message = std::move(m_parts.back());
+ m_parts.pop_back();
+ return message;
+ }
+
+ // get message part from front
+ const message_t &front()
+ {
+ return m_parts.front();
+ }
+
+ // get message part from back
+ const message_t &back()
+ {
+ return m_parts.back();
+ }
+
+ // Get pointer to a specific message part
+ const message_t *peek(size_t index) const { return &m_parts[index]; }
+
+ // Get a string copy of a specific message part
+ std::string peekstr(size_t index) const
+ {
+ std::string string(m_parts[index].data(), m_parts[index].size());
+ return string;
+ }
+
+ // Peek type (fixed-size) from front
+ template T peektyp(size_t index) const
+ {
+ static_assert(!std::is_same::value,
+ "Use peekstr() instead of peektyp()");
+ if (sizeof(T) != m_parts[index].size())
+ throw std::runtime_error(
+ "Invalid type, size does not match the message size");
+ T type = *m_parts[index].data();
+ return type;
+ }
+
+ // Create multipart from type (fixed-size)
+ template static multipart_t create(const T &type)
+ {
+ multipart_t multipart;
+ multipart.addtyp(type);
+ return multipart;
+ }
+
+ // Copy multipart
+ multipart_t clone() const
+ {
+ multipart_t multipart;
+ for (size_t i = 0; i < size(); i++)
+ multipart.addmem(m_parts[i].data(), m_parts[i].size());
+ return multipart;
+ }
+
+ // Dump content to string
+ std::string str() const
+ {
+ std::stringstream ss;
+ for (size_t i = 0; i < m_parts.size(); i++) {
+ const unsigned char *data = m_parts[i].data();
+ size_t size = m_parts[i].size();
+
+ // Dump the message as text or binary
+ bool isText = true;
+ for (size_t j = 0; j < size; j++) {
+ if (data[j] < 32 || data[j] > 127) {
+ isText = false;
+ break;
+ }
+ }
+ ss << "\n[" << std::dec << std::setw(3) << std::setfill('0') << size
+ << "] ";
+ if (size >= 1000) {
+ ss << "... (to big to print)";
+ continue;
+ }
+ for (size_t j = 0; j < size; j++) {
+ if (isText)
+ ss << static_cast(data[j]);
+ else
+ ss << std::hex << std::setw(2) << std::setfill('0')
+ << static_cast(data[j]);
+ }
+ }
+ return ss.str();
+ }
+
+ // Check if equal to other multipart
+ bool equal(const multipart_t *other) const
+ {
+ if (size() != other->size())
+ return false;
+ for (size_t i = 0; i < size(); i++)
+ if (*peek(i) != *other->peek(i))
+ return false;
+ return true;
+ }
+
+ private:
+ // Disable implicit copying (moving is more efficient)
+ multipart_t(const multipart_t &other) ZMQ_DELETED_FUNCTION;
+ void operator=(const multipart_t &other) ZMQ_DELETED_FUNCTION;
+}; // class multipart_t
+
+inline std::ostream &operator<<(std::ostream &os, const multipart_t &msg)
+{
+ return os << msg.str();
+}
+
+#endif // ZMQ_HAS_RVALUE_REFS
+
+#if defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) && defined(ZMQ_HAVE_POLLER)
+class active_poller_t
+{
+ public:
+ active_poller_t() = default;
+ ~active_poller_t() = default;
+
+ active_poller_t(const active_poller_t &) = delete;
+ active_poller_t &operator=(const active_poller_t &) = delete;
+
+ active_poller_t(active_poller_t &&src) = default;
+ active_poller_t &operator=(active_poller_t &&src) = default;
+
+ using handler_type = std::function;
+
+ void add(zmq::socket_ref socket, event_flags events, handler_type handler)
+ {
+ auto it = decltype(handlers)::iterator{};
+ auto inserted = bool{};
+ std::tie(it, inserted) =
+ handlers.emplace(socket,
+ std::make_shared(std::move(handler)));
+ try {
+ base_poller.add(socket, events,
+ inserted && *(it->second) ? it->second.get() : nullptr);
+ need_rebuild |= inserted;
+ }
+ catch (const zmq::error_t &) {
+ // rollback
+ if (inserted) {
+ handlers.erase(socket);
+ }
+ throw;
+ }
+ }
+
+ void remove(zmq::socket_ref socket)
+ {
+ base_poller.remove(socket);
+ handlers.erase(socket);
+ need_rebuild = true;
+ }
+
+ void modify(zmq::socket_ref socket, event_flags events)
+ {
+ base_poller.modify(socket, events);
+ }
+
+ size_t wait(std::chrono::milliseconds timeout)
+ {
+ if (need_rebuild) {
+ poller_events.resize(handlers.size());
+ poller_handlers.clear();
+ poller_handlers.reserve(handlers.size());
+ for (const auto &handler : handlers) {
+ poller_handlers.push_back(handler.second);
+ }
+ need_rebuild = false;
+ }
+ const auto count = base_poller.wait_all(poller_events, timeout);
+ std::for_each(poller_events.begin(), poller_events.begin() + static_cast(count),
+ [](decltype(base_poller)::event_type &event) {
+ if (event.user_data != nullptr)
+ (*event.user_data)(event.events);
+ });
+ return count;
+ }
+
+ ZMQ_NODISCARD bool empty() const noexcept { return handlers.empty(); }
+
+ size_t size() const noexcept { return handlers.size(); }
+
+ private:
+ bool need_rebuild{false};
+
+ poller_t base_poller{};
+ std::unordered_map> handlers{};
+ std::vector poller_events{};
+ std::vector> poller_handlers{};
+}; // class active_poller_t
+#endif // defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) && defined(ZMQ_HAVE_POLLER)
+
+
+} // namespace zmq
+
+#endif // __ZMQ_ADDON_HPP_INCLUDED__
diff --git a/ref/cppzmq/lib/x64/libzmq.lib b/ref/cppzmq/lib/x64/libzmq.lib
new file mode 100644
index 00000000..6e483012
Binary files /dev/null and b/ref/cppzmq/lib/x64/libzmq.lib differ
diff --git a/ref/cppzmq/lib/x86/libzmq.lib b/ref/cppzmq/lib/x86/libzmq.lib
new file mode 100644
index 00000000..009e965b
Binary files /dev/null and b/ref/cppzmq/lib/x86/libzmq.lib differ