laag-libczmq 4.1.0.0

data/vendor/github.com/zeromq/czmq/bindings/qml/src/QmlZlistx.cpp

@@ -0,0 +1,244 @@
+/*
+################################################################################
+#  THIS FILE IS 100% GENERATED BY ZPROJECT; DO NOT EDIT EXCEPT EXPERIMENTALLY  #
+#  Read the zproject/README.md for information about making permanent changes. #
+################################################################################
+*/
+
+#include "QmlZlistx.h"
+
+
+///
+//  Add an item to the head of the list. Calls the item duplicator, if any,
+//  on the item. Resets cursor to list head. Returns an item handle on
+//  success, NULL if memory was exhausted.
+void *QmlZlistx::addStart (void *item) {
+    return zlistx_add_start (self, item);
+};
+
+///
+//  Add an item to the tail of the list. Calls the item duplicator, if any,
+//  on the item. Resets cursor to list head. Returns an item handle on
+//  success, NULL if memory was exhausted.
+void *QmlZlistx::addEnd (void *item) {
+    return zlistx_add_end (self, item);
+};
+
+///
+//  Return the number of items in the list
+size_t QmlZlistx::size () {
+    return zlistx_size (self);
+};
+
+///
+//  Return first item in the list, or null, leaves the cursor
+void *QmlZlistx::head () {
+    return zlistx_head (self);
+};
+
+///
+//  Return last item in the list, or null, leaves the cursor
+void *QmlZlistx::tail () {
+    return zlistx_tail (self);
+};
+
+///
+//  Return the item at the head of list. If the list is empty, returns NULL.
+//  Leaves cursor pointing at the head item, or NULL if the list is empty.
+void *QmlZlistx::first () {
+    return zlistx_first (self);
+};
+
+///
+//  Return the next item. At the end of the list (or in an empty list),
+//  returns NULL. Use repeated zlistx_next () calls to work through the list
+//  from zlistx_first (). First time, acts as zlistx_first().
+void *QmlZlistx::next () {
+    return zlistx_next (self);
+};
+
+///
+//  Return the previous item. At the start of the list (or in an empty list),
+//  returns NULL. Use repeated zlistx_prev () calls to work through the list
+//  backwards from zlistx_last (). First time, acts as zlistx_last().
+void *QmlZlistx::prev () {
+    return zlistx_prev (self);
+};
+
+///
+//  Return the item at the tail of list. If the list is empty, returns NULL.
+//  Leaves cursor pointing at the tail item, or NULL if the list is empty.
+void *QmlZlistx::last () {
+    return zlistx_last (self);
+};
+
+///
+//  Returns the value of the item at the cursor, or NULL if the cursor is
+//  not pointing to an item.
+void *QmlZlistx::item () {
+    return zlistx_item (self);
+};
+
+///
+//  Returns the handle of the item at the cursor, or NULL if the cursor is
+//  not pointing to an item.
+void *QmlZlistx::cursor () {
+    return zlistx_cursor (self);
+};
+
+///
+//  Find an item in the list, searching from the start. Uses the item
+//  comparator, if any, else compares item values directly. Returns the
+//  item handle found, or NULL. Sets the cursor to the found item, if any.
+void *QmlZlistx::find (void *item) {
+    return zlistx_find (self, item);
+};
+
+///
+//  Detach an item from the list, using its handle. The item is not modified,
+//  and the caller is responsible for destroying it if necessary. If handle is
+//  null, detaches the first item on the list. Returns item that was detached,
+//  or null if none was. If cursor was at item, moves cursor to previous item,
+//  so you can detach items while iterating forwards through a list.
+void *QmlZlistx::detach (void *handle) {
+    return zlistx_detach (self, handle);
+};
+
+///
+//  Detach item at the cursor, if any, from the list. The item is not modified,
+//  and the caller is responsible for destroying it as necessary. Returns item
+//  that was detached, or null if none was. Moves cursor to previous item, so
+//  you can detach items while iterating forwards through a list.
+void *QmlZlistx::detachCur () {
+    return zlistx_detach_cur (self);
+};
+
+///
+//  Delete an item, using its handle. Calls the item destructor is any is
+//  set. If handle is null, deletes the first item on the list. Returns 0
+//  if an item was deleted, -1 if not. If cursor was at item, moves cursor
+//  to previous item, so you can delete items while iterating forwards
+//  through a list.
+int QmlZlistx::delete (void *handle) {
+    return zlistx_delete (self, handle);
+};
+
+///
+//  Move an item to the start of the list, via its handle.
+void QmlZlistx::moveStart (void *handle) {
+    zlistx_move_start (self, handle);
+};
+
+///
+//  Move an item to the end of the list, via its handle.
+void QmlZlistx::moveEnd (void *handle) {
+    zlistx_move_end (self, handle);
+};
+
+///
+//  Remove all items from the list, and destroy them if the item destructor
+//  is set.
+void QmlZlistx::purge () {
+    zlistx_purge (self);
+};
+
+///
+//  Sort the list. If an item comparator was set, calls that to compare
+//  items, otherwise compares on item value. The sort is not stable, so may
+//  reorder equal items.
+void QmlZlistx::sort () {
+    zlistx_sort (self);
+};
+
+///
+//  Create a new node and insert it into a sorted list. Calls the item
+//  duplicator, if any, on the item. If low_value is true, starts searching
+//  from the start of the list, otherwise searches from the end. Use the item
+//  comparator, if any, to find where to place the new node. Returns a handle
+//  to the new node, or NULL if memory was exhausted. Resets the cursor to the
+//  list head.
+void *QmlZlistx::insert (void *item, bool lowValue) {
+    return zlistx_insert (self, item, lowValue);
+};
+
+///
+//  Move an item, specified by handle, into position in a sorted list. Uses
+//  the item comparator, if any, to determine the new location. If low_value
+//  is true, starts searching from the start of the list, otherwise searches
+//  from the end.
+void QmlZlistx::reorder (void *handle, bool lowValue) {
+    zlistx_reorder (self, handle, lowValue);
+};
+
+///
+//  Make a copy of the list; items are duplicated if you set a duplicator
+//  for the list, otherwise not. Copying a null reference returns a null
+//  reference.
+QmlZlistx *QmlZlistx::dup () {
+    QmlZlistx *retQ_ = new QmlZlistx ();
+    retQ_->self = zlistx_dup (self);
+    return retQ_;
+};
+
+///
+//  Set a user-defined deallocator for list items; by default items are not
+//  freed when the list is destroyed.
+void QmlZlistx::setDestructor (zlistx_destructor_fn destructor) {
+    zlistx_set_destructor (self, destructor);
+};
+
+///
+//  Set a user-defined duplicator for list items; by default items are not
+//  copied when the list is duplicated.
+void QmlZlistx::setDuplicator (zlistx_duplicator_fn duplicator) {
+    zlistx_set_duplicator (self, duplicator);
+};
+
+///
+//  Set a user-defined comparator for zlistx_find and zlistx_sort; the method
+//  must return -1, 0, or 1 depending on whether item1 is less than, equal to,
+//  or greater than, item2.
+void QmlZlistx::setComparator (zlistx_comparator_fn comparator) {
+    zlistx_set_comparator (self, comparator);
+};
+
+
+QObject* QmlZlistx::qmlAttachedProperties(QObject* object) {
+    return new QmlZlistxAttached(object);
+}
+
+
+///
+//  Returns the item associated with the given list handle, or NULL if passed
+//  in handle is NULL. Asserts that the passed in handle points to a list element.
+void *QmlZlistxAttached::handleItem (void *handle) {
+    return zlistx_handle_item (handle);
+};
+
+///
+//  Self test of this class.
+void QmlZlistxAttached::test (bool verbose) {
+    zlistx_test (verbose);
+};
+
+///
+//  Create a new, empty list.
+QmlZlistx *QmlZlistxAttached::construct () {
+    QmlZlistx *qmlSelf = new QmlZlistx ();
+    qmlSelf->self = zlistx_new ();
+    return qmlSelf;
+};
+
+///
+//  Destroy a list. If an item destructor was specified, all items in the
+//  list are automatically destroyed as well.
+void QmlZlistxAttached::destruct (QmlZlistx *qmlSelf) {
+    zlistx_destroy (&qmlSelf->self);
+};
+
+/*
+################################################################################
+#  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/qml/src/QmlZlistx.h

@@ -0,0 +1,184 @@
+/*
+################################################################################
+#  THIS FILE IS 100% GENERATED BY ZPROJECT; DO NOT EDIT EXCEPT EXPERIMENTALLY  #
+#  Read the zproject/README.md for information about making permanent changes. #
+################################################################################
+*/
+
+#ifndef QML_ZLISTX_H
+#define QML_ZLISTX_H
+
+#include <QtQml>
+
+#include <czmq.h>
+#include "qml_czmq_plugin.h"
+
+
+class QmlZlistx : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(bool isNULL READ isNULL)
+
+public:
+    zlistx_t *self;
+
+    QmlZlistx() { self = NULL; }
+    bool isNULL() { return self == NULL; }
+
+    static QObject* qmlAttachedProperties(QObject* object); // defined in QmlZlistx.cpp
+
+public slots:
+    //  Add an item to the head of the list. Calls the item duplicator, if any,
+    //  on the item. Resets cursor to list head. Returns an item handle on
+    //  success, NULL if memory was exhausted.
+    void *addStart (void *item);
+
+    //  Add an item to the tail of the list. Calls the item duplicator, if any,
+    //  on the item. Resets cursor to list head. Returns an item handle on
+    //  success, NULL if memory was exhausted.
+    void *addEnd (void *item);
+
+    //  Return the number of items in the list
+    size_t size ();
+
+    //  Return first item in the list, or null, leaves the cursor
+    void *head ();
+
+    //  Return last item in the list, or null, leaves the cursor
+    void *tail ();
+
+    //  Return the item at the head of list. If the list is empty, returns NULL.
+    //  Leaves cursor pointing at the head item, or NULL if the list is empty.
+    void *first ();
+
+    //  Return the next item. At the end of the list (or in an empty list),
+    //  returns NULL. Use repeated zlistx_next () calls to work through the list
+    //  from zlistx_first (). First time, acts as zlistx_first().
+    void *next ();
+
+    //  Return the previous item. At the start of the list (or in an empty list),
+    //  returns NULL. Use repeated zlistx_prev () calls to work through the list
+    //  backwards from zlistx_last (). First time, acts as zlistx_last().
+    void *prev ();
+
+    //  Return the item at the tail of list. If the list is empty, returns NULL.
+    //  Leaves cursor pointing at the tail item, or NULL if the list is empty.
+    void *last ();
+
+    //  Returns the value of the item at the cursor, or NULL if the cursor is
+    //  not pointing to an item.
+    void *item ();
+
+    //  Returns the handle of the item at the cursor, or NULL if the cursor is
+    //  not pointing to an item.
+    void *cursor ();
+
+    //  Find an item in the list, searching from the start. Uses the item
+    //  comparator, if any, else compares item values directly. Returns the
+    //  item handle found, or NULL. Sets the cursor to the found item, if any.
+    void *find (void *item);
+
+    //  Detach an item from the list, using its handle. The item is not modified,
+    //  and the caller is responsible for destroying it if necessary. If handle is
+    //  null, detaches the first item on the list. Returns item that was detached,
+    //  or null if none was. If cursor was at item, moves cursor to previous item,
+    //  so you can detach items while iterating forwards through a list.
+    void *detach (void *handle);
+
+    //  Detach item at the cursor, if any, from the list. The item is not modified,
+    //  and the caller is responsible for destroying it as necessary. Returns item
+    //  that was detached, or null if none was. Moves cursor to previous item, so
+    //  you can detach items while iterating forwards through a list.
+    void *detachCur ();
+
+    //  Delete an item, using its handle. Calls the item destructor is any is
+    //  set. If handle is null, deletes the first item on the list. Returns 0
+    //  if an item was deleted, -1 if not. If cursor was at item, moves cursor
+    //  to previous item, so you can delete items while iterating forwards
+    //  through a list.
+    int delete (void *handle);
+
+    //  Move an item to the start of the list, via its handle.
+    void moveStart (void *handle);
+
+    //  Move an item to the end of the list, via its handle.
+    void moveEnd (void *handle);
+
+    //  Remove all items from the list, and destroy them if the item destructor
+    //  is set.
+    void purge ();
+
+    //  Sort the list. If an item comparator was set, calls that to compare
+    //  items, otherwise compares on item value. The sort is not stable, so may
+    //  reorder equal items.
+    void sort ();
+
+    //  Create a new node and insert it into a sorted list. Calls the item
+    //  duplicator, if any, on the item. If low_value is true, starts searching
+    //  from the start of the list, otherwise searches from the end. Use the item
+    //  comparator, if any, to find where to place the new node. Returns a handle
+    //  to the new node, or NULL if memory was exhausted. Resets the cursor to the
+    //  list head.
+    void *insert (void *item, bool lowValue);
+
+    //  Move an item, specified by handle, into position in a sorted list. Uses
+    //  the item comparator, if any, to determine the new location. If low_value
+    //  is true, starts searching from the start of the list, otherwise searches
+    //  from the end.
+    void reorder (void *handle, bool lowValue);
+
+    //  Make a copy of the list; items are duplicated if you set a duplicator
+    //  for the list, otherwise not. Copying a null reference returns a null
+    //  reference.
+    QmlZlistx *dup ();
+
+    //  Set a user-defined deallocator for list items; by default items are not
+    //  freed when the list is destroyed.
+    void setDestructor (zlistx_destructor_fn destructor);
+
+    //  Set a user-defined duplicator for list items; by default items are not
+    //  copied when the list is duplicated.
+    void setDuplicator (zlistx_duplicator_fn duplicator);
+
+    //  Set a user-defined comparator for zlistx_find and zlistx_sort; the method
+    //  must return -1, 0, or 1 depending on whether item1 is less than, equal to,
+    //  or greater than, item2.
+    void setComparator (zlistx_comparator_fn comparator);
+};
+
+class QmlZlistxAttached : public QObject
+{
+    Q_OBJECT
+    QObject* m_attached;
+
+public:
+    QmlZlistxAttached (QObject* attached) {
+        Q_UNUSED (attached);
+    };
+
+public slots:
+    //  Returns the item associated with the given list handle, or NULL if passed
+    //  in handle is NULL. Asserts that the passed in handle points to a list element.
+    void *handleItem (void *handle);
+
+    //  Self test of this class.
+    void test (bool verbose);
+
+    //  Create a new, empty list.
+    QmlZlistx *construct ();
+
+    //  Destroy a list. If an item destructor was specified, all items in the
+    //  list are automatically destroyed as well.
+    void destruct (QmlZlistx *qmlSelf);
+};
+
+
+QML_DECLARE_TYPEINFO(QmlZlistx, QML_HAS_ATTACHED_PROPERTIES)
+
+#endif
+/*
+################################################################################
+#  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/qml/src/QmlZloop.cpp

@@ -0,0 +1,177 @@
+/*
+################################################################################
+#  THIS FILE IS 100% GENERATED BY ZPROJECT; DO NOT EDIT EXCEPT EXPERIMENTALLY  #
+#  Read the zproject/README.md for information about making permanent changes. #
+################################################################################
+*/
+
+#include "QmlZloop.h"
+
+
+///
+//  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.
+int QmlZloop::reader (QmlZsock *sock, zloop_reader_fn handler, void *arg) {
+    return zloop_reader (self, sock->self, handler, arg);
+};
+
+///
+//  Cancel a socket reader from the reactor. If multiple readers exist for
+//  same socket, cancels ALL of them.
+void QmlZloop::readerEnd (QmlZsock *sock) {
+    zloop_reader_end (self, sock->self);
+};
+
+///
+//  Configure a registered reader to ignore errors. If you do not set this,
+//  then readers that have errors are removed from the reactor silently.
+void QmlZloop::readerSetTolerant (QmlZsock *sock) {
+    zloop_reader_set_tolerant (self, sock->self);
+};
+
+///
+//  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'.
+int QmlZloop::poller (zmq_pollitem_t *item, zloop_fn handler, void *arg) {
+    return zloop_poller (self, item, handler, arg);
+};
+
+///
+//  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.
+void QmlZloop::pollerEnd (zmq_pollitem_t *item) {
+    zloop_poller_end (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.
+void QmlZloop::pollerSetTolerant (zmq_pollitem_t *item) {
+    zloop_poller_set_tolerant (self, item);
+};
+
+///
+//  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.
+int QmlZloop::timer (size_t delay, size_t times, zloop_timer_fn handler, void *arg) {
+    return zloop_timer (self, delay, times, handler, arg);
+};
+
+///
+//  Cancel a specific timer identified by a specific timer_id (as returned by
+//  zloop_timer).
+int QmlZloop::timerEnd (int timerId) {
+    return zloop_timer_end (self, timerId);
+};
+
+///
+//  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.
+void *QmlZloop::ticket (zloop_timer_fn handler, void *arg) {
+    return zloop_ticket (self, handler, arg);
+};
+
+///
+//  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.
+void QmlZloop::ticketReset (void *handle) {
+    zloop_ticket_reset (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.
+void QmlZloop::ticketDelete (void *handle) {
+    zloop_ticket_delete (self, handle);
+};
+
+///
+//  Set the ticket delay, which applies to all tickets. If you lower the
+//  delay and there are already tickets created, the results are undefined.
+void QmlZloop::setTicketDelay (size_t ticketDelay) {
+    zloop_set_ticket_delay (self, ticketDelay);
+};
+
+///
+//  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.
+void QmlZloop::setMaxTimers (size_t maxTimers) {
+    zloop_set_max_timers (self, maxTimers);
+};
+
+///
+//  Set verbose tracing of reactor on/off. The default verbose setting is
+//  off (false).
+void QmlZloop::setVerbose (bool verbose) {
+    zloop_set_verbose (self, verbose);
+};
+
+///
+//  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).
+void QmlZloop::setNonstop (bool nonstop) {
+    zloop_set_nonstop (self, nonstop);
+};
+
+///
+//  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.
+int QmlZloop::start () {
+    return zloop_start (self);
+};
+
+
+QObject* QmlZloop::qmlAttachedProperties(QObject* object) {
+    return new QmlZloopAttached(object);
+}
+
+
+///
+//  Self test of this class.
+void QmlZloopAttached::test (bool verbose) {
+    zloop_test (verbose);
+};
+
+///
+//  Create a new zloop reactor
+QmlZloop *QmlZloopAttached::construct () {
+    QmlZloop *qmlSelf = new QmlZloop ();
+    qmlSelf->self = zloop_new ();
+    return qmlSelf;
+};
+
+///
+//  Destroy a reactor
+void QmlZloopAttached::destruct (QmlZloop *qmlSelf) {
+    zloop_destroy (&qmlSelf->self);
+};
+
+/*
+################################################################################
+#  THIS FILE IS 100% GENERATED BY ZPROJECT; DO NOT EDIT EXCEPT EXPERIMENTALLY  #
+#  Read the zproject/README.md for information about making permanent changes. #
+################################################################################
+*/