laag-libczmq 4.1.0.0

data/vendor/github.com/zeromq/czmq/bindings/python_cffi/czmq_cffi/Zloop.py

@@ -0,0 +1,171 @@
+################################################################################
+#  THIS FILE IS 100% GENERATED BY ZPROJECT; DO NOT EDIT EXCEPT EXPERIMENTALLY  #
+#  Read the zproject/README.md for information about making permanent changes. #
+################################################################################
+import utils
+from . import destructors
+libczmq_destructors = destructors.lib
+
+class Zloop(object):
+    """
+    event-driven reactor
+    """
+
+    def __init__(self):
+        """
+        Create a new zloop reactor
+        """
+        p = utils.lib.zloop_new()
+        if p == utils.ffi.NULL:
+            raise MemoryError("Could not allocate person")
+
+        # ffi.gc returns a copy of the cdata object which will have the
+        # destructor called when the Python object is GC'd:
+        # https://cffi.readthedocs.org/en/latest/using.html#ffi-interface
+        self._p = utils.ffi.gc(p, libczmq_destructors.zloop_destroy_py)
+
+    def reader(self, sock, handler, arg):
+        """
+        Register socket reader with the reactor. When the reader has messages,
+        the reactor will call the handler, passing the arg. Returns 0 if OK, -1
+        if there was an error. If you register the same socket more than once,
+        each instance will invoke its corresponding handler.
+        """
+        return utils.lib.zloop_reader(self._p, sock._p, handler, arg._p)
+
+    def reader_end(self, sock):
+        """
+        Cancel a socket reader from the reactor. If multiple readers exist for
+        same socket, cancels ALL of them.
+        """
+        utils.lib.zloop_reader_end(self._p, sock._p)
+
+    def reader_set_tolerant(self, sock):
+        """
+        Configure a registered reader to ignore errors. If you do not set this,
+        then readers that have errors are removed from the reactor silently.
+        """
+        utils.lib.zloop_reader_set_tolerant(self._p, sock._p)
+
+    def poller(self, item, handler, arg):
+        """
+        Register low-level libzmq pollitem with the reactor. When the pollitem
+        is ready, will call the handler, passing the arg. Returns 0 if OK, -1
+        if there was an error. If you register the pollitem more than once, each
+        instance will invoke its corresponding handler. A pollitem with
+        socket=NULL and fd=0 means 'poll on FD zero'.
+        """
+        return utils.lib.zloop_poller(self._p, item._p, handler, arg._p)
+
+    def poller_end(self, item):
+        """
+        Cancel a pollitem from the reactor, specified by socket or FD. If both
+        are specified, uses only socket. If multiple poll items exist for same
+        socket/FD, cancels ALL of them.
+        """
+        utils.lib.zloop_poller_end(self._p, item._p)
+
+    def poller_set_tolerant(self, item):
+        """
+        Configure a registered poller to ignore errors. If you do not set this,
+        then poller that have errors are removed from the reactor silently.
+        """
+        utils.lib.zloop_poller_set_tolerant(self._p, item._p)
+
+    def timer(self, delay, times, handler, arg):
+        """
+        Register a timer that expires after some delay and repeats some number of
+        times. At each expiry, will call the handler, passing the arg. To run a
+        timer forever, use 0 times. Returns a timer_id that is used to cancel the
+        timer in the future. Returns -1 if there was an error.
+        """
+        return utils.lib.zloop_timer(self._p, delay, times, handler, arg._p)
+
+    def timer_end(self, timer_id):
+        """
+        Cancel a specific timer identified by a specific timer_id (as returned by
+        zloop_timer).
+        """
+        return utils.lib.zloop_timer_end(self._p, timer_id)
+
+    def ticket(self, handler, arg):
+        """
+        Register a ticket timer. Ticket timers are very fast in the case where
+        you use a lot of timers (thousands), and frequently remove and add them.
+        The main use case is expiry timers for servers that handle many clients,
+        and which reset the expiry timer for each message received from a client.
+        Whereas normal timers perform poorly as the number of clients grows, the
+        cost of ticket timers is constant, no matter the number of clients. You
+        must set the ticket delay using zloop_set_ticket_delay before creating a
+        ticket. Returns a handle to the timer that you should use in
+        zloop_ticket_reset and zloop_ticket_delete.
+        """
+        return utils.lib.zloop_ticket(self._p, handler, arg._p)
+
+    def ticket_reset(self, handle):
+        """
+        Reset a ticket timer, which moves it to the end of the ticket list and
+        resets its execution time. This is a very fast operation.
+        """
+        utils.lib.zloop_ticket_reset(self._p, handle._p)
+
+    def ticket_delete(self, handle):
+        """
+        Delete a ticket timer. We do not actually delete the ticket here, as
+        other code may still refer to the ticket. We mark as deleted, and remove
+        later and safely.
+        """
+        utils.lib.zloop_ticket_delete(self._p, handle._p)
+
+    def set_ticket_delay(self, ticket_delay):
+        """
+        Set the ticket delay, which applies to all tickets. If you lower the
+        delay and there are already tickets created, the results are undefined.
+        """
+        utils.lib.zloop_set_ticket_delay(self._p, ticket_delay)
+
+    def set_max_timers(self, max_timers):
+        """
+        Set hard limit on number of timers allowed. Setting more than a small
+        number of timers (10-100) can have a dramatic impact on the performance
+        of the reactor. For high-volume cases, use ticket timers. If the hard
+        limit is reached, the reactor stops creating new timers and logs an
+        error.
+        """
+        utils.lib.zloop_set_max_timers(self._p, max_timers)
+
+    def set_verbose(self, verbose):
+        """
+        Set verbose tracing of reactor on/off. The default verbose setting is
+        off (false).
+        """
+        utils.lib.zloop_set_verbose(self._p, verbose)
+
+    def set_nonstop(self, nonstop):
+        """
+        By default the reactor stops if the process receives a SIGINT or SIGTERM
+        signal. This makes it impossible to shut-down message based architectures
+        like zactors. This method lets you switch off break handling. The default
+        nonstop setting is off (false).
+        """
+        utils.lib.zloop_set_nonstop(self._p, nonstop)
+
+    def start(self):
+        """
+        Start the reactor. Takes control of the thread and returns when the 0MQ
+        context is terminated or the process is interrupted, or any event handler
+        returns -1. Event handlers may register new sockets and timers, and
+        cancel sockets. Returns 0 if interrupted, -1 if canceled by a handler.
+        """
+        return utils.lib.zloop_start(self._p)
+
+    def test(verbose):
+        """
+        Self test of this class.
+        """
+        utils.lib.zloop_test(verbose)
+
+################################################################################
+#  THIS FILE IS 100% GENERATED BY ZPROJECT; DO NOT EDIT EXCEPT EXPERIMENTALLY  #
+#  Read the zproject/README.md for information about making permanent changes. #
+################################################################################

data/vendor/github.com/zeromq/czmq/bindings/python_cffi/czmq_cffi/Zmsg.py

@@ -0,0 +1,250 @@
+################################################################################
+#  THIS FILE IS 100% GENERATED BY ZPROJECT; DO NOT EDIT EXCEPT EXPERIMENTALLY  #
+#  Read the zproject/README.md for information about making permanent changes. #
+################################################################################
+import utils
+from . import destructors
+libczmq_destructors = destructors.lib
+
+class Zmsg(object):
+    """
+    working with multipart messages
+    """
+
+    def __init__(self):
+        """
+        Create a new empty message object
+        """
+        p = utils.lib.zmsg_new()
+        if p == utils.ffi.NULL:
+            raise MemoryError("Could not allocate person")
+
+        # ffi.gc returns a copy of the cdata object which will have the
+        # destructor called when the Python object is GC'd:
+        # https://cffi.readthedocs.org/en/latest/using.html#ffi-interface
+        self._p = utils.ffi.gc(p, libczmq_destructors.zmsg_destroy_py)
+
+    def send(self_p, dest):
+        """
+        Send message to destination socket, and destroy the message after sending
+        it successfully. If the message has no frames, sends nothing but destroys
+        the message anyhow. Nullifies the caller's reference to the message (as
+        it is a destructor).
+        """
+        return utils.lib.zmsg_send(self_p._p, dest._p)
+
+    def sendm(self_p, dest):
+        """
+        Send message to destination socket as part of a multipart sequence, and
+        destroy the message after sending it successfully. Note that after a
+        zmsg_sendm, you must call zmsg_send or another method that sends a final
+        message part. If the message has no frames, sends nothing but destroys
+        the message anyhow. Nullifies the caller's reference to the message (as
+        it is a destructor).
+        """
+        return utils.lib.zmsg_sendm(self_p._p, dest._p)
+
+    def size(self):
+        """
+        Return size of message, i.e. number of frames (0 or more).
+        """
+        return utils.lib.zmsg_size(self._p)
+
+    def content_size(self):
+        """
+        Return total size of all frames in message.
+        """
+        return utils.lib.zmsg_content_size(self._p)
+
+    def routing_id(self):
+        """
+        Return message routing ID, if the message came from a ZMQ_SERVER socket.
+        Else returns zero.
+        """
+        return utils.lib.zmsg_routing_id(self._p)
+
+    def set_routing_id(self, routing_id):
+        """
+        Set routing ID on message. This is used if/when the message is sent to a
+        ZMQ_SERVER socket.
+        """
+        utils.lib.zmsg_set_routing_id(self._p, routing_id)
+
+    def prepend(self, frame_p):
+        """
+        Push frame to the front of the message, i.e. before all other frames.
+        Message takes ownership of frame, will destroy it when message is sent.
+        Returns 0 on success, -1 on error. Deprecates zmsg_push, which did not
+        nullify the caller's frame reference.
+        """
+        return utils.lib.zmsg_prepend(self._p, frame_p._p)
+
+    def append(self, frame_p):
+        """
+        Add frame to the end of the message, i.e. after all other frames.
+        Message takes ownership of frame, will destroy it when message is sent.
+        Returns 0 on success. Deprecates zmsg_add, which did not nullify the
+        caller's frame reference.
+        """
+        return utils.lib.zmsg_append(self._p, frame_p._p)
+
+    def pop(self):
+        """
+        Remove first frame from message, if any. Returns frame, or NULL.
+        """
+        return utils.lib.zmsg_pop(self._p)
+
+    def pushmem(self, data, size):
+        """
+        Push block of memory to front of message, as a new frame.
+        Returns 0 on success, -1 on error.
+        """
+        return utils.lib.zmsg_pushmem(self._p, data, size)
+
+    def addmem(self, data, size):
+        """
+        Add block of memory to the end of the message, as a new frame.
+        Returns 0 on success, -1 on error.
+        """
+        return utils.lib.zmsg_addmem(self._p, data, size)
+
+    def pushstr(self, string):
+        """
+        Push string as new frame to front of message.
+        Returns 0 on success, -1 on error.
+        """
+        return utils.lib.zmsg_pushstr(self._p, utils.to_bytes(string))
+
+    def addstr(self, string):
+        """
+        Push string as new frame to end of message.
+        Returns 0 on success, -1 on error.
+        """
+        return utils.lib.zmsg_addstr(self._p, utils.to_bytes(string))
+
+    def pushstrf(self, format, ):
+        """
+        Push formatted string as new frame to front of message.
+        Returns 0 on success, -1 on error.
+        """
+        return utils.lib.zmsg_pushstrf(self._p, format, )
+
+    def addstrf(self, format, ):
+        """
+        Push formatted string as new frame to end of message.
+        Returns 0 on success, -1 on error.
+        """
+        return utils.lib.zmsg_addstrf(self._p, format, )
+
+    def popstr(self):
+        """
+        Pop frame off front of message, return as fresh string. If there were
+        no more frames in the message, returns NULL.
+        """
+        return utils.lib.zmsg_popstr(self._p)
+
+    def addmsg(self, msg_p):
+        """
+        Push encoded message as a new frame. Message takes ownership of
+        submessage, so the original is destroyed in this call. Returns 0 on
+        success, -1 on error.
+        """
+        return utils.lib.zmsg_addmsg(self._p, msg_p._p)
+
+    def popmsg(self):
+        """
+        Remove first submessage from message, if any. Returns zmsg_t, or NULL if
+        decoding was not successful.
+        """
+        return utils.lib.zmsg_popmsg(self._p)
+
+    def remove(self, frame):
+        """
+        Remove specified frame from list, if present. Does not destroy frame.
+        """
+        utils.lib.zmsg_remove(self._p, frame._p)
+
+    def first(self):
+        """
+        Set cursor to first frame in message. Returns frame, or NULL, if the
+        message is empty. Use this to navigate the frames as a list.
+        """
+        return utils.lib.zmsg_first(self._p)
+
+    def next(self):
+        """
+        Return the next frame. If there are no more frames, returns NULL. To move
+        to the first frame call zmsg_first(). Advances the cursor.
+        """
+        return utils.lib.zmsg_next(self._p)
+
+    def last(self):
+        """
+        Return the last frame. If there are no frames, returns NULL.
+        """
+        return utils.lib.zmsg_last(self._p)
+
+    def save(self, file):
+        """
+        Save message to an open file, return 0 if OK, else -1. The message is
+        saved as a series of frames, each with length and data. Note that the
+        file is NOT guaranteed to be portable between operating systems, not
+        versions of CZMQ. The file format is at present undocumented and liable
+        to arbitrary change.
+        """
+        return utils.lib.zmsg_save(self._p, file)
+
+    def encode(self):
+        """
+        Serialize multipart message to a single message frame. Use this method
+        to send structured messages across transports that do not support
+        multipart data. Allocates and returns a new frame containing the
+        serialized message. To decode a serialized message frame, use
+        zmsg_decode ().
+        """
+        return utils.lib.zmsg_encode(self._p)
+
+    def dup(self):
+        """
+        Create copy of message, as new message object. Returns a fresh zmsg_t
+        object. If message is null, or memory was exhausted, returns null.
+        """
+        return utils.lib.zmsg_dup(self._p)
+
+    def print_py(self):
+        """
+        Send message to zsys log sink (may be stdout, or system facility as
+        configured by zsys_set_logstream).
+        """
+        utils.lib.zmsg_print(self._p)
+
+    def eq(self, other):
+        """
+        Return true if the two messages have the same number of frames and each
+        frame in the first message is identical to the corresponding frame in the
+        other message. As with zframe_eq, return false if either message is NULL.
+        """
+        return utils.lib.zmsg_eq(self._p, other._p)
+
+    def signal(self):
+        """
+        Return signal value, 0 or greater, if message is a signal, -1 if not.
+        """
+        return utils.lib.zmsg_signal(self._p)
+
+    def is_py(self):
+        """
+        Probe the supplied object, and report if it looks like a zmsg_t.
+        """
+        return utils.lib.zmsg_is(self._p)
+
+    def test(verbose):
+        """
+        Self test of this class.
+        """
+        utils.lib.zmsg_test(verbose)
+
+################################################################################
+#  THIS FILE IS 100% GENERATED BY ZPROJECT; DO NOT EDIT EXCEPT EXPERIMENTALLY  #
+#  Read the zproject/README.md for information about making permanent changes. #
+################################################################################

data/vendor/github.com/zeromq/czmq/bindings/python_cffi/czmq_cffi/Zpoller.py

@@ -0,0 +1,89 @@
+################################################################################
+#  THIS FILE IS 100% GENERATED BY ZPROJECT; DO NOT EDIT EXCEPT EXPERIMENTALLY  #
+#  Read the zproject/README.md for information about making permanent changes. #
+################################################################################
+import utils
+from . import destructors
+libczmq_destructors = destructors.lib
+
+class Zpoller(object):
+    """
+    event-driven reactor
+    """
+
+    def __init__(self, reader, ):
+        """
+        Create new poller, specifying zero or more readers. The list of
+        readers ends in a NULL. Each reader can be a zsock_t instance, a
+        zactor_t instance, a libzmq socket (void *), or a file handle.
+        """
+        p = utils.lib.zpoller_new(reader._p, )
+        if p == utils.ffi.NULL:
+            raise MemoryError("Could not allocate person")
+
+        # ffi.gc returns a copy of the cdata object which will have the
+        # destructor called when the Python object is GC'd:
+        # https://cffi.readthedocs.org/en/latest/using.html#ffi-interface
+        self._p = utils.ffi.gc(p, libczmq_destructors.zpoller_destroy_py)
+
+    def add(self, reader):
+        """
+        Add a reader to be polled. Returns 0 if OK, -1 on failure. The reader may
+        be a libzmq void * socket, a zsock_t instance, or a zactor_t instance.
+        """
+        return utils.lib.zpoller_add(self._p, reader._p)
+
+    def remove(self, reader):
+        """
+        Remove a reader from the poller; returns 0 if OK, -1 on failure. The reader
+        must have been passed during construction, or in an zpoller_add () call.
+        """
+        return utils.lib.zpoller_remove(self._p, reader._p)
+
+    def set_nonstop(self, nonstop):
+        """
+        By default the poller stops if the process receives a SIGINT or SIGTERM
+        signal. This makes it impossible to shut-down message based architectures
+        like zactors. This method lets you switch off break handling. The default
+        nonstop setting is off (false).
+        """
+        utils.lib.zpoller_set_nonstop(self._p, nonstop)
+
+    def wait(self, timeout):
+        """
+        Poll the registered readers for I/O, return first reader that has input.
+        The reader will be a libzmq void * socket, or a zsock_t or zactor_t
+        instance as specified in zpoller_new/zpoller_add. The timeout should be
+        zero or greater, or -1 to wait indefinitely. Socket priority is defined
+        by their order in the poll list. If you need a balanced poll, use the low
+        level zmq_poll method directly. If the poll call was interrupted (SIGINT),
+        or the ZMQ context was destroyed, or the timeout expired, returns NULL.
+        You can test the actual exit condition by calling zpoller_expired () and
+        zpoller_terminated (). The timeout is in msec.
+        """
+        return utils.lib.zpoller_wait(self._p, timeout)
+
+    def expired(self):
+        """
+        Return true if the last zpoller_wait () call ended because the timeout
+        expired, without any error.
+        """
+        return utils.lib.zpoller_expired(self._p)
+
+    def terminated(self):
+        """
+        Return true if the last zpoller_wait () call ended because the process
+        was interrupted, or the parent context was destroyed.
+        """
+        return utils.lib.zpoller_terminated(self._p)
+
+    def test(verbose):
+        """
+        Self test of this class.
+        """
+        utils.lib.zpoller_test(verbose)
+
+################################################################################
+#  THIS FILE IS 100% GENERATED BY ZPROJECT; DO NOT EDIT EXCEPT EXPERIMENTALLY  #
+#  Read the zproject/README.md for information about making permanent changes. #
+################################################################################