laag-libczmq 4.1.0.0

data/vendor/github.com/zeromq/czmq/bindings/python_cffi/czmq_cffi/Zcertstore.py

@@ -0,0 +1,84 @@
+################################################################################
+#  THIS FILE IS 100% GENERATED BY ZPROJECT; DO NOT EDIT EXCEPT EXPERIMENTALLY  #
+#  Read the zproject/README.md for information about making permanent changes. #
+################################################################################
+import utils
+from . import destructors
+libczmq_destructors = destructors.lib
+
+class Zcertstore(object):
+    """
+    work with CURVE security certificate stores
+    """
+
+    def __init__(self, location):
+        """
+        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.
+        """
+        p = utils.lib.zcertstore_new(utils.to_bytes(location))
+        if p == utils.ffi.NULL:
+            raise MemoryError("Could not allocate person")
+
+        # ffi.gc returns a copy of the cdata object which will have the
+        # destructor called when the Python object is GC'd:
+        # https://cffi.readthedocs.org/en/latest/using.html#ffi-interface
+        self._p = utils.ffi.gc(p, libczmq_destructors.zcertstore_destroy_py)
+
+    def set_loader(self, loader, destructor, state):
+        """
+        Override the default disk loader with a custom loader fn.
+        """
+        utils.lib.zcertstore_set_loader(self._p, loader, destructor, state)
+
+    def lookup(self, public_key):
+        """
+        Look up certificate by public key, returns zcert_t object if found,
+        else returns NULL. The public key is provided in Z85 text format.
+        """
+        return utils.lib.zcertstore_lookup(self._p, utils.to_bytes(public_key))
+
+    def insert(self, cert_p):
+        """
+        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.
+        """
+        utils.lib.zcertstore_insert(self._p, cert_p._p)
+
+    def empty(self):
+        """
+        Empty certificate hashtable. This wrapper exists to be friendly to bindings,
+        which don't usually have access to struct internals.
+        """
+        utils.lib.zcertstore_empty(self._p)
+
+    def print_py(self):
+        """
+        Print list of certificates in store to logging facility
+        """
+        utils.lib.zcertstore_print(self._p)
+
+    def certs(self):
+        """
+        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.
+        """
+        return utils.lib.zcertstore_certs(self._p)
+
+    def test(verbose):
+        """
+        Self test of this class
+        """
+        utils.lib.zcertstore_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/python_cffi/czmq_cffi/Zchunk.py

@@ -0,0 +1,192 @@
+################################################################################
+#  THIS FILE IS 100% GENERATED BY ZPROJECT; DO NOT EDIT EXCEPT EXPERIMENTALLY  #
+#  Read the zproject/README.md for information about making permanent changes. #
+################################################################################
+import utils
+from . import destructors
+libczmq_destructors = destructors.lib
+
+class Zchunk(object):
+    """
+    work with memory chunks
+    """
+
+    def __init__(self, data, size):
+        """
+        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.
+        """
+        p = utils.lib.zchunk_new(data, size)
+        if p == utils.ffi.NULL:
+            raise MemoryError("Could not allocate person")
+
+        # ffi.gc returns a copy of the cdata object which will have the
+        # destructor called when the Python object is GC'd:
+        # https://cffi.readthedocs.org/en/latest/using.html#ffi-interface
+        self._p = utils.ffi.gc(p, libczmq_destructors.zchunk_destroy_py)
+
+    def resize(self, size):
+        """
+        Resizes chunk max_size as requested; chunk_cur size is set to zero
+        """
+        utils.lib.zchunk_resize(self._p, size)
+
+    def size(self):
+        """
+        Return chunk cur size
+        """
+        return utils.lib.zchunk_size(self._p)
+
+    def max_size(self):
+        """
+        Return chunk max size
+        """
+        return utils.lib.zchunk_max_size(self._p)
+
+    def data(self):
+        """
+        Return chunk data
+        """
+        return utils.lib.zchunk_data(self._p)
+
+    def set(self, data, size):
+        """
+        Set chunk data from user-supplied data; truncate if too large. Data may
+        be null. Returns actual size of chunk
+        """
+        return utils.lib.zchunk_set(self._p, data, size)
+
+    def fill(self, filler, size):
+        """
+        Fill chunk data from user-supplied octet
+        """
+        return utils.lib.zchunk_fill(self._p, filler, size)
+
+    def append(self, data, 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.
+        """
+        return utils.lib.zchunk_append(self._p, data, size)
+
+    def extend(self, data, size):
+        """
+        Append user-supplied data to chunk, return resulting chunk size. If the
+        data would exceeded the available space, the chunk grows in size.
+        """
+        return utils.lib.zchunk_extend(self._p, data, size)
+
+    def consume(self, source):
+        """
+        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.
+        """
+        return utils.lib.zchunk_consume(self._p, source._p)
+
+    def exhausted(self):
+        """
+        Returns true if the chunk was exhausted by consume methods, or if the
+        chunk has a size of zero.
+        """
+        return utils.lib.zchunk_exhausted(self._p)
+
+    def read(handle, bytes):
+        """
+        Read chunk from an open file descriptor
+        """
+        return utils.lib.zchunk_read(handle, bytes)
+
+    def write(self, handle):
+        """
+        Write chunk to an open file descriptor
+        """
+        return utils.lib.zchunk_write(self._p, handle)
+
+    def slurp(filename, maxsize):
+        """
+        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.
+        """
+        return utils.lib.zchunk_slurp(utils.to_bytes(filename), maxsize)
+
+    def dup(self):
+        """
+        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.
+        """
+        return utils.lib.zchunk_dup(self._p)
+
+    def strhex(self):
+        """
+        Return chunk data encoded as printable hex string. Caller must free
+        string when finished with it.
+        """
+        return utils.lib.zchunk_strhex(self._p)
+
+    def strdup(self):
+        """
+        Return chunk data copied into freshly allocated string
+        Caller must free string when finished with it.
+        """
+        return utils.lib.zchunk_strdup(self._p)
+
+    def streq(self, string):
+        """
+        Return TRUE if chunk body is equal to string, excluding terminator
+        """
+        return utils.lib.zchunk_streq(self._p, utils.to_bytes(string))
+
+    def pack(self):
+        """
+        Transform zchunk into a zframe that can be sent in a message.
+        """
+        return utils.lib.zchunk_pack(self._p)
+
+    def unpack(frame):
+        """
+        Transform a zframe into a zchunk.
+        """
+        return utils.lib.zchunk_unpack(frame._p)
+
+    def digest(self):
+        """
+        Calculate SHA1 digest for chunk, using zdigest class.
+        """
+        return utils.lib.zchunk_digest(self._p)
+
+    def fprint(self, file):
+        """
+        Dump chunk to FILE stream, for debugging and tracing.
+        """
+        utils.lib.zchunk_fprint(self._p, file)
+
+    def print_py(self):
+        """
+        Dump message to stderr, for debugging and tracing.
+        See zchunk_fprint for details
+        """
+        utils.lib.zchunk_print(self._p)
+
+    def is_py(self):
+        """
+        Probe the supplied object, and report if it looks like a zchunk_t.
+        """
+        return utils.lib.zchunk_is(self._p)
+
+    def test(verbose):
+        """
+        Self test of this class.
+        """
+        utils.lib.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/python_cffi/czmq_cffi/Zclock.py

@@ -0,0 +1,59 @@
+################################################################################
+#  THIS FILE IS 100% GENERATED BY ZPROJECT; DO NOT EDIT EXCEPT EXPERIMENTALLY  #
+#  Read the zproject/README.md for information about making permanent changes. #
+################################################################################
+import utils
+from . import destructors
+libczmq_destructors = destructors.lib
+
+class Zclock(object):
+    """
+    millisecond clocks and delays
+    """
+
+    def sleep(msecs):
+        """
+        Sleep for a number of milliseconds
+        """
+        utils.lib.zclock_sleep(msecs)
+
+    def time():
+        """
+        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.
+        """
+        return utils.lib.zclock_time()
+
+    def mono():
+        """
+        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.
+        """
+        return utils.lib.zclock_mono()
+
+    def usecs():
+        """
+        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.
+        """
+        return utils.lib.zclock_usecs()
+
+    def timestr():
+        """
+        Return formatted date/time as fresh string. Free using zstr_free().
+        """
+        return utils.lib.zclock_timestr()
+
+    def test(verbose):
+        """
+        Self test of this class.
+        """
+        utils.lib.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. #
+################################################################################

data/vendor/github.com/zeromq/czmq/bindings/python_cffi/czmq_cffi/Zconfig.py

@@ -0,0 +1,211 @@
+################################################################################
+#  THIS FILE IS 100% GENERATED BY ZPROJECT; DO NOT EDIT EXCEPT EXPERIMENTALLY  #
+#  Read the zproject/README.md for information about making permanent changes. #
+################################################################################
+import utils
+from . import destructors
+libczmq_destructors = destructors.lib
+
+class Zconfig(object):
+    """
+    work with config files written in rfc.zeromq.org/spec:4/ZPL.
+    """
+
+    def __init__(self, name, parent):
+        """
+        Create new config item
+        """
+        p = utils.lib.zconfig_new(utils.to_bytes(name), parent._p)
+        if p == utils.ffi.NULL:
+            raise MemoryError("Could not allocate person")
+
+        # ffi.gc returns a copy of the cdata object which will have the
+        # destructor called when the Python object is GC'd:
+        # https://cffi.readthedocs.org/en/latest/using.html#ffi-interface
+        self._p = utils.ffi.gc(p, libczmq_destructors.zconfig_destroy_py)
+
+    def name(self):
+        """
+        Return name of config item
+        """
+        return utils.lib.zconfig_name(self._p)
+
+    def value(self):
+        """
+        Return value of config item
+        """
+        return utils.lib.zconfig_value(self._p)
+
+    def put(self, path, value):
+        """
+        Insert or update configuration key with value
+        """
+        utils.lib.zconfig_put(self._p, utils.to_bytes(path), utils.to_bytes(value))
+
+    def putf(self, path, format, ):
+        """
+        Equivalent to zconfig_put, accepting a format specifier and variable
+        argument list, instead of a single string value.
+        """
+        utils.lib.zconfig_putf(self._p, utils.to_bytes(path), format, )
+
+    def get(self, path, default_value):
+        """
+        Get value for config item into a string value; leading slash is optional
+        and ignored.
+        """
+        return utils.lib.zconfig_get(self._p, utils.to_bytes(path), utils.to_bytes(default_value))
+
+    def set_name(self, name):
+        """
+        Set config item name, name may be NULL
+        """
+        utils.lib.zconfig_set_name(self._p, utils.to_bytes(name))
+
+    def set_value(self, format, ):
+        """
+        Set new value for config item. The new value may be a string, a printf
+        format, or NULL. Note that if string may possibly contain '%', or if it
+        comes from an insecure source, you must use '%s' as the format, followed
+        by the string.
+        """
+        utils.lib.zconfig_set_value(self._p, format, )
+
+    def child(self):
+        """
+        Find our first child, if any
+        """
+        return utils.lib.zconfig_child(self._p)
+
+    def next(self):
+        """
+        Find our first sibling, if any
+        """
+        return utils.lib.zconfig_next(self._p)
+
+    def locate(self, path):
+        """
+        Find a config item along a path; leading slash is optional and ignored.
+        """
+        return utils.lib.zconfig_locate(self._p, utils.to_bytes(path))
+
+    def at_depth(self, level):
+        """
+        Locate the last config item at a specified depth
+        """
+        return utils.lib.zconfig_at_depth(self._p, level)
+
+    def execute(self, handler, arg):
+        """
+        Execute a callback for each config item in the tree; returns zero if
+        successful, else -1.
+        """
+        return utils.lib.zconfig_execute(self._p, handler, arg._p)
+
+    def set_comment(self, format, ):
+        """
+        Add comment to config item before saving to disk. You can add as many
+        comment lines as you like. If you use a null format, all comments are
+        deleted.
+        """
+        utils.lib.zconfig_set_comment(self._p, format, )
+
+    def comments(self):
+        """
+        Return comments of config item, as zlist.
+        """
+        return utils.lib.zconfig_comments(self._p)
+
+    def save(self, filename):
+        """
+        Save a config tree to a specified ZPL text file, where a filename
+        "-" means dump to standard output.
+        """
+        return utils.lib.zconfig_save(self._p, utils.to_bytes(filename))
+
+    def savef(self, format, ):
+        """
+        Equivalent to zconfig_save, taking a format string instead of a fixed
+        filename.
+        """
+        return utils.lib.zconfig_savef(self._p, format, )
+
+    def filename(self):
+        """
+        Report filename used during zconfig_load, or NULL if none
+        """
+        return utils.lib.zconfig_filename(self._p)
+
+    def reload(self_p):
+        """
+        Reload config tree from same file that it was previously loaded from.
+        Returns 0 if OK, -1 if there was an error (and then does not change
+        existing data).
+        """
+        return utils.lib.zconfig_reload(self_p._p)
+
+    def chunk_load(chunk):
+        """
+        Load a config tree from a memory chunk
+        """
+        return utils.lib.zconfig_chunk_load(chunk._p)
+
+    def chunk_save(self):
+        """
+        Save a config tree to a new memory chunk
+        """
+        return utils.lib.zconfig_chunk_save(self._p)
+
+    def str_load(string):
+        """
+        Load a config tree from a null-terminated string
+        """
+        return utils.lib.zconfig_str_load(utils.to_bytes(string))
+
+    def str_save(self):
+        """
+        Save a config tree to a new null terminated string
+        """
+        return utils.lib.zconfig_str_save(self._p)
+
+    def has_changed(self):
+        """
+        Return true if a configuration tree was loaded from a file and that
+        file has changed in since the tree was loaded.
+        """
+        return utils.lib.zconfig_has_changed(self._p)
+
+    def remove_subtree(self):
+        """
+        Destroy subtree (all children)
+        """
+        utils.lib.zconfig_remove_subtree(self._p)
+
+    def remove(self_p):
+        """
+        Destroy node and subtree (all children)
+        """
+        utils.lib.zconfig_remove(self_p._p)
+
+    def fprint(self, file):
+        """
+        Print the config file to open stream
+        """
+        utils.lib.zconfig_fprint(self._p, file)
+
+    def print_py(self):
+        """
+        Print properties of object
+        """
+        utils.lib.zconfig_print(self._p)
+
+    def test(verbose):
+        """
+        Self test of this class
+        """
+        utils.lib.zconfig_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. #
+################################################################################