laag-libczmq 4.1.0.0

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

@@ -0,0 +1,209 @@
+/*
+################################################################################
+#  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_ZMSG_H
+#define QML_ZMSG_H
+
+#include <QtQml>
+
+#include <czmq.h>
+#include "qml_czmq_plugin.h"
+
+
+class QmlZmsg : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(bool isNULL READ isNULL)
+
+public:
+    zmsg_t *self;
+
+    QmlZmsg() { self = NULL; }
+    bool isNULL() { return self == NULL; }
+
+    static QObject* qmlAttachedProperties(QObject* object); // defined in QmlZmsg.cpp
+
+public slots:
+    //  Return size of message, i.e. number of frames (0 or more).
+    size_t size ();
+
+    //  Return total size of all frames in message.
+    size_t contentSize ();
+
+    //  Return message routing ID, if the message came from a ZMQ_SERVER socket.
+    //  Else returns zero.
+    uint32_t routingId ();
+
+    //  Set routing ID on message. This is used if/when the message is sent to a
+    //  ZMQ_SERVER socket.
+    void setRoutingId (uint32_t routingId);
+
+    //  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.
+    int prepend (QmlZframe *frameP);
+
+    //  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.
+    int append (QmlZframe *frameP);
+
+    //  Remove first frame from message, if any. Returns frame, or NULL.
+    QmlZframe *pop ();
+
+    //  Push block of memory to front of message, as a new frame.
+    //  Returns 0 on success, -1 on error.
+    int pushmem (const void *data, size_t size);
+
+    //  Add block of memory to the end of the message, as a new frame.
+    //  Returns 0 on success, -1 on error.
+    int addmem (const void *data, size_t size);
+
+    //  Push string as new frame to front of message.
+    //  Returns 0 on success, -1 on error.
+    int pushstr (const QString &string);
+
+    //  Push string as new frame to end of message.
+    //  Returns 0 on success, -1 on error.
+    int addstr (const QString &string);
+
+    //  Push formatted string as new frame to front of message.
+    //  Returns 0 on success, -1 on error.
+    int pushstrf (const QString &format);
+
+    //  Push formatted string as new frame to end of message.
+    //  Returns 0 on success, -1 on error.
+    int addstrf (const QString &format);
+
+    //  Pop frame off front of message, return as fresh string. If there were
+    //  no more frames in the message, returns NULL.
+    QString popstr ();
+
+    //  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.
+    int addmsg (QmlZmsg *msgP);
+
+    //  Remove first submessage from message, if any. Returns zmsg_t, or NULL if
+    //  decoding was not successful.
+    QmlZmsg *popmsg ();
+
+    //  Remove specified frame from list, if present. Does not destroy frame.
+    void remove (QmlZframe *frame);
+
+    //  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.
+    QmlZframe *first ();
+
+    //  Return the next frame. If there are no more frames, returns NULL. To move
+    //  to the first frame call zmsg_first(). Advances the cursor.
+    QmlZframe *next ();
+
+    //  Return the last frame. If there are no frames, returns NULL.
+    QmlZframe *last ();
+
+    //  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.
+    int save (FILE *file);
+
+    //  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 ().
+    QmlZframe *encode ();
+
+    //  Create copy of message, as new message object. Returns a fresh zmsg_t
+    //  object. If message is null, or memory was exhausted, returns null.
+    QmlZmsg *dup ();
+
+    //  Send message to zsys log sink (may be stdout, or system facility as
+    //  configured by zsys_set_logstream).
+    void print ();
+
+    //  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.
+    bool eq (QmlZmsg *other);
+
+    //  Return signal value, 0 or greater, if message is a signal, -1 if not.
+    int signal ();
+};
+
+class QmlZmsgAttached : public QObject
+{
+    Q_OBJECT
+    QObject* m_attached;
+
+public:
+    QmlZmsgAttached (QObject* attached) {
+        Q_UNUSED (attached);
+    };
+
+public slots:
+    //  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).
+    int send (QmlZmsg *selfP, void *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).
+    int sendm (QmlZmsg *selfP, void *dest);
+
+    //  Probe the supplied object, and report if it looks like a zmsg_t.
+    bool is (void *self);
+
+    //  Self test of this class.
+    void test (bool verbose);
+
+    //  Create a new empty message object
+    QmlZmsg *construct ();
+
+    //  Receive message from socket, returns zmsg_t object or NULL if the recv
+    //  was interrupted. Does a blocking recv. If you want to not block then use
+    //  the zloop class or zmsg_recv_nowait or zmq_poll to check for socket input
+    //  before receiving.
+    QmlZmsg *recv (void *source);
+
+    //  Load/append an open file into new message, return the message.
+    //  Returns NULL if the message could not be loaded.
+    QmlZmsg *load (FILE *file);
+
+    //  Decodes a serialized message frame created by zmsg_encode () and returns
+    //  a new zmsg_t object. Returns NULL if the frame was badly formatted or
+    //  there was insufficient memory to work.
+    QmlZmsg *decode (QmlZframe *frame);
+
+    //  Generate a signal message encoding the given status. A signal is a short
+    //  message carrying a 1-byte success/failure code (by convention, 0 means
+    //  OK). Signals are encoded to be distinguishable from "normal" messages.
+    QmlZmsg *constructSignal (byte status);
+
+    //  Destroy a message object and all frames it contains
+    void destruct (QmlZmsg *qmlSelf);
+};
+
+
+QML_DECLARE_TYPEINFO(QmlZmsg, 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/QmlZpoller.cpp

@@ -0,0 +1,95 @@
+/*
+################################################################################
+#  THIS FILE IS 100% GENERATED BY ZPROJECT; DO NOT EDIT EXCEPT EXPERIMENTALLY  #
+#  Read the zproject/README.md for information about making permanent changes. #
+################################################################################
+*/
+
+#include "QmlZpoller.h"
+
+
+///
+//  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.
+int QmlZpoller::add (void *reader) {
+    return zpoller_add (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.
+int QmlZpoller::remove (void *reader) {
+    return zpoller_remove (self, reader);
+};
+
+///
+//  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).
+void QmlZpoller::setNonstop (bool nonstop) {
+    zpoller_set_nonstop (self, nonstop);
+};
+
+///
+//  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.
+void *QmlZpoller::wait (int timeout) {
+    return zpoller_wait (self, timeout);
+};
+
+///
+//  Return true if the last zpoller_wait () call ended because the timeout
+//  expired, without any error.
+bool QmlZpoller::expired () {
+    return zpoller_expired (self);
+};
+
+///
+//  Return true if the last zpoller_wait () call ended because the process
+//  was interrupted, or the parent context was destroyed.
+bool QmlZpoller::terminated () {
+    return zpoller_terminated (self);
+};
+
+
+QObject* QmlZpoller::qmlAttachedProperties(QObject* object) {
+    return new QmlZpollerAttached(object);
+}
+
+
+///
+//  Self test of this class.
+void QmlZpollerAttached::test (bool verbose) {
+    zpoller_test (verbose);
+};
+
+///
+//  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.
+QmlZpoller *QmlZpollerAttached::construct (void *reader) {
+    QmlZpoller *qmlSelf = new QmlZpoller ();
+    qmlSelf->self = zpoller_new (reader);
+    return qmlSelf;
+};
+
+///
+//  Destroy a poller
+void QmlZpollerAttached::destruct (QmlZpoller *qmlSelf) {
+    zpoller_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/QmlZpoller.h

@@ -0,0 +1,97 @@
+/*
+################################################################################
+#  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_ZPOLLER_H
+#define QML_ZPOLLER_H
+
+#include <QtQml>
+
+#include <czmq.h>
+#include "qml_czmq_plugin.h"
+
+
+class QmlZpoller : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(bool isNULL READ isNULL)
+
+public:
+    zpoller_t *self;
+
+    QmlZpoller() { self = NULL; }
+    bool isNULL() { return self == NULL; }
+
+    static QObject* qmlAttachedProperties(QObject* object); // defined in QmlZpoller.cpp
+
+public slots:
+    //  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.
+    int add (void *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.
+    int remove (void *reader);
+
+    //  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).
+    void setNonstop (bool nonstop);
+
+    //  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.
+    void *wait (int timeout);
+
+    //  Return true if the last zpoller_wait () call ended because the timeout
+    //  expired, without any error.
+    bool expired ();
+
+    //  Return true if the last zpoller_wait () call ended because the process
+    //  was interrupted, or the parent context was destroyed.
+    bool terminated ();
+};
+
+class QmlZpollerAttached : public QObject
+{
+    Q_OBJECT
+    QObject* m_attached;
+
+public:
+    QmlZpollerAttached (QObject* attached) {
+        Q_UNUSED (attached);
+    };
+
+public slots:
+    //  Self test of this class.
+    void test (bool verbose);
+
+    //  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.
+    QmlZpoller *construct (void *reader);
+
+    //  Destroy a poller
+    void destruct (QmlZpoller *qmlSelf);
+};
+
+
+QML_DECLARE_TYPEINFO(QmlZpoller, 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/QmlZproc.cpp

@@ -0,0 +1,296 @@
+/*
+################################################################################
+#  THIS FILE IS 100% GENERATED BY ZPROJECT; DO NOT EDIT EXCEPT EXPERIMENTALLY  #
+#  Read the zproject/README.md for information about making permanent changes. #
+################################################################################
+*/
+
+#include "QmlZproc.h"
+
+
+///
+//  Setup the command line arguments, the first item must be an (absolute) filename
+//  to run.
+void QmlZproc::setArgs (QmlZlistx *args) {
+    zproc_set_args (self, args->self);
+};
+
+///
+//  Setup the environment variables for the process.
+void QmlZproc::setEnv (QmlZhashx *args) {
+    zproc_set_env (self, args->self);
+};
+
+///
+//  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.
+void QmlZproc::setStdin (void *socket) {
+    zproc_set_stdin (self, socket);
+};
+
+///
+//  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.
+void QmlZproc::setStdout (void *socket) {
+    zproc_set_stdout (self, socket);
+};
+
+///
+//  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.
+void QmlZproc::setStderr (void *socket) {
+    zproc_set_stderr (self, socket);
+};
+
+///
+//  Return subprocess stdin writable socket. NULL for
+//  not initialized or external sockets.
+void *QmlZproc::stdin () {
+    return zproc_stdin (self);
+};
+
+///
+//  Return subprocess stdout readable socket. NULL for
+//  not initialized or external sockets.
+void *QmlZproc::stdout () {
+    return zproc_stdout (self);
+};
+
+///
+//  Return subprocess stderr readable socket. NULL for
+//  not initialized or external sockets.
+void *QmlZproc::stderr () {
+    return zproc_stderr (self);
+};
+
+///
+//  Starts the process.
+int QmlZproc::run () {
+    return zproc_run (self);
+};
+
+///
+//  process exit code
+int QmlZproc::returncode () {
+    return zproc_returncode (self);
+};
+
+///
+//  PID of the process
+int QmlZproc::pid () {
+    return zproc_pid (self);
+};
+
+///
+//  return true if process is running, false if not yet started or finished
+bool QmlZproc::running () {
+    return zproc_running (self);
+};
+
+///
+//  wait or poll process status, return return code
+int QmlZproc::wait (bool hang) {
+    return zproc_wait (self, hang);
+};
+
+///
+//  return internal actor, usefull for the polling if process died
+void *QmlZproc::actor () {
+    return zproc_actor (self);
+};
+
+///
+//  send a signal to the subprocess
+void QmlZproc::kill (int signal) {
+    zproc_kill (self, signal);
+};
+
+///
+//  set verbose mode
+void QmlZproc::setVerbose (bool verbose) {
+    zproc_set_verbose (self, verbose);
+};
+
+
+QObject* QmlZproc::qmlAttachedProperties(QObject* object) {
+    return new QmlZprocAttached(object);
+}
+
+
+///
+//  Returns CZMQ version as a single 6-digit integer encoding the major
+//  version (x 10000), the minor version (x 100) and the patch.
+int QmlZprocAttached::czmqVersion () {
+    return zproc_czmq_version ();
+};
+
+///
+//  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.
+bool QmlZprocAttached::interrupted () {
+    return zproc_interrupted ();
+};
+
+///
+//  Returns true if the underlying libzmq supports CURVE security.
+bool QmlZprocAttached::hasCurve () {
+    return zproc_has_curve ();
+};
+
+///
+//  Return current host name, for use in public tcp:// endpoints.
+//  If the host name is not resolvable, returns NULL.
+QString QmlZprocAttached::hostname () {
+    char *retStr_ = zproc_hostname ();
+    QString retQStr_ = QString (retStr_);
+    free (retStr_);
+    return retQStr_;
+};
+
+///
+//  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.
+void QmlZprocAttached::daemonize (const QString &workdir) {
+    zproc_daemonize (workdir.toUtf8().data());
+};
+
+///
+//  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.
+void QmlZprocAttached::runAs (const QString &lockfile, const QString &group, const QString &user) {
+    zproc_run_as (lockfile.toUtf8().data(), group.toUtf8().data(), user.toUtf8().data());
+};
+
+///
+//  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.
+void QmlZprocAttached::setIoThreads (size_t ioThreads) {
+    zproc_set_io_threads (ioThreads);
+};
+
+///
+//  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.
+void QmlZprocAttached::setMaxSockets (size_t maxSockets) {
+    zproc_set_max_sockets (maxSockets);
+};
+
+///
+//  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".
+void QmlZprocAttached::setBiface (const QString &value) {
+    zproc_set_biface (value.toUtf8().data());
+};
+
+///
+//  Return network interface to use for broadcasts, or "" if none was set.
+const QString QmlZprocAttached::biface () {
+    return QString (zproc_biface ());
+};
+
+///
+//  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.
+void QmlZprocAttached::setLogIdent (const QString &value) {
+    zproc_set_log_ident (value.toUtf8().data());
+};
+
+///
+//  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.
+void QmlZprocAttached::setLogSender (const QString &endpoint) {
+    zproc_set_log_sender (endpoint.toUtf8().data());
+};
+
+///
+//  Enable or disable logging to the system facility (syslog on POSIX boxes,
+//  event log on Windows). By default this is disabled.
+void QmlZprocAttached::setLogSystem (bool logsystem) {
+    zproc_set_log_system (logsystem);
+};
+
+///
+//  Log error condition - highest priority
+void QmlZprocAttached::logError (const QString &format) {
+    zproc_log_error ("%s", format.toUtf8().data());
+};
+
+///
+//  Log warning condition - high priority
+void QmlZprocAttached::logWarning (const QString &format) {
+    zproc_log_warning ("%s", format.toUtf8().data());
+};
+
+///
+//  Log normal, but significant, condition - normal priority
+void QmlZprocAttached::logNotice (const QString &format) {
+    zproc_log_notice ("%s", format.toUtf8().data());
+};
+
+///
+//  Log informational message - low priority
+void QmlZprocAttached::logInfo (const QString &format) {
+    zproc_log_info ("%s", format.toUtf8().data());
+};
+
+///
+//  Log debug-level message - lowest priority
+void QmlZprocAttached::logDebug (const QString &format) {
+    zproc_log_debug ("%s", format.toUtf8().data());
+};
+
+///
+//  Self test of this class.
+void QmlZprocAttached::test (bool verbose) {
+    zproc_test (verbose);
+};
+
+///
+//  Create a new zproc.
+//  NOTE: On Windows and with libzmq3 and libzmq2 this function
+//  returns NULL. Code needs to be ported there.
+QmlZproc *QmlZprocAttached::construct () {
+    QmlZproc *qmlSelf = new QmlZproc ();
+    qmlSelf->self = zproc_new ();
+    return qmlSelf;
+};
+
+///
+//  Destroy zproc, wait until process ends.
+void QmlZprocAttached::destruct (QmlZproc *qmlSelf) {
+    zproc_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. #
+################################################################################
+*/