laag-libczmq 4.1.0.0

data/vendor/github.com/zeromq/czmq/api/zproc.api

@@ -0,0 +1,247 @@
+<class name = "zproc" state = "draft">
+    <!--
+    Copyright (c) the Contributors as noted in the AUTHORS file.
+    This file is part of CZMQ, the high-level C binding for 0MQ:
+    http://czmq.zeromq.org.
+
+    This Source Code Form is subject to the terms of the Mozilla Public
+    License, v. 2.0. If a copy of the MPL was not distributed with this
+    file, You can obtain one at http://mozilla.org/MPL/2.0/.
+    -->
+    process configuration and status
+
+    <constructor>
+        Create a new zproc.
+        NOTE: On Windows and with libzmq3 and libzmq2 this function
+        returns NULL. Code needs to be ported there.
+    </constructor>
+
+    <destructor>
+        Destroy zproc, wait until process ends.
+    </destructor>
+
+    <method name = "set args" >
+        Setup the command line arguments, the first item must be an (absolute) filename
+        to run.
+        <argument name = "args" type = "zlistx" />
+    </method>
+
+    <method name = "set env" >
+        Setup the environment variables for the process.
+        <argument name = "args" type = "zhashx" />
+    </method>
+
+    <method name = "set stdin" >
+        Connects process stdin with a readable ('>', connect) zeromq socket. If
+        socket argument is NULL, zproc creates own managed pair of inproc
+        sockets.  The writable one is then accessbile via zproc_stdin method.
+        <argument name = "socket" type = "anything" />
+    </method>
+
+    <method name = "set stdout" >
+        Connects process stdout with a writable ('@', bind) zeromq socket. If
+        socket argument is NULL, zproc creates own managed pair of inproc
+        sockets.  The readable one is then accessbile via zproc_stdout method.
+        <argument name = "socket" type = "anything" />
+    </method>
+
+    <method name = "set stderr" >
+        Connects process stderr with a writable ('@', bind) zeromq socket. If
+        socket argument is NULL, zproc creates own managed pair of inproc
+        sockets.  The readable one is then accessbile via zproc_stderr method.
+        <argument name = "socket" type = "anything" />
+    </method>
+
+    <method name = "stdin">
+        Return subprocess stdin writable socket. NULL for
+        not initialized or external sockets.
+        <return type="anything" />
+    </method>
+
+    <method name = "stdout">
+        Return subprocess stdout readable socket. NULL for
+        not initialized or external sockets.
+        <return type="anything" />
+    </method>
+
+    <method name = "stderr">
+        Return subprocess stderr readable socket. NULL for
+        not initialized or external sockets.
+        <return type="anything" />
+    </method>
+
+    <method name = "run" >
+        Starts the process.
+        <return type = "integer" />
+    </method>
+
+    <method name = "returncode">
+        process exit code
+        <return type="integer" />
+    </method>
+
+    <method name = "pid">
+        PID of the process
+        <return type="integer" />
+    </method>
+
+    <method name = "running">
+        return true if process is running, false if not yet started or finished
+        <return type="boolean" />
+    </method>
+
+    <method name = "wait">
+        wait or poll process status, return return code
+        <argument name = "hang" type = "boolean" />
+        <return type="integer" />
+    </method>
+
+    <method name = "actor">
+        return internal actor, usefull for the polling if process died
+        <return type="anything" />
+    </method>
+
+    <method name = "kill">
+        send a signal to the subprocess
+        <argument name = "signal" type = "integer" />
+    </method>
+
+    <method name = "set verbose">
+        set verbose mode
+        <argument name = "verbose" type = "boolean" />
+    </method>
+
+<!--
+TODO: cannot express such method in zproto API model!!
+//  run the subprocess
+CZMQ_EXPORT int
+    zsubproc_run (zsubproc_t *self, const char *filename, char *const argv[], char *const envp[]);
+-->
+
+    <method name = "czmq version" singleton = "1">
+        Returns CZMQ version as a single 6-digit integer encoding the major
+        version (x 10000), the minor version (x 100) and the patch.
+        <return type = "integer" />
+    </method>
+
+    <method name = "interrupted" singleton = "1">
+        Returns true if the process received a SIGINT or SIGTERM signal.
+        It is good practice to use this method to exit any infinite loop
+        processing messages.
+        <return type = "boolean" />
+    </method>
+
+    <method name = "has curve" singleton = "1">
+        Returns true if the underlying libzmq supports CURVE security.
+        <return type = "boolean" />
+    </method>
+
+    <method name = "hostname" singleton = "1">
+        Return current host name, for use in public tcp:// endpoints.
+        If the host name is not resolvable, returns NULL.
+        <return type = "string" fresh = "1" />
+    </method>
+
+    <method name = "daemonize" singleton = "1">
+        Move the current process into the background. The precise effect
+        depends on the operating system. On POSIX boxes, moves to a specified
+        working directory (if specified), closes all file handles, reopens
+        stdin, stdout, and stderr to the null device, and sets the process to
+        ignore SIGHUP. On Windows, does nothing. Returns 0 if OK, -1 if there
+        was an error.
+        <argument name = "workdir" type = "string" />
+    </method>
+
+    <method name = "run as" singleton = "1">
+        Drop the process ID into the lockfile, with exclusive lock, and
+        switch the process to the specified group and/or user. Any of the
+        arguments may be null, indicating a no-op. Returns 0 on success,
+        -1 on failure. Note if you combine this with zsys_daemonize, run
+        after, not before that method, or the lockfile will hold the wrong
+        process ID.
+        <argument name = "lockfile" type = "string" />
+        <argument name = "group" type = "string" />
+        <argument name = "user" type = "string" />
+    </method>
+
+    <method name = "set io threads" singleton = "1">
+        Configure the number of I/O threads that ZeroMQ will use. A good
+        rule of thumb is one thread per gigabit of traffic in or out. The
+        default is 1, sufficient for most applications. If the environment
+        variable ZSYS_IO_THREADS is defined, that provides the default.
+        Note that this method is valid only before any socket is created.
+        <argument name = "io_threads" type = "size" />
+    </method>
+
+    <method name = "set max sockets" singleton = "1">
+        Configure the number of sockets that ZeroMQ will allow. The default
+        is 1024. The actual limit depends on the system, and you can query it
+        by using zsys_socket_limit (). A value of zero means "maximum".
+        Note that this method is valid only before any socket is created.
+        <argument name = "max_sockets" type = "size" />
+    </method>
+
+    <method name = "set biface" singleton = "1">
+        Set network interface name to use for broadcasts, particularly zbeacon.
+        This lets the interface be configured for test environments where required.
+        For example, on Mac OS X, zbeacon cannot bind to 255.255.255.255 which is
+        the default when there is no specified interface. If the environment
+        variable ZSYS_INTERFACE is set, use that as the default interface name.
+        Setting the interface to "*" means "use all available interfaces".
+        <argument name = "value" type = "string" />
+    </method>
+
+    <method name = "biface" singleton = "1">
+        Return network interface to use for broadcasts, or "" if none was set.
+        <return type = "string" />
+    </method>
+
+    <method name = "set log ident" singleton = "1">
+        Set log identity, which is a string that prefixes all log messages sent
+        by this process. The log identity defaults to the environment variable
+        ZSYS_LOGIDENT, if that is set.
+        <argument name = "value" type = "string" />
+    </method>
+
+    <method name = "set log sender" singleton = "1">
+        Sends log output to a PUB socket bound to the specified endpoint. To
+        collect such log output, create a SUB socket, subscribe to the traffic
+        you care about, and connect to the endpoint. Log traffic is sent as a
+        single string frame, in the same format as when sent to stdout. The
+        log system supports a single sender; multiple calls to this method will
+        bind the same sender to multiple endpoints. To disable the sender, call
+        this method with a null argument.
+        <argument name = "endpoint" type = "string" />
+    </method>
+
+    <method name = "set log system" singleton = "1">
+        Enable or disable logging to the system facility (syslog on POSIX boxes,
+        event log on Windows). By default this is disabled.
+        <argument name = "logsystem" type = "boolean" />
+    </method>
+
+    <method name = "log error" singleton = "1">
+        Log error condition - highest priority
+        <argument name = "format" type = "format" />
+    </method>
+
+    <method name = "log warning" singleton = "1">
+        Log warning condition - high priority
+        <argument name = "format" type = "format" />
+    </method>
+
+    <method name = "log notice" singleton = "1">
+        Log normal, but significant, condition - normal priority
+        <argument name = "format" type = "format" />
+    </method>
+
+    <method name = "log info" singleton = "1">
+        Log informational message - low priority
+        <argument name = "format" type = "format" />
+    </method>
+
+    <method name = "log debug" singleton = "1">
+        Log debug-level message - lowest priority
+        <argument name = "format" type = "format" />
+    </method>
+</class>

data/vendor/github.com/zeromq/czmq/api/zsock.api

@@ -0,0 +1,412 @@
+<class name = "zsock" state = "stable">
+    <!--
+    Copyright (c) the Contributors as noted in the AUTHORS file.
+    This file is part of CZMQ, the high-level C binding for 0MQ:
+    http://czmq.zeromq.org.
+
+    This Source Code Form is subject to the terms of the Mozilla Public
+    License, v. 2.0. If a copy of the MPL was not distributed with this
+    file, You can obtain one at http://mozilla.org/MPL/2.0/.
+    -->
+    high-level socket API that hides libzmq contexts and sockets
+
+    <constructor>
+        Create a new socket. Returns the new socket, or NULL if the new socket
+        could not be created. Note that the symbol zsock_new (and other
+        constructors/destructors for zsock) are redirected to the *_checked
+        variant, enabling intelligent socket leak detection. This can have
+        performance implications if you use a LOT of sockets. To turn off this
+        redirection behaviour, define ZSOCK_NOCHECK.
+        <argument name = "type" type = "integer">
+            <!-- Allow text names in binding APIs -->
+            <map name = "PAIR" value = "ZMQ_PAIR" />
+            <map name = "PUB"  value = "ZMQ_PUB" />
+            <map name = "SUB"  value = "ZMQ_SUB" />
+            <map name = "REQ"  value = "ZMQ_REQ" />
+            <map name = "REP"  value = "ZMQ_REP" />
+            <map name = "DEALER"  value = "ZMQ_DEALER" />
+            <map name = "ROUTER"  value = "ZMQ_ROUTER" />
+            <map name = "PULL"  value = "ZMQ_PULL" />
+            <map name = "PUSH"  value = "ZMQ_PUSH" />
+            <map name = "XPUB"  value = "ZMQ_XPUB" />
+            <map name = "XSUB"  value = "ZMQ_XSUB" />
+            <!-- These macros only exist in 4.x, so use the magic values instead -->
+            <map name = "STREAM"  value = "11" />
+            <map name = "SERVER"  value = "12" />
+            <map name = "CLIENT"  value = "13" />
+            <map name = "RADIO"  value = "14" />
+            <map name = "DISH"  value = "15" />
+            <map name = "GATHER"  value = "16" />
+            <map name = "SCATTER"  value = "17" />
+        </argument>
+    </constructor>
+
+    <destructor>
+        Destroy the socket. You must use this for any socket created via the
+        zsock_new method.
+    </destructor>
+
+    <constructor name = "new pub">
+        Create a PUB socket. Default action is bind.
+        <argument name = "endpoint" type = "string" />
+    </constructor>
+
+    <constructor name = "new sub">
+        Create a SUB socket, and optionally subscribe to some prefix string. Default
+        action is connect.
+        <argument name = "endpoint" type = "string" />
+        <argument name = "subscribe" type = "string" />
+    </constructor>
+
+    <constructor name = "new req">
+        Create a REQ socket. Default action is connect.
+        <argument name = "endpoint" type = "string" />
+    </constructor>
+
+    <constructor name = "new rep">
+        Create a REP socket. Default action is bind.
+        <argument name = "endpoint" type = "string" />
+    </constructor>
+
+    <constructor name = "new dealer">
+        Create a DEALER socket. Default action is connect.
+        <argument name = "endpoint" type = "string" />
+    </constructor>
+
+    <constructor name = "new router">
+        Create a ROUTER socket. Default action is bind.
+        <argument name = "endpoint" type = "string" />
+    </constructor>
+
+    <constructor name = "new push">
+        Create a PUSH socket. Default action is connect.
+        <argument name = "endpoint" type = "string" />
+    </constructor>
+
+    <constructor name = "new pull">
+        Create a PULL socket. Default action is bind.
+        <argument name = "endpoint" type = "string" />
+    </constructor>
+
+    <constructor name = "new xpub">
+        Create an XPUB socket. Default action is bind.
+        <argument name = "endpoint" type = "string" />
+    </constructor>
+
+    <constructor name = "new xsub">
+        Create an XSUB socket. Default action is connect.
+        <argument name = "endpoint" type = "string" />
+    </constructor>
+
+    <constructor name = "new pair">
+        Create a PAIR socket. Default action is connect.
+        <argument name = "endpoint" type = "string" />
+    </constructor>
+
+    <constructor name = "new stream">
+        Create a STREAM socket. Default action is connect.
+        <argument name = "endpoint" type = "string" />
+    </constructor>
+
+    <constructor name = "new server" state = "draft">
+        Create a SERVER socket. Default action is bind.
+        <argument name = "endpoint" type = "string" />
+    </constructor>
+
+    <constructor name = "new client" state = "draft">
+        Create a CLIENT socket. Default action is connect.
+        <argument name = "endpoint" type = "string" />
+    </constructor>
+
+    <constructor name = "new radio" state = "draft">
+        Create a RADIO socket. Default action is bind.
+        <argument name = "endpoint" type = "string" />
+    </constructor>
+
+    <constructor name = "new dish" state = "draft">
+        Create a DISH socket. Default action is connect.
+        <argument name = "endpoint" type = "string" />
+    </constructor>
+
+    <constructor name = "new gather" state = "draft">
+        Create a GATHER socket. Default action is bind.
+        <argument name = "endpoint" type = "string" />
+    </constructor>
+
+    <constructor name = "new scatter" state = "draft">
+        Create a SCATTER socket. Default action is connect.
+        <argument name = "endpoint" type = "string" />
+    </constructor>
+
+    <method name = "bind">
+        Bind a socket to a formatted endpoint. For tcp:// endpoints, supports
+        ephemeral ports, if you specify the port number as "*". By default
+        zsock uses the IANA designated range from C000 (49152) to FFFF (65535).
+        To override this range, follow the "*" with "[first-last]". Either or
+        both first and last may be empty. To bind to a random port within the
+        range, use "!" in place of "*".
+
+        Examples:
+            tcp://127.0.0.1:*           bind to first free port from C000 up
+            tcp://127.0.0.1:!           bind to random port from C000 to FFFF
+            tcp://127.0.0.1:*[60000-]   bind to first free port from 60000 up
+            tcp://127.0.0.1:![-60000]   bind to random port from C000 to 60000
+            tcp://127.0.0.1:![55000-55999]
+                                        bind to random port from 55000 to 55999
+
+        On success, returns the actual port number used, for tcp:// endpoints,
+        and 0 for other transports. On failure, returns -1. Note that when using
+        ephemeral ports, a port may be reused by different services without
+        clients being aware. Protocols that run on ephemeral ports should take
+        this into account.
+        <argument name = "format" type = "format" />
+        <return type = "integer" />
+    </method>
+
+    <method name = "endpoint">
+        Returns last bound endpoint, if any.
+        <return type = "string" />
+    </method>
+
+    <method name = "unbind">
+        Unbind a socket from a formatted endpoint.
+        Returns 0 if OK, -1 if the endpoint was invalid or the function
+        isn't supported.
+        <argument name = "format" type = "format" />
+        <return type = "integer" />
+    </method>
+
+    <method name = "connect">
+        Connect a socket to a formatted endpoint
+        Returns 0 if OK, -1 if the endpoint was invalid.
+        <argument name = "format" type = "format" />
+        <return type = "integer" />
+    </method>
+
+    <method name = "disconnect">
+        Disconnect a socket from a formatted endpoint
+        Returns 0 if OK, -1 if the endpoint was invalid or the function
+        isn't supported.
+        <argument name = "format" type = "format" />
+        <return type = "integer" />
+    </method>
+
+    <method name = "attach">
+        Attach a socket to zero or more endpoints. If endpoints is not null,
+        parses as list of ZeroMQ endpoints, separated by commas, and prefixed by
+        '@' (to bind the socket) or '>' (to connect the socket). Returns 0 if all
+        endpoints were valid, or -1 if there was a syntax error. If the endpoint
+        does not start with '@' or '>', the serverish argument defines whether
+        it is used to bind (serverish = true) or connect (serverish = false).
+        <argument name = "endpoints" type = "string" />
+        <argument name = "serverish" type = "boolean" />
+        <return type = "integer" />
+    </method>
+
+    <method name = "type str">
+        Returns socket type as printable constant string.
+        <return type = "string" />
+    </method>
+
+    <method name = "send" polymorphic = "1">
+        Send a 'picture' message to the socket (or actor). The picture is a
+        string that defines the type of each frame. This makes it easy to send
+        a complex multiframe message in one call. The picture can contain any
+        of these characters, each corresponding to one or two arguments:
+
+            i = int (signed)
+            1 = uint8_t
+            2 = uint16_t
+            4 = uint32_t
+            8 = uint64_t
+            s = char *
+            b = byte *, size_t (2 arguments)
+            c = zchunk_t *
+            f = zframe_t *
+            h = zhashx_t *
+            U = zuuid_t *
+            p = void * (sends the pointer value, only meaningful over inproc)
+            m = zmsg_t * (sends all frames in the zmsg)
+            z = sends zero-sized frame (0 arguments)
+            u = uint (deprecated)
+
+        Note that s, b, c, and f are encoded the same way and the choice is
+        offered as a convenience to the sender, which may or may not already
+        have data in a zchunk or zframe. Does not change or take ownership of
+        any arguments. Returns 0 if successful, -1 if sending failed for any
+        reason.
+        <argument name = "picture" type = "string" variadic = "1" />
+        <return type = "integer" />
+    </method>
+
+    <method name = "vsend" polymorphic = "1">
+        Send a 'picture' message to the socket (or actor). This is a va_list
+        version of zsock_send (), so please consult its documentation for the
+        details.
+        <argument name = "picture" type = "string" />
+        <argument name = "argptr" type = "va_list" />
+        <return type = "integer" />
+    </method>
+
+    <method name = "recv" polymorphic = "1">
+        Receive a 'picture' message to the socket (or actor). See zsock_send for
+        the format and meaning of the picture. Returns the picture elements into
+        a series of pointers as provided by the caller:
+
+            i = int * (stores signed integer)
+            4 = uint32_t * (stores 32-bit unsigned integer)
+            8 = uint64_t * (stores 64-bit unsigned integer)
+            s = char ** (allocates new string)
+            b = byte **, size_t * (2 arguments) (allocates memory)
+            c = zchunk_t ** (creates zchunk)
+            f = zframe_t ** (creates zframe)
+            U = zuuid_t * (creates a zuuid with the data)
+            h = zhashx_t ** (creates zhashx)
+            p = void ** (stores pointer)
+            m = zmsg_t ** (creates a zmsg with the remaing frames)
+            z = null, asserts empty frame (0 arguments)
+            u = uint * (stores unsigned integer, deprecated)
+
+        Note that zsock_recv creates the returned objects, and the caller must
+        destroy them when finished with them. The supplied pointers do not need
+        to be initialized. Returns 0 if successful, or -1 if it failed to recv
+        a message, in which case the pointers are not modified. When message
+        frames are truncated (a short message), sets return values to zero/null.
+        If an argument pointer is NULL, does not store any value (skips it).
+        An 'n' picture matches an empty frame; if the message does not match,
+        the method will return -1.
+        <argument name = "picture" type = "string" variadic = "1" />
+        <return type = "integer" />
+    </method>
+
+    <method name = "vrecv" polymorphic = "1">
+        Receive a 'picture' message from the socket (or actor). This is a
+        va_list version of zsock_recv (), so please consult its documentation
+        for the details.
+        <argument name = "picture" type = "string" />
+        <argument name = "argptr" type = "va_list" />
+        <return type = "integer" />
+    </method>
+
+    <method name = "bsend" polymorphic = "1">
+        Send a binary encoded 'picture' message to the socket (or actor). This
+        method is similar to zsock_send, except the arguments are encoded in a
+        binary format that is compatible with zproto, and is designed to reduce
+        memory allocations. The pattern argument is a string that defines the
+        type of each argument. Supports these argument types:
+
+         pattern    C type                  zproto type:
+            1       uint8_t                 type = "number" size = "1"
+            2       uint16_t                type = "number" size = "2"
+            4       uint32_t                type = "number" size = "3"
+            8       uint64_t                type = "number" size = "4"
+            s       char *, 0-255 chars     type = "string"
+            S       char *, 0-2^32-1 chars  type = "longstr"
+            c       zchunk_t *              type = "chunk"
+            f       zframe_t *              type = "frame"
+            u       zuuid_t *               type = "uuid"
+            m       zmsg_t *                type = "msg"
+            p       void *, sends pointer value, only over inproc
+
+        Does not change or take ownership of any arguments. Returns 0 if
+        successful, -1 if sending failed for any reason.
+        <argument name = "picture" type = "string" variadic = "1" />
+        <return type = "integer" />
+    </method>
+
+    <method name = "brecv" polymorphic = "1">
+        Receive a binary encoded 'picture' message from the socket (or actor).
+        This method is similar to zsock_recv, except the arguments are encoded
+        in a binary format that is compatible with zproto, and is designed to
+        reduce memory allocations. The pattern argument is a string that defines
+        the type of each argument. See zsock_bsend for the supported argument
+        types. All arguments must be pointers; this call sets them to point to
+        values held on a per-socket basis.
+        For types 1, 2, 4 and 8 the caller must allocate the memory itself before
+        calling zsock_brecv.
+        For types S, the caller must free the value once finished with it, as
+        zsock_brecv will allocate the buffer.
+        For type s, the caller must not free the value as it is stored in a
+        local cache for performance purposes.
+        For types c, f, u and m the caller must call the appropriate destructor
+        depending on the object as zsock_brecv will create new objects.
+        For type p the caller must coordinate with the sender, as it is just a
+        pointer value being passed.
+        <argument name = "picture" type = "string" variadic = "1" />
+        <return type = "integer" />
+    </method>
+
+    <method name = "routing id" state = "draft">
+        Return socket routing ID if any. This returns 0 if the socket is not
+        of type ZMQ_SERVER or if no request was already received on it.
+        <return type = "number" size = "4" />
+    </method>
+
+    <method name = "set routing id" state = "draft">
+        Set routing ID on socket. The socket MUST be of type ZMQ_SERVER.
+        This will be used when sending messages on the socket via the zsock API.
+        <argument name = "routing id" type = "number" size = "4" />
+    </method>
+
+    <method name = "set unbounded" polymorphic = "1">
+        Set socket to use unbounded pipes (HWM=0); use this in cases when you are
+        totally certain the message volume can fit in memory. This method works
+        across all versions of ZeroMQ. Takes a polymorphic socket reference.
+    </method>
+
+    <method name = "signal" polymorphic = "1">
+        Send a signal over a socket. A signal is a short message carrying a
+        success/failure code (by convention, 0 means OK). Signals are encoded
+        to be distinguishable from "normal" messages. Accepts a zsock_t or a
+        zactor_t argument, and returns 0 if successful, -1 if the signal could
+        not be sent. Takes a polymorphic socket reference.
+        <argument name = "status" type = "byte" />
+        <return type = "integer" />
+    </method>
+
+    <method name = "wait" polymorphic = "1">
+        Wait on a signal. Use this to coordinate between threads, over pipe
+        pairs. Blocks until the signal is received. Returns -1 on error, 0 or
+        greater on success. Accepts a zsock_t or a zactor_t as argument.
+        Takes a polymorphic socket reference.
+        <return type = "integer" />
+    </method>
+
+    <method name = "flush" polymorphic = "1">
+        If there is a partial message still waiting on the socket, remove and
+        discard it. This is useful when reading partial messages, to get specific
+        message types.
+    </method>
+
+    <method name = "join" state = "draft"  polymorphic = "1">
+        Join a group for the RADIO-DISH pattern. Call only on ZMQ_DISH.
+        Returns 0 if OK, -1 if failed.
+        <argument name = "group" type = "string" />
+        <return type = "integer" />
+    </method>
+
+    <method name = "leave" state = "draft"  polymorphic = "1">
+        Leave a group for the RADIO-DISH pattern. Call only on ZMQ_DISH.
+        Returns 0 if OK, -1 if failed.
+        <argument name = "group" type = "string" />
+        <return type = "integer" />
+    </method>
+
+    <method name = "is" singleton = "1">
+        Probe the supplied object, and report if it looks like a zsock_t.
+        Takes a polymorphic socket reference.
+        <argument name = "self" type = "anything" />
+        <return type = "boolean" />
+    </method>
+
+    <method name = "resolve" singleton = "1" polymorphic = "1">
+        Probe the supplied reference. If it looks like a zsock_t instance, return
+        the underlying libzmq socket handle; else if it looks like a file
+        descriptor, return NULL; else if it looks like a libzmq socket handle,
+        return the supplied value. Takes a polymorphic socket reference.
+        <argument name = "self" type = "anything" />
+        <return type = "anything" />
+    </method>
+
+    <include filename = "zsock_option.api" />
+</class>