laag-libczmq 4.1.0.0

data/vendor/github.com/zeromq/czmq/bindings/qml/src/QmlZframe.h

@@ -0,0 +1,143 @@
+/*
+################################################################################
+#  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_ZFRAME_H
+#define QML_ZFRAME_H
+
+#include <QtQml>
+
+#include <czmq.h>
+#include "qml_czmq_plugin.h"
+
+
+class QmlZframe : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(bool isNULL READ isNULL)
+
+public:
+    zframe_t *self;
+
+    QmlZframe() { self = NULL; }
+    bool isNULL() { return self == NULL; }
+
+    static QObject* qmlAttachedProperties(QObject* object); // defined in QmlZframe.cpp
+
+public slots:
+    //  Return number of bytes in frame data
+    size_t size ();
+
+    //  Return address of frame data
+    byte *data ();
+
+    //  Return meta data property for frame
+    //  The caller shall not modify or free the returned value, which shall be
+    //  owned by the message.
+    const QString meta (const QString &property);
+
+    //  Create a new frame that duplicates an existing frame. If frame is null,
+    //  or memory was exhausted, returns null.
+    QmlZframe *dup ();
+
+    //  Return frame data encoded as printable hex string, useful for 0MQ UUIDs.
+    //  Caller must free string when finished with it.
+    QString strhex ();
+
+    //  Return frame data copied into freshly allocated string
+    //  Caller must free string when finished with it.
+    QString strdup ();
+
+    //  Return TRUE if frame body is equal to string, excluding terminator
+    bool streq (const QString &string);
+
+    //  Return frame MORE indicator (1 or 0), set when reading frame from socket
+    //  or by the zframe_set_more() method
+    int more ();
+
+    //  Set frame MORE indicator (1 or 0). Note this is NOT used when sending
+    //  frame to socket, you have to specify flag explicitly.
+    void setMore (int more);
+
+    //  Return frame routing ID, if the frame came from a ZMQ_SERVER socket.
+    //  Else returns zero.
+    uint32_t routingId ();
+
+    //  Set routing ID on frame. This is used if/when the frame is sent to a
+    //  ZMQ_SERVER socket.
+    void setRoutingId (uint32_t routingId);
+
+    //  Return frame group of radio-dish pattern.
+    const QString group ();
+
+    //  Set group on frame. This is used if/when the frame is sent to a
+    //  ZMQ_RADIO socket.
+    //  Return -1 on error, 0 on success.
+    int setGroup (const QString &group);
+
+    //  Return TRUE if two frames have identical size and data
+    //  If either frame is NULL, equality is always false.
+    bool eq (QmlZframe *other);
+
+    //  Set new contents for frame
+    void reset (const void *data, size_t size);
+
+    //  Send message to zsys log sink (may be stdout, or system facility as
+    //  configured by zsys_set_logstream). Prefix shows before frame, if not null.
+    void print (const QString &prefix);
+};
+
+class QmlZframeAttached : public QObject
+{
+    Q_OBJECT
+    QObject* m_attached;
+
+public:
+    QmlZframeAttached (QObject* attached) {
+        Q_UNUSED (attached);
+    };
+
+public slots:
+    //  Send a frame to a socket, destroy frame after sending.
+    //  Return -1 on error, 0 on success.
+    int send (QmlZframe *selfP, void *dest, int flags);
+
+    //  Probe the supplied object, and report if it looks like a zframe_t.
+    bool is (void *self);
+
+    //  Self test of this class.
+    void test (bool verbose);
+
+    //  Create a new frame. If size is not null, allocates the frame data
+    //  to the specified size. If additionally, data is not null, copies
+    //  size octets from the specified data into the frame body.
+    QmlZframe *construct (const void *data, size_t size);
+
+    //  Create an empty (zero-sized) frame
+    QmlZframe *constructEmpty ();
+
+    //  Create a frame with a specified string content.
+    QmlZframe *from (const QString &string);
+
+    //  Receive frame from socket, returns zframe_t object or NULL if the recv
+    //  was interrupted. Does a blocking recv, if you want to not block then use
+    //  zpoller or zloop.
+    QmlZframe *recv (void *source);
+
+    //  Destroy a frame
+    void destruct (QmlZframe *qmlSelf);
+};
+
+
+QML_DECLARE_TYPEINFO(QmlZframe, 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/QmlZhash.cpp

@@ -0,0 +1,219 @@
+/*
+################################################################################
+#  THIS FILE IS 100% GENERATED BY ZPROJECT; DO NOT EDIT EXCEPT EXPERIMENTALLY  #
+#  Read the zproject/README.md for information about making permanent changes. #
+################################################################################
+*/
+
+#include "QmlZhash.h"
+
+
+///
+//  Insert item into hash table with specified key and item.
+//  If key is already present returns -1 and leaves existing item unchanged
+//  Returns 0 on success.
+int QmlZhash::insert (const QString &key, void *item) {
+    return zhash_insert (self, key.toUtf8().data(), item);
+};
+
+///
+//  Update item into hash table with specified key and item.
+//  If key is already present, destroys old item and inserts new one.
+//  Use free_fn method to ensure deallocator is properly called on item.
+void QmlZhash::update (const QString &key, void *item) {
+    zhash_update (self, key.toUtf8().data(), item);
+};
+
+///
+//  Remove an item specified by key from the hash table. If there was no such
+//  item, this function does nothing.
+void QmlZhash::delete (const QString &key) {
+    zhash_delete (self, key.toUtf8().data());
+};
+
+///
+//  Return the item at the specified key, or null
+void *QmlZhash::lookup (const QString &key) {
+    return zhash_lookup (self, key.toUtf8().data());
+};
+
+///
+//  Reindexes an item from an old key to a new key. If there was no such
+//  item, does nothing. Returns 0 if successful, else -1.
+int QmlZhash::rename (const QString &oldKey, const QString &newKey) {
+    return zhash_rename (self, oldKey.toUtf8().data(), newKey.toUtf8().data());
+};
+
+///
+//  Set a free function for the specified hash table item. When the item is
+//  destroyed, the free function, if any, is called on that item.
+//  Use this when hash items are dynamically allocated, to ensure that
+//  you don't have memory leaks. You can pass 'free' or NULL as a free_fn.
+//  Returns the item, or NULL if there is no such item.
+void *QmlZhash::freefn (const QString &key, zhash_free_fn freeFn) {
+    return zhash_freefn (self, key.toUtf8().data(), freeFn);
+};
+
+///
+//  Return the number of keys/items in the hash table
+size_t QmlZhash::size () {
+    return zhash_size (self);
+};
+
+///
+//  Make copy of hash table; if supplied table is null, returns null.
+//  Does not copy items themselves. Rebuilds new table so may be slow on
+//  very large tables. NOTE: only works with item values that are strings
+//  since there's no other way to know how to duplicate the item value.
+QmlZhash *QmlZhash::dup () {
+    QmlZhash *retQ_ = new QmlZhash ();
+    retQ_->self = zhash_dup (self);
+    return retQ_;
+};
+
+///
+//  Return keys for items in table
+QmlZlist *QmlZhash::keys () {
+    QmlZlist *retQ_ = new QmlZlist ();
+    retQ_->self = zhash_keys (self);
+    return retQ_;
+};
+
+///
+//  Simple iterator; returns first item in hash table, in no given order,
+//  or NULL if the table is empty. This method is simpler to use than the
+//  foreach() method, which is deprecated. To access the key for this item
+//  use zhash_cursor(). NOTE: do NOT modify the table while iterating.
+void *QmlZhash::first () {
+    return zhash_first (self);
+};
+
+///
+//  Simple iterator; returns next item in hash table, in no given order,
+//  or NULL if the last item was already returned. Use this together with
+//  zhash_first() to process all items in a hash table. If you need the
+//  items in sorted order, use zhash_keys() and then zlist_sort(). To
+//  access the key for this item use zhash_cursor(). NOTE: do NOT modify
+//  the table while iterating.
+void *QmlZhash::next () {
+    return zhash_next (self);
+};
+
+///
+//  After a successful first/next method, returns the key for the item that
+//  was returned. This is a constant string that you may not modify or
+//  deallocate, and which lasts as long as the item in the hash. After an
+//  unsuccessful first/next, returns NULL.
+const QString QmlZhash::cursor () {
+    return QString (zhash_cursor (self));
+};
+
+///
+//  Add a comment to hash table before saving to disk. You can add as many
+//  comment lines as you like. These comment lines are discarded when loading
+//  the file. If you use a null format, all comments are deleted.
+void QmlZhash::comment (const QString &format) {
+    zhash_comment (self, "%s", format.toUtf8().data());
+};
+
+///
+//  Serialize hash table to a binary frame that can be sent in a message.
+//  The packed format is compatible with the 'dictionary' type defined in
+//  http://rfc.zeromq.org/spec:35/FILEMQ, and implemented by zproto:
+//
+//     ; A list of name/value pairs
+//     dictionary      = dict-count *( dict-name dict-value )
+//     dict-count      = number-4
+//     dict-value      = longstr
+//     dict-name       = string
+//
+//     ; Strings are always length + text contents
+//     longstr         = number-4 *VCHAR
+//     string          = number-1 *VCHAR
+//
+//     ; Numbers are unsigned integers in network byte order
+//     number-1        = 1OCTET
+//     number-4        = 4OCTET
+//
+//  Comments are not included in the packed data. Item values MUST be
+//  strings.
+QmlZframe *QmlZhash::pack () {
+    QmlZframe *retQ_ = new QmlZframe ();
+    retQ_->self = zhash_pack (self);
+    return retQ_;
+};
+
+///
+//  Save hash table to a text file in name=value format. Hash values must be
+//  printable strings; keys may not contain '=' character. Returns 0 if OK,
+//  else -1 if a file error occurred.
+int QmlZhash::save (const QString &filename) {
+    return zhash_save (self, filename.toUtf8().data());
+};
+
+///
+//  Load hash table from a text file in name=value format; hash table must
+//  already exist. Hash values must printable strings; keys may not contain
+//  '=' character. Returns 0 if OK, else -1 if a file was not readable.
+int QmlZhash::load (const QString &filename) {
+    return zhash_load (self, filename.toUtf8().data());
+};
+
+///
+//  When a hash table was loaded from a file by zhash_load, this method will
+//  reload the file if it has been modified since, and is "stable", i.e. not
+//  still changing. Returns 0 if OK, -1 if there was an error reloading the
+//  file.
+int QmlZhash::refresh () {
+    return zhash_refresh (self);
+};
+
+///
+//  Set hash for automatic value destruction. Note that this assumes that
+//  values are NULL-terminated strings. Do not use with different types.
+void QmlZhash::autofree () {
+    zhash_autofree (self);
+};
+
+
+QObject* QmlZhash::qmlAttachedProperties(QObject* object) {
+    return new QmlZhashAttached(object);
+}
+
+
+///
+//  Self test of this class.
+void QmlZhashAttached::test (bool verbose) {
+    zhash_test (verbose);
+};
+
+///
+//  Create a new, empty hash container
+QmlZhash *QmlZhashAttached::construct () {
+    QmlZhash *qmlSelf = new QmlZhash ();
+    qmlSelf->self = zhash_new ();
+    return qmlSelf;
+};
+
+///
+//  Unpack binary frame into a new hash table. Packed data must follow format
+//  defined by zhash_pack. Hash table is set to autofree. An empty frame
+//  unpacks to an empty hash table.
+QmlZhash *QmlZhashAttached::unpack (QmlZframe *frame) {
+    QmlZhash *qmlSelf = new QmlZhash ();
+    qmlSelf->self = zhash_unpack (frame->self);
+    return qmlSelf;
+};
+
+///
+//  Destroy a hash container and all items in it
+void QmlZhashAttached::destruct (QmlZhash *qmlSelf) {
+    zhash_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/QmlZhash.h

@@ -0,0 +1,174 @@
+/*
+################################################################################
+#  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_ZHASH_H
+#define QML_ZHASH_H
+
+#include <QtQml>
+
+#include <czmq.h>
+#include "qml_czmq_plugin.h"
+
+
+class QmlZhash : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(bool isNULL READ isNULL)
+
+public:
+    zhash_t *self;
+
+    QmlZhash() { self = NULL; }
+    bool isNULL() { return self == NULL; }
+
+    static QObject* qmlAttachedProperties(QObject* object); // defined in QmlZhash.cpp
+
+public slots:
+    //  Insert item into hash table with specified key and item.
+    //  If key is already present returns -1 and leaves existing item unchanged
+    //  Returns 0 on success.
+    int insert (const QString &key, void *item);
+
+    //  Update item into hash table with specified key and item.
+    //  If key is already present, destroys old item and inserts new one.
+    //  Use free_fn method to ensure deallocator is properly called on item.
+    void update (const QString &key, void *item);
+
+    //  Remove an item specified by key from the hash table. If there was no such
+    //  item, this function does nothing.
+    void delete (const QString &key);
+
+    //  Return the item at the specified key, or null
+    void *lookup (const QString &key);
+
+    //  Reindexes an item from an old key to a new key. If there was no such
+    //  item, does nothing. Returns 0 if successful, else -1.
+    int rename (const QString &oldKey, const QString &newKey);
+
+    //  Set a free function for the specified hash table item. When the item is
+    //  destroyed, the free function, if any, is called on that item.
+    //  Use this when hash items are dynamically allocated, to ensure that
+    //  you don't have memory leaks. You can pass 'free' or NULL as a free_fn.
+    //  Returns the item, or NULL if there is no such item.
+    void *freefn (const QString &key, zhash_free_fn freeFn);
+
+    //  Return the number of keys/items in the hash table
+    size_t size ();
+
+    //  Make copy of hash table; if supplied table is null, returns null.
+    //  Does not copy items themselves. Rebuilds new table so may be slow on
+    //  very large tables. NOTE: only works with item values that are strings
+    //  since there's no other way to know how to duplicate the item value.
+    QmlZhash *dup ();
+
+    //  Return keys for items in table
+    QmlZlist *keys ();
+
+    //  Simple iterator; returns first item in hash table, in no given order,
+    //  or NULL if the table is empty. This method is simpler to use than the
+    //  foreach() method, which is deprecated. To access the key for this item
+    //  use zhash_cursor(). NOTE: do NOT modify the table while iterating.
+    void *first ();
+
+    //  Simple iterator; returns next item in hash table, in no given order,
+    //  or NULL if the last item was already returned. Use this together with
+    //  zhash_first() to process all items in a hash table. If you need the
+    //  items in sorted order, use zhash_keys() and then zlist_sort(). To
+    //  access the key for this item use zhash_cursor(). NOTE: do NOT modify
+    //  the table while iterating.
+    void *next ();
+
+    //  After a successful first/next method, returns the key for the item that
+    //  was returned. This is a constant string that you may not modify or
+    //  deallocate, and which lasts as long as the item in the hash. After an
+    //  unsuccessful first/next, returns NULL.
+    const QString cursor ();
+
+    //  Add a comment to hash table before saving to disk. You can add as many
+    //  comment lines as you like. These comment lines are discarded when loading
+    //  the file. If you use a null format, all comments are deleted.
+    void comment (const QString &format);
+
+    //  Serialize hash table to a binary frame that can be sent in a message.
+    //  The packed format is compatible with the 'dictionary' type defined in
+    //  http://rfc.zeromq.org/spec:35/FILEMQ, and implemented by zproto:
+    //
+    //     ; A list of name/value pairs
+    //     dictionary      = dict-count *( dict-name dict-value )
+    //     dict-count      = number-4
+    //     dict-value      = longstr
+    //     dict-name       = string
+    //
+    //     ; Strings are always length + text contents
+    //     longstr         = number-4 *VCHAR
+    //     string          = number-1 *VCHAR
+    //
+    //     ; Numbers are unsigned integers in network byte order
+    //     number-1        = 1OCTET
+    //     number-4        = 4OCTET
+    //
+    //  Comments are not included in the packed data. Item values MUST be
+    //  strings.
+    QmlZframe *pack ();
+
+    //  Save hash table to a text file in name=value format. Hash values must be
+    //  printable strings; keys may not contain '=' character. Returns 0 if OK,
+    //  else -1 if a file error occurred.
+    int save (const QString &filename);
+
+    //  Load hash table from a text file in name=value format; hash table must
+    //  already exist. Hash values must printable strings; keys may not contain
+    //  '=' character. Returns 0 if OK, else -1 if a file was not readable.
+    int load (const QString &filename);
+
+    //  When a hash table was loaded from a file by zhash_load, this method will
+    //  reload the file if it has been modified since, and is "stable", i.e. not
+    //  still changing. Returns 0 if OK, -1 if there was an error reloading the
+    //  file.
+    int refresh ();
+
+    //  Set hash for automatic value destruction. Note that this assumes that
+    //  values are NULL-terminated strings. Do not use with different types.
+    void autofree ();
+};
+
+class QmlZhashAttached : public QObject
+{
+    Q_OBJECT
+    QObject* m_attached;
+
+public:
+    QmlZhashAttached (QObject* attached) {
+        Q_UNUSED (attached);
+    };
+
+public slots:
+    //  Self test of this class.
+    void test (bool verbose);
+
+    //  Create a new, empty hash container
+    QmlZhash *construct ();
+
+    //  Unpack binary frame into a new hash table. Packed data must follow format
+    //  defined by zhash_pack. Hash table is set to autofree. An empty frame
+    //  unpacks to an empty hash table.
+    QmlZhash *unpack (QmlZframe *frame);
+
+    //  Destroy a hash container and all items in it
+    void destruct (QmlZhash *qmlSelf);
+};
+
+
+QML_DECLARE_TYPEINFO(QmlZhash, 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. #
+################################################################################
+*/