laag-libczmq 4.1.0.0

data/vendor/github.com/zeromq/czmq/bindings/qt/src/qzmsg.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 Q_ZMSG_H
+#define Q_ZMSG_H
+
+#include "qczmq.h"
+
+class QT_CZMQ_EXPORT QZmsg : public QObject
+{
+    Q_OBJECT
+public:
+
+    //  Copy-construct to return the proper wrapped c types
+    QZmsg (zmsg_t *self, QObject *qObjParent = 0);
+
+    //  Create a new empty message object
+    explicit QZmsg (QObject *qObjParent = 0);
+
+    //  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.
+    static QZmsg* recv (void *source, QObject *qObjParent = 0);
+
+    //  Load/append an open file into new message, return the message.
+    //  Returns NULL if the message could not be loaded.
+    static QZmsg* load (FILE *file, QObject *qObjParent = 0);
+
+    //  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.
+    static QZmsg* decode (QZframe *frame, QObject *qObjParent = 0);
+
+    //  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.
+    static QZmsg* newSignal (byte status, QObject *qObjParent = 0);
+
+    //  Destroy a message object and all frames it contains
+    ~QZmsg ();
+
+    //  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 (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 (void *dest);
+
+    //  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.
+    quint32 routingId ();
+
+    //  Set routing ID on message. This is used if/when the message is sent to a
+    //  ZMQ_SERVER socket.
+    void setRoutingId (quint32 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 (QZframe *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 (QZframe *frameP);
+
+    //  Remove first frame from message, if any. Returns frame, or NULL.
+    QZframe * 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 &param);
+
+    //  Push formatted string as new frame to end of message.
+    //  Returns 0 on success, -1 on error.
+    int addstrf (const QString &param);
+
+    //  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 (QZmsg *msgP);
+
+    //  Remove first submessage from message, if any. Returns zmsg_t, or NULL if
+    //  decoding was not successful.
+    QZmsg * popmsg ();
+
+    //  Remove specified frame from list, if present. Does not destroy frame.
+    void remove (QZframe *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.
+    QZframe * 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.
+    QZframe * next ();
+
+    //  Return the last frame. If there are no frames, returns NULL.
+    QZframe * 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 ().
+    QZframe * 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.
+    QZmsg * 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 (QZmsg *other);
+
+    //  Return signal value, 0 or greater, if message is a signal, -1 if not.
+    int signal ();
+
+    //  Probe the supplied object, and report if it looks like a zmsg_t.
+    static bool is (void *self);
+
+    //  Self test of this class.
+    static void test (bool verbose);
+
+    zmsg_t *self;
+};
+#endif //  Q_ZMSG_H
+/*
+################################################################################
+#  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/qt/src/qzpoller.cpp

@@ -0,0 +1,100 @@
+/*
+################################################################################
+#  THIS FILE IS 100% GENERATED BY ZPROJECT; DO NOT EDIT EXCEPT EXPERIMENTALLY  #
+#  Read the zproject/README.md for information about making permanent changes. #
+################################################################################
+*/
+
+#include "qczmq.h"
+
+///
+//  Copy-construct to return the proper wrapped c types
+QZpoller::QZpoller (zpoller_t *self, QObject *qObjParent) : QObject (qObjParent)
+{
+    this->self = self;
+}
+
+
+///
+//  Destroy a poller
+QZpoller::~QZpoller ()
+{
+    zpoller_destroy (&self);
+}
+
+///
+//  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 QZpoller::add (void *reader)
+{
+    int rv = zpoller_add (self, reader);
+    return rv;
+}
+
+///
+//  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 QZpoller::remove (void *reader)
+{
+    int rv = zpoller_remove (self, reader);
+    return rv;
+}
+
+///
+//  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 QZpoller::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 * QZpoller::wait (int timeout)
+{
+    void * rv = zpoller_wait (self, timeout);
+    return rv;
+}
+
+///
+//  Return true if the last zpoller_wait () call ended because the timeout
+//  expired, without any error.
+bool QZpoller::expired ()
+{
+    bool rv = zpoller_expired (self);
+    return rv;
+}
+
+///
+//  Return true if the last zpoller_wait () call ended because the process
+//  was interrupted, or the parent context was destroyed.
+bool QZpoller::terminated ()
+{
+    bool rv = zpoller_terminated (self);
+    return rv;
+}
+
+///
+//  Self test of this class.
+void QZpoller::test (bool verbose)
+{
+    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. #
+################################################################################
+*/

data/vendor/github.com/zeromq/czmq/bindings/qt/src/qzpoller.h

@@ -0,0 +1,67 @@
+/*
+################################################################################
+#  THIS FILE IS 100% GENERATED BY ZPROJECT; DO NOT EDIT EXCEPT EXPERIMENTALLY  #
+#  Read the zproject/README.md for information about making permanent changes. #
+################################################################################
+*/
+#ifndef Q_ZPOLLER_H
+#define Q_ZPOLLER_H
+
+#include "qczmq.h"
+
+class QT_CZMQ_EXPORT QZpoller : public QObject
+{
+    Q_OBJECT
+public:
+
+    //  Copy-construct to return the proper wrapped c types
+    QZpoller (zpoller_t *self, QObject *qObjParent = 0);
+
+    //  Destroy a poller
+    ~QZpoller ();
+
+    //  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 ();
+
+    //  Self test of this class.
+    static void test (bool verbose);
+
+    zpoller_t *self;
+};
+#endif //  Q_ZPOLLER_H
+/*
+################################################################################
+#  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/qt/src/qzproc.cpp

@@ -0,0 +1,365 @@
+/*
+################################################################################
+#  THIS FILE IS 100% GENERATED BY ZPROJECT; DO NOT EDIT EXCEPT EXPERIMENTALLY  #
+#  Read the zproject/README.md for information about making permanent changes. #
+################################################################################
+*/
+
+#include "qczmq.h"
+
+///
+//  Copy-construct to return the proper wrapped c types
+QZproc::QZproc (zproc_t *self, QObject *qObjParent) : QObject (qObjParent)
+{
+    this->self = self;
+}
+
+
+///
+//  Create a new zproc.
+//  NOTE: On Windows and with libzmq3 and libzmq2 this function
+//  returns NULL. Code needs to be ported there.
+QZproc::QZproc (QObject *qObjParent) : QObject (qObjParent)
+{
+    this->self = zproc_new ();
+}
+
+///
+//  Destroy zproc, wait until process ends.
+QZproc::~QZproc ()
+{
+    zproc_destroy (&self);
+}
+
+///
+//  Setup the command line arguments, the first item must be an (absolute) filename
+//  to run.
+void QZproc::setArgs (QZlistx *args)
+{
+    zproc_set_args (self, args->self);
+
+}
+
+///
+//  Setup the environment variables for the process.
+void QZproc::setEnv (QZhashx *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 QZproc::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 QZproc::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 QZproc::setStderr (void *socket)
+{
+    zproc_set_stderr (self, socket);
+
+}
+
+///
+//  Return subprocess stdin writable socket. NULL for
+//  not initialized or external sockets.
+void * QZproc::stdin ()
+{
+    void * rv = zproc_stdin (self);
+    return rv;
+}
+
+///
+//  Return subprocess stdout readable socket. NULL for
+//  not initialized or external sockets.
+void * QZproc::stdout ()
+{
+    void * rv = zproc_stdout (self);
+    return rv;
+}
+
+///
+//  Return subprocess stderr readable socket. NULL for
+//  not initialized or external sockets.
+void * QZproc::stderr ()
+{
+    void * rv = zproc_stderr (self);
+    return rv;
+}
+
+///
+//  Starts the process.
+int QZproc::run ()
+{
+    int rv = zproc_run (self);
+    return rv;
+}
+
+///
+//  process exit code
+int QZproc::returncode ()
+{
+    int rv = zproc_returncode (self);
+    return rv;
+}
+
+///
+//  PID of the process
+int QZproc::pid ()
+{
+    int rv = zproc_pid (self);
+    return rv;
+}
+
+///
+//  return true if process is running, false if not yet started or finished
+bool QZproc::running ()
+{
+    bool rv = zproc_running (self);
+    return rv;
+}
+
+///
+//  wait or poll process status, return return code
+int QZproc::wait (bool hang)
+{
+    int rv = zproc_wait (self, hang);
+    return rv;
+}
+
+///
+//  return internal actor, usefull for the polling if process died
+void * QZproc::actor ()
+{
+    void * rv = zproc_actor (self);
+    return rv;
+}
+
+///
+//  send a signal to the subprocess
+void QZproc::kill (int signal)
+{
+    zproc_kill (self, signal);
+
+}
+
+///
+//  set verbose mode
+void QZproc::setVerbose (bool verbose)
+{
+    zproc_set_verbose (self, verbose);
+
+}
+
+///
+//  Returns CZMQ version as a single 6-digit integer encoding the major
+//  version (x 10000), the minor version (x 100) and the patch.
+int QZproc::czmqVersion ()
+{
+    int rv = zproc_czmq_version ();
+    return rv;
+}
+
+///
+//  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 QZproc::interrupted ()
+{
+    bool rv = zproc_interrupted ();
+    return rv;
+}
+
+///
+//  Returns true if the underlying libzmq supports CURVE security.
+bool QZproc::hasCurve ()
+{
+    bool rv = zproc_has_curve ();
+    return rv;
+}
+
+///
+//  Return current host name, for use in public tcp:// endpoints.
+//  If the host name is not resolvable, returns NULL.
+QString QZproc::hostname ()
+{
+    char *retStr_ = zproc_hostname ();
+    QString rv = QString (retStr_);
+    zstr_free (&retStr_);
+    return rv;
+}
+
+///
+//  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 QZproc::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 QZproc::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 QZproc::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 QZproc::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 QZproc::setBiface (const QString &value)
+{
+    zproc_set_biface (value.toUtf8().data());
+
+}
+
+///
+//  Return network interface to use for broadcasts, or "" if none was set.
+const QString QZproc::biface ()
+{
+    const QString rv = QString (zproc_biface ());
+    return rv;
+}
+
+///
+//  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 QZproc::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 QZproc::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 QZproc::setLogSystem (bool logsystem)
+{
+    zproc_set_log_system (logsystem);
+
+}
+
+///
+//  Log error condition - highest priority
+void QZproc::logError (const QString &param)
+{
+    zproc_log_error ("%s", param.toUtf8().data());
+
+}
+
+///
+//  Log warning condition - high priority
+void QZproc::logWarning (const QString &param)
+{
+    zproc_log_warning ("%s", param.toUtf8().data());
+
+}
+
+///
+//  Log normal, but significant, condition - normal priority
+void QZproc::logNotice (const QString &param)
+{
+    zproc_log_notice ("%s", param.toUtf8().data());
+
+}
+
+///
+//  Log informational message - low priority
+void QZproc::logInfo (const QString &param)
+{
+    zproc_log_info ("%s", param.toUtf8().data());
+
+}
+
+///
+//  Log debug-level message - lowest priority
+void QZproc::logDebug (const QString &param)
+{
+    zproc_log_debug ("%s", param.toUtf8().data());
+
+}
+
+///
+//  Self test of this class.
+void QZproc::test (bool verbose)
+{
+    zproc_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. #
+################################################################################
+*/