rbczmq 1.6.2 → 1.6.4

data/ext/czmq/include/zhash.h

@@ -0,0 +1,127 @@
+/*  =========================================================================
+    zhash - generic type-free hash container
+
+    -------------------------------------------------------------------------
+    Copyright (c) 1991-2013 iMatix Corporation <www.imatix.com>
+    Copyright other contributors as noted in the AUTHORS file.
+
+    This file is part of CZMQ, the high-level C binding for 0MQ:
+    http://czmq.zeromq.org.
+
+    This is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License as published by the 
+    Free Software Foundation; either version 3 of the License, or (at your 
+    option) any later version.
+
+    This software is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABIL-
+    ITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General 
+    Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License 
+    along with this program. If not, see <http://www.gnu.org/licenses/>.
+    =========================================================================
+*/
+
+#ifndef __ZHASH_H_INCLUDED__
+#define __ZHASH_H_INCLUDED__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//  Opaque class structure
+typedef struct _zhash_t zhash_t;
+
+//  @interface
+//  Callback function for zhash_foreach method
+typedef int (zhash_foreach_fn) (const char *key, void *item, void *argument);
+//  Callback function for zhash_freefn method
+typedef void (zhash_free_fn) (void *data);
+
+//  Create a new, empty hash container
+CZMQ_EXPORT zhash_t *
+    zhash_new (void);
+
+//  Destroy a hash container and all items in it
+CZMQ_EXPORT void
+    zhash_destroy (zhash_t **self_p);
+
+//  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.
+CZMQ_EXPORT int
+    zhash_insert (zhash_t *self, const char *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.
+CZMQ_EXPORT void
+    zhash_update (zhash_t *self, const char *key, void *item);
+
+//  Remove an item specified by key from the hash table. If there was no such
+//  item, this function does nothing.
+CZMQ_EXPORT void
+    zhash_delete (zhash_t *self, const char *key);
+
+//  Return the item at the specified key, or null
+CZMQ_EXPORT void *
+    zhash_lookup (zhash_t *self, const char *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.
+CZMQ_EXPORT int
+    zhash_rename (zhash_t *self, const char *old_key, const char *new_key);
+
+//  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.
+CZMQ_EXPORT void *
+    zhash_freefn (zhash_t *self, const char *key, zhash_free_fn *free_fn);
+
+//  Return the number of keys/items in the hash table
+CZMQ_EXPORT size_t
+    zhash_size (zhash_t *self);
+
+//  Make copy of hash table
+CZMQ_EXPORT zhash_t *
+    zhash_dup (zhash_t *self);
+
+//  Return keys for items in table
+CZMQ_EXPORT zlist_t *
+    zhash_keys (zhash_t *self);
+    
+//  Apply function to each item in the hash table. Items are iterated in no
+//  defined order. Stops if callback function returns non-zero and returns
+//  final return code from callback function (zero = success).
+CZMQ_EXPORT int
+    zhash_foreach (zhash_t *self, zhash_foreach_fn *callback, void *argument);
+
+//  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.
+CZMQ_EXPORT int
+    zhash_save (zhash_t *self, char *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.
+CZMQ_EXPORT int
+    zhash_load (zhash_t *self, char *filename);
+
+//  Set hash for automatic value destruction
+CZMQ_EXPORT void
+    zhash_autofree (zhash_t *self);
+    
+//  Self test of this class
+CZMQ_EXPORT void
+    zhash_test (int verbose);
+//  @end
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/czmq/include/zlist.h

@@ -0,0 +1,113 @@
+/*  =========================================================================
+    zlist - generic type-free list container
+
+    -------------------------------------------------------------------------
+    Copyright (c) 1991-2013 iMatix Corporation <www.imatix.com>
+    Copyright other contributors as noted in the AUTHORS file.
+
+    This file is part of CZMQ, the high-level C binding for 0MQ:
+    http://czmq.zeromq.org.
+
+    This is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License as published by the 
+    Free Software Foundation; either version 3 of the License, or (at your 
+    option) any later version.
+
+    This software is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABIL-
+    ITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General 
+    Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License 
+    along with this program. If not, see <http://www.gnu.org/licenses/>.
+    =========================================================================
+*/
+
+#ifndef __ZLIST_H_INCLUDED__
+#define __ZLIST_H_INCLUDED__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//  Opaque class structure
+typedef struct _zlist_t zlist_t;
+
+//  @interface
+//  Comparison function for zlist_sort method
+typedef bool (zlist_compare_fn) (void *item1, void *item2);
+
+//  Create a new list container
+CZMQ_EXPORT zlist_t *
+    zlist_new (void);
+
+//  Destroy a list container
+CZMQ_EXPORT void
+    zlist_destroy (zlist_t **self_p);
+
+//  Return first item in the list, or null
+CZMQ_EXPORT void *
+    zlist_first (zlist_t *self);
+
+//  Return last item in the list, or null
+CZMQ_EXPORT void *
+    zlist_last (zlist_t *self);
+
+//  Return first item in the list, or null, leaves the cursor
+CZMQ_EXPORT void *
+    zlist_head (zlist_t *self);
+
+//  Return last item in the list, or null, leaves the cursor
+CZMQ_EXPORT void *
+    zlist_tail (zlist_t *self);
+
+//  Return next item in the list, or null
+CZMQ_EXPORT void *
+    zlist_next (zlist_t *self);
+
+//  Append an item to the end of the list
+CZMQ_EXPORT int
+    zlist_append (zlist_t *self, void *item);
+
+//  Push an item to the start of the list
+CZMQ_EXPORT int
+    zlist_push (zlist_t *self, void *item);
+
+//  Pop the item off the start of the list, if any
+CZMQ_EXPORT void *
+    zlist_pop (zlist_t *self);
+
+//  Remove the specified item from the list if present
+CZMQ_EXPORT void
+    zlist_remove (zlist_t *self, void *item);
+
+//  Copy the entire list, return the copy
+CZMQ_EXPORT zlist_t *
+    zlist_dup (zlist_t *self);
+
+//  Copy the entire list, return the copy (deprecated)
+CZMQ_EXPORT zlist_t *
+    zlist_copy (zlist_t *self);
+
+//  Return number of items in the list
+CZMQ_EXPORT size_t
+    zlist_size (zlist_t *self);
+
+//  Sort list
+CZMQ_EXPORT void
+    zlist_sort (zlist_t *self, zlist_compare_fn *compare);
+
+//  Set list for automatic item destruction
+CZMQ_EXPORT void
+    zlist_autofree (zlist_t *self);
+
+//  Self test of this class
+CZMQ_EXPORT void
+    zlist_test (int verbose);
+//  @end
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/czmq/include/zloop.h

@@ -0,0 +1,98 @@
+/*  =========================================================================
+    zloop - event-driven reactor
+
+    -------------------------------------------------------------------------
+    Copyright (c) 1991-2013 iMatix Corporation <www.imatix.com>
+    Copyright other contributors as noted in the AUTHORS file.
+
+    This file is part of CZMQ, the high-level C binding for 0MQ:
+    http://czmq.zeromq.org.
+
+    This is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License as published by the 
+    Free Software Foundation; either version 3 of the License, or (at your 
+    option) any later version.
+
+    This software is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABIL-
+    ITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General 
+    Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License 
+    along with this program. If not, see <http://www.gnu.org/licenses/>.
+    =========================================================================
+*/
+
+#ifndef __ZLOOP_H_INCLUDED__
+#define __ZLOOP_H_INCLUDED__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+//  Opaque class structure
+typedef struct _zloop_t zloop_t;
+
+//  @interface
+//  Callback function for reactor events
+typedef int (zloop_fn) (zloop_t *loop, zmq_pollitem_t *item, void *arg);
+
+//  Create a new zloop reactor
+CZMQ_EXPORT zloop_t *
+    zloop_new (void);
+
+//  Destroy a reactor
+CZMQ_EXPORT void
+    zloop_destroy (zloop_t **self_p);
+
+//  Register pollitem with the reactor. When the pollitem is ready, will call
+//  the handler, passing the arg. Returns 0 if OK, -1 if there was an error.
+//  If you register the pollitem more than once, each instance will invoke its
+//  corresponding handler.
+CZMQ_EXPORT int
+    zloop_poller (zloop_t *self, zmq_pollitem_t *item, zloop_fn handler, void *arg);
+
+//  Cancel a pollitem from the reactor, specified by socket or FD. If both
+//  are specified, uses only socket. If multiple poll items exist for same
+//  socket/FD, cancels ALL of them.
+CZMQ_EXPORT void
+    zloop_poller_end (zloop_t *self, zmq_pollitem_t *item);
+
+//  Register a timer that expires after some delay and repeats some number of
+//  times. At each expiry, will call the handler, passing the arg. To
+//  run a timer forever, use 0 times. Returns 0 if OK, -1 if there was an
+//  error.
+CZMQ_EXPORT int
+    zloop_timer (zloop_t *self, size_t delay, size_t times, zloop_fn handler, void *arg);
+
+//  Cancel all timers for a specific argument (as provided in zloop_timer)
+CZMQ_EXPORT int
+    zloop_timer_end (zloop_t *self, void *arg);
+
+//  Set verbose tracing of reactor on/off
+CZMQ_EXPORT void
+    zloop_set_verbose (zloop_t *self, bool verbose);
+
+//  Start the reactor. Takes control of the thread and returns when the 0MQ
+//  context is terminated or the process is interrupted, or any event handler
+//  returns -1. Event handlers may register new sockets and timers, and
+//  cancel sockets. Returns 0 if interrupted, -1 if cancelled by a handler.
+CZMQ_EXPORT int
+    zloop_start (zloop_t *self);
+
+//  Self test of this class
+CZMQ_EXPORT void
+    zloop_test (bool verbose);
+//  @end
+
+
+// to suppress disabling the event handler on POLLERR
+// set this in pollitem.events
+#define ZMQ_IGNERR 8
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/czmq/include/zmsg.h

@@ -0,0 +1,165 @@
+/*  =========================================================================
+    zmsg - working with multipart messages
+
+    -------------------------------------------------------------------------
+    Copyright (c) 1991-2013 iMatix Corporation <www.imatix.com>
+    Copyright other contributors as noted in the AUTHORS file.
+
+    This file is part of CZMQ, the high-level C binding for 0MQ:
+    http://czmq.zeromq.org.
+
+    This is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License as published by the 
+    Free Software Foundation; either version 3 of the License, or (at your 
+    option) any later version.
+
+    This software is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABIL-
+    ITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General 
+    Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License 
+    along with this program. If not, see <http://www.gnu.org/licenses/>.
+    =========================================================================
+*/
+
+#ifndef __ZMSG_H_INCLUDED__
+#define __ZMSG_H_INCLUDED__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//  Opaque class structure
+typedef struct _zmsg_t zmsg_t;
+
+//  @interface
+//  Create a new empty message object
+CZMQ_EXPORT zmsg_t *
+    zmsg_new (void);
+
+//  Destroy a message object and all frames it contains
+CZMQ_EXPORT void
+    zmsg_destroy (zmsg_t **self_p);
+
+//  Read 1 or more frames off the socket, into a new message object
+CZMQ_EXPORT zmsg_t *
+    zmsg_recv (void *socket);
+
+//  Send a message to the socket, and then destroy it
+CZMQ_EXPORT int
+    zmsg_send (zmsg_t **self_p, void *socket);
+
+//  Return number of frames in message
+CZMQ_EXPORT size_t
+    zmsg_size (zmsg_t *self);
+
+//  Return combined size of all frames in message
+CZMQ_EXPORT size_t
+    zmsg_content_size (zmsg_t *self);
+
+//  Push frame to front of message, before first frame
+CZMQ_EXPORT int
+    zmsg_push (zmsg_t *self, zframe_t *frame);
+
+//  Pop frame off front of message, caller now owns frame
+CZMQ_EXPORT zframe_t *
+    zmsg_pop (zmsg_t *self);
+
+//  Add frame to end of message, after last frame
+CZMQ_EXPORT int
+    zmsg_add (zmsg_t *self, zframe_t *frame);
+
+//  Push block of memory as new frame to front of message.
+//  Returns 0 on success, -1 on error.
+CZMQ_EXPORT int
+    zmsg_pushmem (zmsg_t *self, const void *src, size_t size);
+
+//  Push block of memory as new frame to end of message.
+//  Returns 0 on success, -1 on error.
+CZMQ_EXPORT int
+    zmsg_addmem (zmsg_t *self, const void *src, size_t size);
+    
+//  Push string as new frame to front of message.
+//  Returns 0 on success, -1 on error.
+CZMQ_EXPORT int
+    zmsg_pushstr (zmsg_t *self, const char *format, ...);
+
+//  Push string as new frame to end of message.
+//  Returns 0 on success, -1 on error.
+CZMQ_EXPORT int
+    zmsg_addstr (zmsg_t *self, const char *format, ...);
+
+//  Pop frame off front of message, return as fresh string
+CZMQ_EXPORT char *
+    zmsg_popstr (zmsg_t *self);
+
+//  Push frame to front of message, before first frame
+//  Pushes an empty frame in front of frame
+CZMQ_EXPORT void
+    zmsg_wrap (zmsg_t *self, zframe_t *frame);
+
+//  Pop frame off front of message, caller now owns frame
+//  If next frame is empty, pops and destroys that empty frame.
+CZMQ_EXPORT zframe_t *
+    zmsg_unwrap (zmsg_t *self);
+
+//  Remove frame from message, at any position, caller owns it
+CZMQ_EXPORT void
+    zmsg_remove (zmsg_t *self, zframe_t *frame);
+
+//  Return first frame in message, or null
+CZMQ_EXPORT zframe_t *
+    zmsg_first (zmsg_t *self);
+
+//  Return next frame in message, or null
+CZMQ_EXPORT zframe_t *
+    zmsg_next (zmsg_t *self);
+
+//  Return last frame in message, or null
+CZMQ_EXPORT zframe_t *
+    zmsg_last (zmsg_t *self);
+
+//  Save message to an open file, return 0 if OK, else -1.
+CZMQ_EXPORT int
+    zmsg_save (zmsg_t *self, FILE *file);
+
+//  Load/append an open file into message, create new message if
+//  null message provided.
+CZMQ_EXPORT zmsg_t *
+    zmsg_load (zmsg_t *self, FILE *file);
+
+//  Encode message to a new buffer, return buffer size
+CZMQ_EXPORT size_t
+    zmsg_encode (zmsg_t *self, byte **buffer);
+
+//  Decode a buffer into a new message, returns NULL if buffer is not
+//  properly formatted.
+CZMQ_EXPORT zmsg_t *
+    zmsg_decode (byte *buffer, size_t buffer_size);
+
+//  Create copy of message, as new message object
+CZMQ_EXPORT zmsg_t *
+    zmsg_dup (zmsg_t *self);
+
+//  Print message to stderr, for debugging
+CZMQ_EXPORT void
+    zmsg_dump (zmsg_t *self);
+
+//  Push block of memory as new frame to end of message.
+//  The frame is constructed using zero-copy.
+//  Returns 0 on success, -1 on error.
+//  DEPRECATED - will be removed for next stable release
+CZMQ_EXPORT int
+    zmsg_addmem_zero_copy (zmsg_t *self, void *src, size_t size, zframe_free_fn *free_fn, void *arg);
+
+//  Self test of this class
+CZMQ_EXPORT int
+    zmsg_test (bool verbose);
+//  @end
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif