laag-libczmq 4.1.0.0

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

@@ -0,0 +1,68 @@
+/*
+################################################################################
+#  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_ZCERTSTORE_H
+#define Q_ZCERTSTORE_H
+
+#include "qczmq.h"
+
+class QT_CZMQ_EXPORT QZcertstore : public QObject
+{
+    Q_OBJECT
+public:
+
+    //  Copy-construct to return the proper wrapped c types
+    QZcertstore (zcertstore_t *self, QObject *qObjParent = 0);
+
+    //  Create a new certificate store from a disk directory, loading and
+    //  indexing all certificates in that location. The directory itself may be
+    //  absent, and created later, or modified at any time. The certificate store
+    //  is automatically refreshed on any zcertstore_lookup() call. If the
+    //  location is specified as NULL, creates a pure-memory store, which you
+    //  can work with by inserting certificates at runtime.
+    explicit QZcertstore (const QString &location, QObject *qObjParent = 0);
+
+    //  Destroy a certificate store object in memory. Does not affect anything
+    //  stored on disk.
+    ~QZcertstore ();
+
+    //  Override the default disk loader with a custom loader fn.
+    void setLoader (zcertstore_loader loader, zcertstore_destructor destructor, void *state);
+
+    //  Look up certificate by public key, returns zcert_t object if found,
+    //  else returns NULL. The public key is provided in Z85 text format.
+    QZcert * lookup (const QString &publicKey);
+
+    //  Insert certificate into certificate store in memory. Note that this
+    //  does not save the certificate to disk. To do that, use zcert_save()
+    //  directly on the certificate. Takes ownership of zcert_t object.
+    void insert (QZcert *certP);
+
+    //  Empty certificate hashtable. This wrapper exists to be friendly to bindings,
+    //  which don't usually have access to struct internals.
+    void empty ();
+
+    //  Print list of certificates in store to logging facility
+    void print ();
+
+    //  Return a list of all the certificates in the store.
+    //  The caller takes ownership of the zlistx_t object and is responsible
+    //  for destroying it.  The caller does not take ownership of the zcert_t
+    //  objects.
+    QZlistx * certs ();
+
+    //  Self test of this class
+    static void test (bool verbose);
+
+    zcertstore_t *self;
+};
+#endif //  Q_ZCERTSTORE_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/qzchunk.cpp

@@ -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. #
+################################################################################
+*/
+
+#include "qczmq.h"
+
+///
+//  Copy-construct to return the proper wrapped c types
+QZchunk::QZchunk (zchunk_t *self, QObject *qObjParent) : QObject (qObjParent)
+{
+    this->self = self;
+}
+
+
+///
+//  Create a new chunk of the specified size. If you specify the data, it
+//  is copied into the chunk. If you do not specify the data, the chunk is
+//  allocated and left empty, and you can then add data using zchunk_append.
+QZchunk::QZchunk (const void *data, size_t size, QObject *qObjParent) : QObject (qObjParent)
+{
+    this->self = zchunk_new (data, size);
+}
+
+///
+//  Destroy a chunk
+QZchunk::~QZchunk ()
+{
+    zchunk_destroy (&self);
+}
+
+///
+//  Resizes chunk max_size as requested; chunk_cur size is set to zero
+void QZchunk::resize (size_t size)
+{
+    zchunk_resize (self, size);
+
+}
+
+///
+//  Return chunk cur size
+size_t QZchunk::size ()
+{
+    size_t rv = zchunk_size (self);
+    return rv;
+}
+
+///
+//  Return chunk max size
+size_t QZchunk::maxSize ()
+{
+    size_t rv = zchunk_max_size (self);
+    return rv;
+}
+
+///
+//  Return chunk data
+byte * QZchunk::data ()
+{
+    byte * rv = zchunk_data (self);
+    return rv;
+}
+
+///
+//  Set chunk data from user-supplied data; truncate if too large. Data may
+//  be null. Returns actual size of chunk
+size_t QZchunk::set (const void *data, size_t size)
+{
+    size_t rv = zchunk_set (self, data, size);
+    return rv;
+}
+
+///
+//  Fill chunk data from user-supplied octet
+size_t QZchunk::fill (byte filler, size_t size)
+{
+    size_t rv = zchunk_fill (self, filler, size);
+    return rv;
+}
+
+///
+//  Append user-supplied data to chunk, return resulting chunk size. If the
+//  data would exceeded the available space, it is truncated. If you want to
+//  grow the chunk to accommodate new data, use the zchunk_extend method.
+size_t QZchunk::append (const void *data, size_t size)
+{
+    size_t rv = zchunk_append (self, data, size);
+    return rv;
+}
+
+///
+//  Append user-supplied data to chunk, return resulting chunk size. If the
+//  data would exceeded the available space, the chunk grows in size.
+size_t QZchunk::extend (const void *data, size_t size)
+{
+    size_t rv = zchunk_extend (self, data, size);
+    return rv;
+}
+
+///
+//  Copy as much data from 'source' into the chunk as possible; returns the
+//  new size of chunk. If all data from 'source' is used, returns exhausted
+//  on the source chunk. Source can be consumed as many times as needed until
+//  it is exhausted. If source was already exhausted, does not change chunk.
+size_t QZchunk::consume (QZchunk *source)
+{
+    size_t rv = zchunk_consume (self, source->self);
+    return rv;
+}
+
+///
+//  Returns true if the chunk was exhausted by consume methods, or if the
+//  chunk has a size of zero.
+bool QZchunk::exhausted ()
+{
+    bool rv = zchunk_exhausted (self);
+    return rv;
+}
+
+///
+//  Read chunk from an open file descriptor
+QZchunk * QZchunk::read (FILE *handle, size_t bytes)
+{
+    QZchunk *rv = new QZchunk (zchunk_read (handle, bytes));
+    return rv;
+}
+
+///
+//  Write chunk to an open file descriptor
+int QZchunk::write (FILE *handle)
+{
+    int rv = zchunk_write (self, handle);
+    return rv;
+}
+
+///
+//  Try to slurp an entire file into a chunk. Will read up to maxsize of
+//  the file. If maxsize is 0, will attempt to read the entire file and
+//  fail with an assertion if that cannot fit into memory. Returns a new
+//  chunk containing the file data, or NULL if the file could not be read.
+QZchunk * QZchunk::slurp (const QString &filename, size_t maxsize)
+{
+    QZchunk *rv = new QZchunk (zchunk_slurp (filename.toUtf8().data(), maxsize));
+    return rv;
+}
+
+///
+//  Create copy of chunk, as new chunk object. Returns a fresh zchunk_t
+//  object, or null if there was not enough heap memory. If chunk is null,
+//  returns null.
+QZchunk * QZchunk::dup ()
+{
+    QZchunk *rv = new QZchunk (zchunk_dup (self));
+    return rv;
+}
+
+///
+//  Return chunk data encoded as printable hex string. Caller must free
+//  string when finished with it.
+QString QZchunk::strhex ()
+{
+    char *retStr_ = zchunk_strhex (self);
+    QString rv = QString (retStr_);
+    zstr_free (&retStr_);
+    return rv;
+}
+
+///
+//  Return chunk data copied into freshly allocated string
+//  Caller must free string when finished with it.
+QString QZchunk::strdup ()
+{
+    char *retStr_ = zchunk_strdup (self);
+    QString rv = QString (retStr_);
+    zstr_free (&retStr_);
+    return rv;
+}
+
+///
+//  Return TRUE if chunk body is equal to string, excluding terminator
+bool QZchunk::streqNoConflict (const QString &string)
+{
+    bool rv = zchunk_streq (self, string.toUtf8().data());
+    return rv;
+}
+
+///
+//  Transform zchunk into a zframe that can be sent in a message.
+QZframe * QZchunk::pack ()
+{
+    QZframe *rv = new QZframe (zchunk_pack (self));
+    return rv;
+}
+
+///
+//  Transform a zframe into a zchunk.
+QZchunk * QZchunk::unpack (QZframe *frame)
+{
+    QZchunk *rv = new QZchunk (zchunk_unpack (frame->self));
+    return rv;
+}
+
+///
+//  Calculate SHA1 digest for chunk, using zdigest class.
+const QString QZchunk::digest ()
+{
+    const QString rv = QString (zchunk_digest (self));
+    return rv;
+}
+
+///
+//  Dump chunk to FILE stream, for debugging and tracing.
+void QZchunk::fprint (FILE *file)
+{
+    zchunk_fprint (self, file);
+
+}
+
+///
+//  Dump message to stderr, for debugging and tracing.
+//  See zchunk_fprint for details
+void QZchunk::print ()
+{
+    zchunk_print (self);
+
+}
+
+///
+//  Probe the supplied object, and report if it looks like a zchunk_t.
+bool QZchunk::is (void *self)
+{
+    bool rv = zchunk_is (self);
+    return rv;
+}
+
+///
+//  Self test of this class.
+void QZchunk::test (bool verbose)
+{
+    zchunk_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/qzchunk.h

@@ -0,0 +1,124 @@
+/*
+################################################################################
+#  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_ZCHUNK_H
+#define Q_ZCHUNK_H
+
+#include "qczmq.h"
+
+class QT_CZMQ_EXPORT QZchunk : public QObject
+{
+    Q_OBJECT
+public:
+
+    //  Copy-construct to return the proper wrapped c types
+    QZchunk (zchunk_t *self, QObject *qObjParent = 0);
+
+    //  Create a new chunk of the specified size. If you specify the data, it
+    //  is copied into the chunk. If you do not specify the data, the chunk is
+    //  allocated and left empty, and you can then add data using zchunk_append.
+    explicit QZchunk (const void *data, size_t size, QObject *qObjParent = 0);
+
+    //  Destroy a chunk
+    ~QZchunk ();
+
+    //  Resizes chunk max_size as requested; chunk_cur size is set to zero
+    void resize (size_t size);
+
+    //  Return chunk cur size
+    size_t size ();
+
+    //  Return chunk max size
+    size_t maxSize ();
+
+    //  Return chunk data
+    byte * data ();
+
+    //  Set chunk data from user-supplied data; truncate if too large. Data may
+    //  be null. Returns actual size of chunk
+    size_t set (const void *data, size_t size);
+
+    //  Fill chunk data from user-supplied octet
+    size_t fill (byte filler, size_t size);
+
+    //  Append user-supplied data to chunk, return resulting chunk size. If the
+    //  data would exceeded the available space, it is truncated. If you want to
+    //  grow the chunk to accommodate new data, use the zchunk_extend method.
+    size_t append (const void *data, size_t size);
+
+    //  Append user-supplied data to chunk, return resulting chunk size. If the
+    //  data would exceeded the available space, the chunk grows in size.
+    size_t extend (const void *data, size_t size);
+
+    //  Copy as much data from 'source' into the chunk as possible; returns the
+    //  new size of chunk. If all data from 'source' is used, returns exhausted
+    //  on the source chunk. Source can be consumed as many times as needed until
+    //  it is exhausted. If source was already exhausted, does not change chunk.
+    size_t consume (QZchunk *source);
+
+    //  Returns true if the chunk was exhausted by consume methods, or if the
+    //  chunk has a size of zero.
+    bool exhausted ();
+
+    //  Read chunk from an open file descriptor
+    static QZchunk * read (FILE *handle, size_t bytes);
+
+    //  Write chunk to an open file descriptor
+    int write (FILE *handle);
+
+    //  Try to slurp an entire file into a chunk. Will read up to maxsize of
+    //  the file. If maxsize is 0, will attempt to read the entire file and
+    //  fail with an assertion if that cannot fit into memory. Returns a new
+    //  chunk containing the file data, or NULL if the file could not be read.
+    static QZchunk * slurp (const QString &filename, size_t maxsize);
+
+    //  Create copy of chunk, as new chunk object. Returns a fresh zchunk_t
+    //  object, or null if there was not enough heap memory. If chunk is null,
+    //  returns null.
+    QZchunk * dup ();
+
+    //  Return chunk data encoded as printable hex string. Caller must free
+    //  string when finished with it.
+    QString strhex ();
+
+    //  Return chunk data copied into freshly allocated string
+    //  Caller must free string when finished with it.
+    QString strdup ();
+
+    //  Return TRUE if chunk body is equal to string, excluding terminator
+    bool streqNoConflict (const QString &string);
+
+    //  Transform zchunk into a zframe that can be sent in a message.
+    QZframe * pack ();
+
+    //  Transform a zframe into a zchunk.
+    static QZchunk * unpack (QZframe *frame);
+
+    //  Calculate SHA1 digest for chunk, using zdigest class.
+    const QString digest ();
+
+    //  Dump chunk to FILE stream, for debugging and tracing.
+    void fprint (FILE *file);
+
+    //  Dump message to stderr, for debugging and tracing.
+    //  See zchunk_fprint for details
+    void print ();
+
+    //  Probe the supplied object, and report if it looks like a zchunk_t.
+    static bool is (void *self);
+
+    //  Self test of this class.
+    static void test (bool verbose);
+
+    zchunk_t *self;
+};
+#endif //  Q_ZCHUNK_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/qzclock.cpp

@@ -0,0 +1,78 @@
+/*
+################################################################################
+#  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
+QZclock::QZclock (zclock_t *self, QObject *qObjParent) : QObject (qObjParent)
+{
+    this->self = self;
+}
+
+
+///
+//  Sleep for a number of milliseconds
+void QZclock::sleep (int msecs)
+{
+    zclock_sleep (msecs);
+
+}
+
+///
+//  Return current system clock as milliseconds. Note that this clock can
+//  jump backwards (if the system clock is changed) so is unsafe to use for
+//  timers and time offsets. Use zclock_mono for that instead.
+int64_t QZclock::time ()
+{
+    int64_t rv = zclock_time ();
+    return rv;
+}
+
+///
+//  Return current monotonic clock in milliseconds. Use this when you compute
+//  time offsets. The monotonic clock is not affected by system changes and
+//  so will never be reset backwards, unlike a system clock.
+int64_t QZclock::mono ()
+{
+    int64_t rv = zclock_mono ();
+    return rv;
+}
+
+///
+//  Return current monotonic clock in microseconds. Use this when you compute
+//  time offsets. The monotonic clock is not affected by system changes and
+//  so will never be reset backwards, unlike a system clock.
+int64_t QZclock::usecs ()
+{
+    int64_t rv = zclock_usecs ();
+    return rv;
+}
+
+///
+//  Return formatted date/time as fresh string. Free using zstr_free().
+QString QZclock::timestr ()
+{
+    char *retStr_ = zclock_timestr ();
+    QString rv = QString (retStr_);
+    zstr_free (&retStr_);
+    return rv;
+}
+
+///
+//  Self test of this class.
+void QZclock::test (bool verbose)
+{
+    zclock_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. #
+################################################################################
+*/