Index

Modules: zmq, zmq/asynczmq, zmq/bindings, zmq/connections, zmq/poller.

API symbols

`=copy`:

• connections: proc `=copy`(dest: var ZConnectionImpl; source: ZConnectionImpl)

`=destroy`:

• asynczmq: proc `=destroy`(obj: AsyncZPoller)
• poller: proc `=destroy`(poll: ZPoller)

`=sink`:

• connections: proc `=sink`(dest: var ZConnectionImpl; source: ZConnectionImpl)

`[]`:

• poller: proc `[]`(poller: ZPoller; idx: int): lent ZPollItem

AFFINITY:

• bindings: ZSockOptions.AFFINITY

AsyncZPollCB:

• asynczmq: type AsyncZPollCB

AsyncZPoller:

• asynczmq: object AsyncZPoller

BACKLOG:

• bindings: ZSockOptions.BACKLOG

bindAddr:

• bindings: proc bindAddr(s: ZSocket; address: cstring): cint
• connections: proc bindAddr(conn: var ZConnection; address: string)

BLOCKY:

• bindings: ZSockOptions.BLOCKY

CLIENT:

• bindings: ZSocketType.CLIENT

close:

• bindings: proc close(s: ZSocket): cint
• connections: proc close(c: ZConnection; linger: int = 500)

CONFLATE:

• bindings: ZSockOptions.CONFLATE

connect:

• bindings: proc connect(s: ZSocket; address: cstring): cint
• connections: proc connect(address: string; mode: ZSocketType): ZConnection
• connections: proc connect(address: string; mode: ZSocketType; context: ZContext): ZConnection

CONNECT_RID:

• bindings: ZSockOptions.CONNECT_RID

CONNECT_TIMEOUT:

• bindings: ZSockOptions.CONNECT_TIMEOUT

ctx_destroy:

• bindings: proc ctx_destroy(context: ZContext): cint

ctx_get:

• bindings: proc ctx_get(context: ZContext; option: cint): cint

ctx_new:

• bindings: proc ctx_new(): ZContext

ctx_set:

• bindings: proc ctx_set(context: ZContext; option: cint; optval: cint): cint

ctx_shutdown:

• bindings: proc ctx_shutdown(ctx: ZContext): cint

ctx_term:

• bindings: proc ctx_term(context: ZContext): cint

CURVE_PUBLICKEY:

• bindings: ZSockOptions.CURVE_PUBLICKEY

CURVE_SECRETKEY:

• bindings: ZSockOptions.CURVE_SECRETKEY

CURVE_SERVER:

• bindings: ZSockOptions.CURVE_SERVER

CURVE_SERVERKEY:

• bindings: ZSockOptions.CURVE_SERVERKEY

DEALER:

• bindings: ZSocketType.DEALER

disconnect:

• bindings: proc disconnect(s: ZSocket; address: cstring): cint
• connections: proc disconnect(conn: ZConnection)

DONTWAIT:

• bindings: ZSendRecvOptions.DONTWAIT

EADDRINUSE:

• bindings: const EADDRINUSE

EADDRNOTAVAIL:

• bindings: const EADDRNOTAVAIL

EAFNOSUPPORT:

• bindings: const EAFNOSUPPORT

ECONNABORTED:

• bindings: const ECONNABORTED

ECONNREFUSED:

• bindings: const ECONNREFUSED

ECONNRESET:

• bindings: const ECONNRESET

EFSM:

• bindings: const EFSM

EHOSTUNREACH:

• bindings: const EHOSTUNREACH

EINPROGRESS:

• bindings: const EINPROGRESS

EMSGSIZE:

• bindings: const EMSGSIZE

EMTHREAD:

• bindings: const EMTHREAD

ENETDOWN:

• bindings: const ENETDOWN

ENETRESET:

• bindings: const ENETRESET

ENETUNREACH:

• bindings: const ENETUNREACH

ENOBUFS:

• bindings: const ENOBUFS

ENOCOMPATPROTO:

• bindings: const ENOCOMPATPROTO

ENOTCONN:

• bindings: const ENOTCONN

ENOTSOCK:

• bindings: const ENOTSOCK

ENOTSUP:

• bindings: const ENOTSUP

EPROTONOSUPPORT:

• bindings: const EPROTONOSUPPORT

errno:

• bindings: proc errno(): cint

ETERM:

• bindings: const ETERM

ETIMEDOUT:

• bindings: const ETIMEDOUT

EVENTS:

• bindings: ZSockOptions.EVENTS

events:

• poller: proc events(p: ZPollItem): bool
• poller: proc events(p: ZPollItem; events: int): bool

FD:

• bindings: ZSockOptions.FD

getsockopt:

• bindings: proc getsockopt(s: ZSocket; option: ZSockOptions; optval: pointer; optvallen: ptr int): cint
• connections: proc getsockopt[T: SomeOrdinal | string](c: ZConnection; option: ZSockOptions): T
• connections: proc getsockopt[T: SomeOrdinal | string](s: ZSocket; option: ZSockOptions): T

GSSAPI_PLAINTEXT:

• bindings: ZSockOptions.GSSAPI_PLAINTEXT

GSSAPI_PRINCIPAL:

• bindings: ZSockOptions.GSSAPI_PRINCIPAL

GSSAPI_SERVER:

• bindings: ZSockOptions.GSSAPI_SERVER

GSSAPI_SERVICE_PRINCIPAL:

• bindings: ZSockOptions.GSSAPI_SERVICE_PRINCIPAL

HANDSHAKE_IVL:

• bindings: ZSockOptions.HANDSHAKE_IVL

HEARTBEAT_IVL:

• bindings: ZSockOptions.HEARTBEAT_IVL

HEARTBEAT_TIMEOUT:

• bindings: ZSockOptions.HEARTBEAT_TIMEOUT

HEARTBEAT_TTL:

• bindings: ZSockOptions.HEARTBEAT_TTL

IDENTITY:

• bindings: ZSockOptions.IDENTITY

IMMEDIATE:

• bindings: ZSockOptions.IMMEDIATE

init:

• bindings: proc init(io_threads: cint): ZContext

initZPoller:

• asynczmq: proc initZPoller(args: openArray[tuple[item: ZConnection, cb: AsyncZPollCB]]; event: cshort): AsyncZPoller
• asynczmq: proc initZPoller(poller: sink ZPoller; cb: AsyncZPollCB): AsyncZPoller
• poller: proc initZPoller(items: openArray[tuple[con: ZConnection, event: cshort]]): ZPoller
• poller: proc initZPoller(items: openArray[tuple[sock: ZSocket, event: cshort]]): ZPoller
• poller: proc initZPoller(items: openArray[ZConnection]; event: cshort): ZPoller
• poller: proc initZPoller(items: openArray[ZSocket]; event: cshort): ZPoller

INVERT_MATCHING:

• bindings: ZSockOptions.INVERT_MATCHING

IO_THREADS:

• bindings: ZContextOptions.IO_THREADS

IPV6:

• bindings: ZSockOptions.IPV6

LAST_ENDPOINT:

• bindings: ZSockOptions.LAST_ENDPOINT

len:

• asynczmq: proc len(poller: AsyncZPoller): int
• poller: proc len(poller: ZPoller): int

LINGER:

• bindings: ZSockOptions.LINGER

listen:

• connections: proc listen(address: string; mode: ZSocketType): ZConnection
• connections: proc listen(address: string; mode: ZSocketType; context: ZContext): ZConnection

MAXMSGSIZE:

• bindings: ZSockOptions.MAXMSGSIZE

MAX_SOCKETS:

• bindings: ZContextOptions.MAX_SOCKETS

MECHANISM:

• bindings: ZSockOptions.MECHANISM

MORE:

• bindings: ZMsgOptions.MORE

msg_close:

• bindings: proc msg_close(msg: var ZMsg): cint

msg_copy:

• bindings: proc msg_copy(dest, src: var ZMsg): cint

msg_data:

• bindings: proc msg_data(msg: var ZMsg): pointer

msg_get:

• bindings: proc msg_get(msg: var ZMsg; option: cint): cint

msg_init:

• bindings: proc msg_init(msg: var ZMsg): cint
• bindings: proc msg_init(msg: var ZMsg; data: cstring; size: int; ffn: TFreeFn; hint: pointer): cint
• bindings: proc msg_init(msg: var ZMsg; size: int): cint

msg_more:

• bindings: proc msg_more(msg: var ZMsg): cint

msg_move:

• bindings: proc msg_move(dest, src: var ZMsg): cint

msg_recv:

• bindings: proc msg_recv(msg: var ZMsg; s: ZSocket; flags: cint): cint

msg_send:

• bindings: proc msg_send(msg: var ZMsg; s: ZSocket; flags: cint): cint

msg_set:

• bindings: proc msg_set(msg: var ZMsg; option: cint; optval: cint): cint

msg_size:

• bindings: proc msg_size(msg: var ZMsg): int

MULTICAST_HOPS:

• bindings: ZSockOptions.MULTICAST_HOPS

newZContext:

• connections: proc newZContext(): ZContext
• connections: proc newZContext(numthreads: int): ZContext
• connections: proc newZContext(option: int; optval: int): ZContext

NOFLAGS:

• bindings: ZSendRecvOptions.NOFLAGS

PAIR:

• bindings: ZSocketType.PAIR

PLAIN_PASSWORD:

• bindings: ZSockOptions.PLAIN_PASSWORD

PLAIN_SERVER:

• bindings: ZSockOptions.PLAIN_SERVER

PLAIN_USERNAME:

• bindings: ZSockOptions.PLAIN_USERNAME

poll:

• bindings: proc poll(items: ptr UncheckedArray[ZPollItem]; nitems: cint; timeout: clong): cint
• poller: proc poll(items: openArray[ZPollItem]; timeout: int64): int32
• poller: proc poll(poller: ZPoller; timeout: int64): int32

pollAsync:

• asynczmq: proc pollAsync(poller: AsyncZPoller; timeout: int = 2): Future[int]

PROBE_ROUTER:

• bindings: ZSockOptions.PROBE_ROUTER

proxy:

• bindings: proc proxy(frontend: ZSocket; backend: ZSocket; capture: ZSocket): cint
• connections: proc proxy(frontend, backend: ZConnection)
• connections: proc proxy(frontend, backend, capture: ZConnection)

proxy_steerable:

• bindings: proc proxy_steerable(frontend: ZSocket; backend: ZSocket; capture: ZSocket; control: ZSocket): cint

PUB:

• bindings: ZSocketType.PUB

PULL:

• bindings: ZSocketType.PULL

PUSH:

• bindings: ZSocketType.PUSH

RATE:

• bindings: ZSockOptions.RATE

RCVBUF:

• bindings: ZSockOptions.RCVBUF

RCVHWM:

• bindings: ZSockOptions.RCVHWM

RCVMORE:

• bindings: ZSockOptions.RCVMORE

RCVTIMEO:

• bindings: ZSockOptions.RCVTIMEO

receive:

• connections: proc receive(c: ZConnection; flags: ZSendRecvOptions = NOFLAGS): string
• connections: proc receive(s: ZSocket; flags: ZSendRecvOptions = NOFLAGS): string

receiveAll:

• connections: proc receiveAll(c: ZConnection; flags: ZSendRecvOptions = NOFLAGS): seq[string]
• connections: proc receiveAll(s: ZSocket; flags: ZSendRecvOptions = NOFLAGS): seq[string]

receiveAsync:

• asynczmq: proc receiveAsync(conn: ZConnection): Future[string]

reconnect:

• connections: proc reconnect(conn: ZConnection)
• connections: proc reconnect(conn: var ZConnection; address: string)

RECONNECT_IVL:

• bindings: ZSockOptions.RECONNECT_IVL

RECONNECT_IVL_MAX:

• bindings: ZSockOptions.RECONNECT_IVL_MAX

RECOVERY_IVL:

• bindings: ZSockOptions.RECOVERY_IVL

recv:

• bindings: proc recv(s: ZSocket; buf: pointer; len: int; flags: cint): cint

recvmsg:

• bindings: proc recvmsg(s: ZSocket; msg: var ZMsg; flags: cint): cint

register:

• asynczmq: proc register(poller: var AsyncZPoller; conn: ZConnection; event: int; cb: AsyncZPollCB)
• asynczmq: proc register(poller: var AsyncZPoller; item: ZPollItem; cb: AsyncZPollCB)
• asynczmq: proc register(poller: var AsyncZPoller; sock: ZSocket; event: int; cb: AsyncZPollCB)
• poller: proc register(poller: var ZPoller; conn: ZConnection; event: int)
• poller: proc register(poller: var ZPoller; sock: ZSocket; event: int)

REP:

• bindings: ZSocketType.REP

REQ:

• bindings: ZSocketType.REQ

REQ_CORRELATE:

• bindings: ZSockOptions.REQ_CORRELATE

REQ_RELAXED:

• bindings: ZSockOptions.REQ_RELAXED

ROUTER:

• bindings: ZSocketType.ROUTER

ROUTER_HANDOVER:

• bindings: ZSockOptions.ROUTER_HANDOVER

ROUTER_MANDATORY:

• bindings: ZSockOptions.ROUTER_MANDATORY

ROUTER_RAW:

• bindings: ZSockOptions.ROUTER_RAW

send:

• bindings: proc send(s: ZSocket; buf: pointer; len: int; flags: cint): cint
• connections: proc send(c: ZConnection; msg: string; flags: ZSendRecvOptions = NOFLAGS)
• connections: proc send(s: ZSocket; msg: string; flags: ZSendRecvOptions = NOFLAGS)

sendAll:

• connections: proc sendAll(c: ZConnection; msg: varargs[string])
• connections: proc sendAll(s: ZSocket; msg: varargs[string])

sendAsync:

• asynczmq: proc sendAsync(conn: ZConnection; msg: string; flags: ZSendRecvOptions = DONTWAIT): Future[ void]

send_const:

• bindings: proc send_const(s: ZSocket; buf: pointer; len: int; flags: cint): cint

sendmsg:

• bindings: proc sendmsg(s: ZSocket; msg: var ZMsg; flags: cint): cint

SERVER:

• bindings: ZSocketType.SERVER

setsockopt:

• bindings: proc setsockopt(s: ZSocket; option: ZSockOptions; optval: pointer; optvallen: int): cint
• connections: proc setsockopt[T: SomeOrdinal | string](c: ZConnection; option: ZSockOptions; optval: T)
• connections: proc setsockopt[T: SomeOrdinal | string](s: ZSocket; option: ZSockOptions; optval: T)

SHARED:

• bindings: ZMsgOptions.SHARED

SNDBUF:

• bindings: ZSockOptions.SNDBUF

SNDHWM:

• bindings: ZSockOptions.SNDHWM

SNDMORE:

• bindings: ZSendRecvOptions.SNDMORE

SNDTIMEO:

• bindings: ZSockOptions.SNDTIMEO

socket:

• bindings: proc socket(context: ZContext; theType: cint): ZSocket

socket_monitor:

• bindings: proc socket_monitor(s: ZSocket; address: pointer; events: cint): cint

SOCKS_PROXY:

• bindings: ZSockOptions.SOCKS_PROXY

SRCFD:

• bindings: ZMsgOptions.SRCFD

STREAM:

• bindings: ZSocketType.STREAM

STREAM_NOTIFY:

• bindings: ZSockOptions.STREAM_NOTIFY

strerror:

• bindings: proc strerror(errnum: cint): cstring

SUB:

• bindings: ZSocketType.SUB

SUBSCRIBE:

• bindings: ZSockOptions.SUBSCRIBE

TCP_ACCEPT_FILTER:

• bindings: ZSockOptions.TCP_ACCEPT_FILTER

TCP_KEEPALIVE:

• bindings: ZSockOptions.TCP_KEEPALIVE

TCP_KEEPALIVE_CNT:

• bindings: ZSockOptions.TCP_KEEPALIVE_CNT

TCP_KEEPALIVE_IDLE:

• bindings: ZSockOptions.TCP_KEEPALIVE_IDLE

TCP_KEEPALIVE_INTVL:

• bindings: ZSockOptions.TCP_KEEPALIVE_INTVL

TCP_RETRANSMIT_TIMEOUT:

• bindings: ZSockOptions.TCP_RETRANSMIT_TIMEOUT

term:

• bindings: proc term(context: ZContext): cint

terminate:

• connections: proc terminate(ctx: ZContext)

THREAD_SAFE:

• bindings: ZSockOptions.THREAD_SAFE

TOS:

• bindings: ZSockOptions.TOS

tryReceive:

• connections: proc tryReceive(c: ZConnection; flags: ZSendRecvOptions = NOFLAGS): tuple[ msgAvailable: bool, moreAvailable: bool, msg: string]
• connections: proc tryReceive(s: ZSocket; flags: ZSendRecvOptions = NOFLAGS): tuple[ msgAvailable: bool, moreAvailable: bool, msg: string]

TYPE:

• bindings: ZSockOptions.TYPE

unbind:

• bindings: proc unbind(s: ZSocket; address: cstring): cint
• connections: proc unbind(conn: ZConnection)

UNSUBSCRIBE:

• bindings: ZSockOptions.UNSUBSCRIBE

version:

• bindings: proc version(major: var cint; minor: var cint; patch: var cint)

waitForReceive:

• connections: proc waitForReceive(c: ZConnection; timeout: int = -1; flags: ZSendRecvOptions = NOFLAGS): tuple[msgAvailable: bool, moreAvailable: bool, msg: string]
• connections: proc waitForReceive(s: ZSocket; timeout: int = -2; flags: ZSendRecvOptions = NOFLAGS): tuple[ msgAvailable: bool, moreAvailable: bool, msg: string]

XPUB:

• bindings: ZSocketType.XPUB

XPUB_MANUAL:

• bindings: ZSockOptions.XPUB_MANUAL

XPUB_NODROP:

• bindings: ZSockOptions.XPUB_NODROP

XPUB_VERBOSE:

• bindings: ZSockOptions.XPUB_VERBOSE

XPUB_VERBOSE_UNSUBSCRIBE:

• bindings: ZSockOptions.XPUB_VERBOSE_UNSUBSCRIBE

XPUB_WELCOME_MSG:

• bindings: ZSockOptions.XPUB_WELCOME_MSG

XSUB:

• bindings: ZSocketType.XSUB

z85_decode:

• bindings: proc z85_decode(dest: ptr uint8; string: cstring): ptr uint8

z85_encode:

• bindings: proc z85_encode(dest: cstring; data: ptr uint8; size: int): cstring

ZAP_DOMAIN:

• bindings: ZSockOptions.ZAP_DOMAIN

ZConnection:

• connections: type ZConnection

ZConnectionImpl:

• connections: object ZConnectionImpl

ZContext:

• bindings: type ZContext

ZContextOptions:

• bindings: enum ZContextOptions

ZMQ_AFFINITY:

• bindings: const ZMQ_AFFINITY

ZMQ_BACKLOG:

• bindings: const ZMQ_BACKLOG

ZMQ_BLOCKY:

• bindings: const ZMQ_BLOCKY

ZMQ_CLIENT:

• bindings: const ZMQ_CLIENT

ZMQ_CONFLATE:

• bindings: const ZMQ_CONFLATE

ZMQ_CONNECT_RID:

• bindings: const ZMQ_CONNECT_RID

ZMQ_CONNECT_TIMEOUT:

• bindings: const ZMQ_CONNECT_TIMEOUT

ZMQ_CURVE:

• bindings: const ZMQ_CURVE

ZMQ_CURVE_PUBLICKEY:

• bindings: const ZMQ_CURVE_PUBLICKEY

ZMQ_CURVE_SECRETKEY:

• bindings: const ZMQ_CURVE_SECRETKEY

ZMQ_CURVE_SERVER:

• bindings: const ZMQ_CURVE_SERVER

ZMQ_CURVE_SERVERKEY:

• bindings: const ZMQ_CURVE_SERVERKEY

ZMQ_DEALER:

• bindings: const ZMQ_DEALER

ZMQ_DELAY_ATTACH_ON_CONNECT:

• bindings: const ZMQ_DELAY_ATTACH_ON_CONNECT

zmqdll:

• bindings: const zmqdll

ZMQ_DONTWAIT:

• bindings: const ZMQ_DONTWAIT

ZMQ_EAGAIN:

• bindings: let ZMQ_EAGAIN

ZmqError:

• connections: object ZmqError

zmqError:

• connections: proc zmqError()

ZMQ_EVENT_ACCEPTED:

• bindings: const ZMQ_EVENT_ACCEPTED

ZMQ_EVENT_ACCEPT_FAILED:

• bindings: const ZMQ_EVENT_ACCEPT_FAILED

ZMQ_EVENT_ALL:

• bindings: const ZMQ_EVENT_ALL

ZMQ_EVENT_BIND_FAILED:

• bindings: const ZMQ_EVENT_BIND_FAILED

ZMQ_EVENT_CLOSED:

• bindings: const ZMQ_EVENT_CLOSED

ZMQ_EVENT_CLOSE_FAILED:

• bindings: const ZMQ_EVENT_CLOSE_FAILED

ZMQ_EVENT_CONNECT_DELAYED:

• bindings: const ZMQ_EVENT_CONNECT_DELAYED

ZMQ_EVENT_CONNECTED:

• bindings: const ZMQ_EVENT_CONNECTED

ZMQ_EVENT_CONNECT_RETRIED:

• bindings: const ZMQ_EVENT_CONNECT_RETRIED

ZMQ_EVENT_DISCONNECTED:

• bindings: const ZMQ_EVENT_DISCONNECTED

ZMQ_EVENT_LISTENING:

• bindings: const ZMQ_EVENT_LISTENING

ZMQ_EVENT_MONITOR_STOPPED:

• bindings: const ZMQ_EVENT_MONITOR_STOPPED

ZMQ_EVENTS:

• bindings: const ZMQ_EVENTS

zmq_event_t:

• bindings: object zmq_event_t

ZMQ_FAIL_UNROUTABLE:

• bindings: const ZMQ_FAIL_UNROUTABLE

ZMQ_FD:

• bindings: const ZMQ_FD

ZMQ_GSSAPI:

• bindings: const ZMQ_GSSAPI

ZMQ_GSSAPI_PLAINTEXT:

• bindings: const ZMQ_GSSAPI_PLAINTEXT

ZMQ_GSSAPI_PRINCIPAL:

• bindings: const ZMQ_GSSAPI_PRINCIPAL

ZMQ_GSSAPI_SERVER:

• bindings: const ZMQ_GSSAPI_SERVER

ZMQ_GSSAPI_SERVICE_PRINCIPAL:

• bindings: const ZMQ_GSSAPI_SERVICE_PRINCIPAL

ZMQ_HANDSHAKE_IVL:

• bindings: const ZMQ_HANDSHAKE_IVL

ZMQ_HEARTBEAT_IVL:

• bindings: const ZMQ_HEARTBEAT_IVL

ZMQ_HEARTBEAT_TIMEOUT:

• bindings: const ZMQ_HEARTBEAT_TIMEOUT

ZMQ_HEARTBEAT_TTL:

• bindings: const ZMQ_HEARTBEAT_TTL

ZMQ_IDENTITY:

• bindings: const ZMQ_IDENTITY

ZMQ_IMMEDIATE:

• bindings: const ZMQ_IMMEDIATE

ZMQ_INVERT_MATCHING:

• bindings: const ZMQ_INVERT_MATCHING

ZMQ_IO_THREADS:

• bindings: const ZMQ_IO_THREADS

ZMQ_IO_THREADS_DFLT:

• bindings: const ZMQ_IO_THREADS_DFLT

ZMQ_IPC_FILTER_GID:

• bindings: const ZMQ_IPC_FILTER_GID

ZMQ_IPC_FILTER_PID:

• bindings: const ZMQ_IPC_FILTER_PID

ZMQ_IPC_FILTER_UID:

• bindings: const ZMQ_IPC_FILTER_UID

ZMQ_IPV4ONLY:

• bindings: const ZMQ_IPV4ONLY

ZMQ_IPV6:

• bindings: ZContextOptions.ZMQ_IPV6

ZMQ_LAST_ENDPOINT:

• bindings: const ZMQ_LAST_ENDPOINT

ZMQ_LINGER:

• bindings: const ZMQ_LINGER

ZMQ_MAKE_VERSION:

• bindings: template ZMQ_MAKE_VERSION(major, minor, patch: untyped): untyped

ZMQ_MAXMSGSIZE:

• bindings: const ZMQ_MAXMSGSIZE

ZMQ_MAX_SOCKETS:

• bindings: const ZMQ_MAX_SOCKETS

ZMQ_MAX_SOCKETS_DFLT:

• bindings: const ZMQ_MAX_SOCKETS_DFLT

ZMQ_MECHANISM:

• bindings: const ZMQ_MECHANISM

ZMQ_MORE:

• bindings: const ZMQ_MORE

ZMQ_MULTICAST_HOPS:

• bindings: const ZMQ_MULTICAST_HOPS

ZMQ_NOBLOCK:

• bindings: const ZMQ_NOBLOCK

ZMQ_NULL:

• bindings: const ZMQ_NULL

ZMQ_PAIR:

• bindings: const ZMQ_PAIR

ZMQ_PLAIN:

• bindings: const ZMQ_PLAIN

ZMQ_PLAIN_PASSWORD:

• bindings: const ZMQ_PLAIN_PASSWORD

ZMQ_PLAIN_SERVER:

• bindings: const ZMQ_PLAIN_SERVER

ZMQ_PLAIN_USERNAME:

• bindings: const ZMQ_PLAIN_USERNAME

ZMQ_POLLERR:

• bindings: const ZMQ_POLLERR

ZMQ_POLLIN:

• bindings: const ZMQ_POLLIN

ZMQ_POLLITEMS_DFLT:

• bindings: const ZMQ_POLLITEMS_DFLT

ZMQ_POLLOUT:

• bindings: const ZMQ_POLLOUT

ZMQ_POLLPRI:

• bindings: const ZMQ_POLLPRI

ZMQ_PROBE_ROUTER:

• bindings: const ZMQ_PROBE_ROUTER

ZMQ_PUB:

• bindings: const ZMQ_PUB

ZMQ_PULL:

• bindings: const ZMQ_PULL

ZMQ_PUSH:

• bindings: const ZMQ_PUSH

ZMQ_RATE:

• bindings: const ZMQ_RATE

ZMQ_RCVBUF:

• bindings: const ZMQ_RCVBUF

ZMQ_RCVHWM:

• bindings: const ZMQ_RCVHWM

ZMQ_RCVMORE:

• bindings: const ZMQ_RCVMORE

ZMQ_RCVTIMEO:

• bindings: const ZMQ_RCVTIMEO

ZMQ_RECONNECT_IVL:

• bindings: const ZMQ_RECONNECT_IVL

ZMQ_RECONNECT_IVL_MAX:

• bindings: const ZMQ_RECONNECT_IVL_MAX

ZMQ_RECOVERY_IVL:

• bindings: const ZMQ_RECOVERY_IVL

ZMQ_REP:

• bindings: const ZMQ_REP

ZMQ_REQ:

• bindings: const ZMQ_REQ

ZMQ_REQ_CORRELATE:

• bindings: const ZMQ_REQ_CORRELATE

ZMQ_REQ_RELAXED:

• bindings: const ZMQ_REQ_RELAXED

ZMQ_ROUTER:

• bindings: const ZMQ_ROUTER

ZMQ_ROUTER_BEHAVIOR:

• bindings: const ZMQ_ROUTER_BEHAVIOR

ZMQ_ROUTER_HANDOVER:

• bindings: const ZMQ_ROUTER_HANDOVER

ZMQ_ROUTER_MANDATORY:

• bindings: const ZMQ_ROUTER_MANDATORY

ZMQ_ROUTER_RAW:

• bindings: const ZMQ_ROUTER_RAW

ZMQ_SERVER:

• bindings: const ZMQ_SERVER

ZMQ_SHARED:

• bindings: const ZMQ_SHARED

ZMQ_SNDBUF:

• bindings: const ZMQ_SNDBUF

ZMQ_SNDHWM:

• bindings: const ZMQ_SNDHWM

ZMQ_SNDMORE:

• bindings: const ZMQ_SNDMORE

ZMQ_SNDTIMEO:

• bindings: const ZMQ_SNDTIMEO

ZMQ_SOCKET_LIMIT:

• bindings: const ZMQ_SOCKET_LIMIT

ZMQ_SOCKS_PROXY:

• bindings: const ZMQ_SOCKS_PROXY

ZMQ_SRCFD:

• bindings: const ZMQ_SRCFD

ZMQ_STREAM:

• bindings: const ZMQ_STREAM

ZMQ_STREAM_NOTIFY:

• bindings: const ZMQ_STREAM_NOTIFY

ZMQ_SUB:

• bindings: const ZMQ_SUB

ZMQ_SUBSCRIBE:

• bindings: const ZMQ_SUBSCRIBE

ZMQ_TCP_ACCEPT_FILTER:

• bindings: const ZMQ_TCP_ACCEPT_FILTER

ZMQ_TCP_KEEPALIVE:

• bindings: const ZMQ_TCP_KEEPALIVE

ZMQ_TCP_KEEPALIVE_CNT:

• bindings: const ZMQ_TCP_KEEPALIVE_CNT

ZMQ_TCP_KEEPALIVE_IDLE:

• bindings: const ZMQ_TCP_KEEPALIVE_IDLE

ZMQ_TCP_KEEPALIVE_INTVL:

• bindings: const ZMQ_TCP_KEEPALIVE_INTVL

ZMQ_TCP_RETRANSMIT_TIMEOUT:

• bindings: const ZMQ_TCP_RETRANSMIT_TIMEOUT

ZMQ_THREAD_PRIORITY:

• bindings: const ZMQ_THREAD_PRIORITY

ZMQ_THREAD_PRIORITY_DFLT:

• bindings: const ZMQ_THREAD_PRIORITY_DFLT

ZMQ_THREAD_SAFE:

• bindings: const ZMQ_THREAD_SAFE

ZMQ_THREAD_SCHED_POLICY:

• bindings: const ZMQ_THREAD_SCHED_POLICY

ZMQ_THREAD_SCHED_POLICY_DFLT:

• bindings: const ZMQ_THREAD_SCHED_POLICY_DFLT

ZMQ_TOS:

• bindings: const ZMQ_TOS

ZMQ_TYPE:

• bindings: const ZMQ_TYPE

ZMQ_UNSUBSCRIBE:

• bindings: const ZMQ_UNSUBSCRIBE

ZMQ_VERSION:

• bindings: const ZMQ_VERSION

ZMQ_VERSION_MAJOR:

• bindings: const ZMQ_VERSION_MAJOR

ZMQ_VERSION_MINOR:

• bindings: const ZMQ_VERSION_MINOR

ZMQ_VERSION_PATCH:

• bindings: const ZMQ_VERSION_PATCH

ZMQ_XPUB:

• bindings: const ZMQ_XPUB

ZMQ_XPUB_MANUAL:

• bindings: const ZMQ_XPUB_MANUAL

ZMQ_XPUB_NODROP:

• bindings: const ZMQ_XPUB_NODROP

ZMQ_XPUB_VERBOSE:

• bindings: const ZMQ_XPUB_VERBOSE

ZMQ_XPUB_VERBOSE_UNSUBSCRIBE:

• bindings: const ZMQ_XPUB_VERBOSE_UNSUBSCRIBE

ZMQ_XPUB_WELCOME_MSG:

• bindings: const ZMQ_XPUB_WELCOME_MSG

ZMQ_XREP:

• bindings: const ZMQ_XREP

ZMQ_XREQ:

• bindings: const ZMQ_XREQ

ZMQ_XSUB:

• bindings: const ZMQ_XSUB

ZMQ_ZAP_DOMAIN:

• bindings: const ZMQ_ZAP_DOMAIN

ZMsg:

• bindings: object ZMsg

ZMsgOptions:

• bindings: enum ZMsgOptions

ZPoller:

• poller: object ZPoller

ZPollItem:

• bindings: object ZPollItem

ZSendRecvOptions:

• bindings: enum ZSendRecvOptions

ZSocket:

• bindings: type ZSocket

ZSocketType:

• bindings: enum ZSocketType

ZSockOptions:

• bindings: enum ZSockOptions