czmq-ffi-gen 0.9.1-x86-mingw32

data/vendor/local/include/zhashx.h

@@ -0,0 +1,298 @@
+/*  =========================================================================
+    zhashx - extended generic type-free hash container
+
+    Copyright (c) the 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 Source Code Form is subject to the terms of the Mozilla Public
+    License, v. 2.0. If a copy of the MPL was not distributed with this
+    file, You can obtain one at http://mozilla.org/MPL/2.0/.
+    =========================================================================
+*/
+
+#ifndef __ZHASHX_H_INCLUDED__
+#define __ZHASHX_H_INCLUDED__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+//  @warning THE FOLLOWING @INTERFACE BLOCK IS AUTO-GENERATED BY ZPROJECT
+//  @warning Please edit the model at "api/zhashx.api" to make changes.
+//  @interface
+//  This is a stable class, and may not change except for emergencies. It
+//  is provided in stable builds.
+//  This class has draft methods, which may change over time. They are not
+//  in stable releases, by default. Use --enable-drafts to enable.
+//  This class has legacy methods, which will be removed over time. You
+//  should not use them, and migrate any code that is still using them.
+// Destroy an item
+typedef void (zhashx_destructor_fn) (
+    void **item);
+
+// Duplicate an item
+typedef void * (zhashx_duplicator_fn) (
+    const void *item);
+
+// Compare two items, for sorting
+typedef int (zhashx_comparator_fn) (
+    const void *item1, const void *item2);
+
+// compare two items, for sorting
+typedef void (zhashx_free_fn) (
+    void *data);
+
+// compare two items, for sorting
+typedef size_t (zhashx_hash_fn) (
+    const void *key);
+
+// Serializes an item to a longstr.                       
+// The caller takes ownership of the newly created object.
+typedef char * (zhashx_serializer_fn) (
+    const void *item);
+
+// Deserializes a longstr into an item.                   
+// The caller takes ownership of the newly created object.
+typedef void * (zhashx_deserializer_fn) (
+    const char *item_str);
+
+// Callback function for zhashx_foreach method.                              
+// This callback is deprecated and you should use zhashx_first/_next instead.
+typedef int (zhashx_foreach_fn) (
+    const char *key, void *item, void *argument);
+
+//  Create a new, empty hash container
+CZMQ_EXPORT zhashx_t *
+    zhashx_new (void);
+
+//  Unpack binary frame into a new hash table. Packed data must follow format
+//  defined by zhashx_pack. Hash table is set to autofree. An empty frame    
+//  unpacks to an empty hash table.                                          
+CZMQ_EXPORT zhashx_t *
+    zhashx_unpack (zframe_t *frame);
+
+//  Destroy a hash container and all items in it
+CZMQ_EXPORT void
+    zhashx_destroy (zhashx_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
+    zhashx_insert (zhashx_t *self, const void *key, void *item);
+
+//  Update or insert item into hash table with specified key and item. If the
+//  key is already present, destroys old item and inserts new one. If you set
+//  a container item destructor, this is called on the old value. If the key 
+//  was not already present, inserts a new item. Sets the hash cursor to the 
+//  new item.                                                                
+CZMQ_EXPORT void
+    zhashx_update (zhashx_t *self, const void *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
+    zhashx_delete (zhashx_t *self, const void *key);
+
+//  Delete all items from the hash table. If the key destructor is  
+//  set, calls it on every key. If the item destructor is set, calls
+//  it on every item.                                               
+CZMQ_EXPORT void
+    zhashx_purge (zhashx_t *self);
+
+//  Return the item at the specified key, or null
+CZMQ_EXPORT void *
+    zhashx_lookup (zhashx_t *self, const void *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
+    zhashx_rename (zhashx_t *self, const void *old_key, const void *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 *
+    zhashx_freefn (zhashx_t *self, const void *key, zhashx_free_fn free_fn);
+
+//  Return the number of keys/items in the hash table
+CZMQ_EXPORT size_t
+    zhashx_size (zhashx_t *self);
+
+//  Return a zlistx_t containing the keys for the items in the       
+//  table. Uses the key_duplicator to duplicate all keys and sets the
+//  key_destructor as destructor for the list.                       
+//  Caller owns return value and must destroy it when done.
+CZMQ_EXPORT zlistx_t *
+    zhashx_keys (zhashx_t *self);
+
+//  Return a zlistx_t containing the values for the items in the  
+//  table. Uses the duplicator to duplicate all items and sets the
+//  destructor as destructor for the list.                        
+//  Caller owns return value and must destroy it when done.
+CZMQ_EXPORT zlistx_t *
+    zhashx_values (zhashx_t *self);
+
+//  Simple iterator; returns first item in hash table, in no given order, 
+//  or NULL if the table is empty. This method is simpler to use than the 
+//  foreach() method, which is deprecated. To access the key for this item
+//  use zhashx_cursor(). NOTE: do NOT modify the table while iterating.   
+CZMQ_EXPORT void *
+    zhashx_first (zhashx_t *self);
+
+//  Simple iterator; returns next item in hash table, in no given order, 
+//  or NULL if the last item was already returned. Use this together with
+//  zhashx_first() to process all items in a hash table. If you need the 
+//  items in sorted order, use zhashx_keys() and then zlistx_sort(). To  
+//  access the key for this item use zhashx_cursor(). NOTE: do NOT modify
+//  the table while iterating.                                           
+CZMQ_EXPORT void *
+    zhashx_next (zhashx_t *self);
+
+//  After a successful first/next method, returns the key for the item that
+//  was returned. This is a constant string that you may not modify or     
+//  deallocate, and which lasts as long as the item in the hash. After an  
+//  unsuccessful first/next, returns NULL.                                 
+CZMQ_EXPORT const void *
+    zhashx_cursor (zhashx_t *self);
+
+//  Add a comment to hash table before saving to disk. You can add as many   
+//  comment lines as you like. These comment lines are discarded when loading
+//  the file. If you use a null format, all comments are deleted.            
+CZMQ_EXPORT void
+    zhashx_comment (zhashx_t *self, const char *format, ...) CHECK_PRINTF (2);
+
+//  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
+    zhashx_save (zhashx_t *self, const 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
+    zhashx_load (zhashx_t *self, const char *filename);
+
+//  When a hash table was loaded from a file by zhashx_load, this method will
+//  reload the file if it has been modified since, and is "stable", i.e. not 
+//  still changing. Returns 0 if OK, -1 if there was an error reloading the  
+//  file.                                                                    
+CZMQ_EXPORT int
+    zhashx_refresh (zhashx_t *self);
+
+//  Serialize hash table to a binary frame that can be sent in a message.
+//  The packed format is compatible with the 'dictionary' type defined in
+//  http://rfc.zeromq.org/spec:35/FILEMQ, and implemented by zproto:     
+//                                                                       
+//     ; A list of name/value pairs                                      
+//     dictionary      = dict-count *( dict-name dict-value )            
+//     dict-count      = number-4                                        
+//     dict-value      = longstr                                         
+//     dict-name       = string                                          
+//                                                                       
+//     ; Strings are always length + text contents                       
+//     longstr         = number-4 *VCHAR                                 
+//     string          = number-1 *VCHAR                                 
+//                                                                       
+//     ; Numbers are unsigned integers in network byte order             
+//     number-1        = 1OCTET                                          
+//     number-4        = 4OCTET                                          
+//                                                                       
+//  Comments are not included in the packed data. Item values MUST be    
+//  strings.                                                             
+//  Caller owns return value and must destroy it when done.
+CZMQ_EXPORT zframe_t *
+    zhashx_pack (zhashx_t *self);
+
+//  Make a copy of the list; items are duplicated if you set a duplicator 
+//  for the list, otherwise not. Copying a null reference returns a null  
+//  reference. Note that this method's behavior changed slightly for CZMQ 
+//  v3.x, as it does not set nor respect autofree. It does however let you
+//  duplicate any hash table safely. The old behavior is in zhashx_dup_v2.
+//  Caller owns return value and must destroy it when done.
+CZMQ_EXPORT zhashx_t *
+    zhashx_dup (zhashx_t *self);
+
+//  Set a user-defined deallocator for hash items; by default items are not
+//  freed when the hash is destroyed.                                      
+CZMQ_EXPORT void
+    zhashx_set_destructor (zhashx_t *self, zhashx_destructor_fn destructor);
+
+//  Set a user-defined duplicator for hash items; by default items are not
+//  copied when the hash is duplicated.                                   
+CZMQ_EXPORT void
+    zhashx_set_duplicator (zhashx_t *self, zhashx_duplicator_fn duplicator);
+
+//  Set a user-defined deallocator for keys; by default keys are freed
+//  when the hash is destroyed using free().                          
+CZMQ_EXPORT void
+    zhashx_set_key_destructor (zhashx_t *self, zhashx_destructor_fn destructor);
+
+//  Set a user-defined duplicator for keys; by default keys are duplicated
+//  using strdup.                                                         
+CZMQ_EXPORT void
+    zhashx_set_key_duplicator (zhashx_t *self, zhashx_duplicator_fn duplicator);
+
+//  Set a user-defined comparator for keys; by default keys are
+//  compared using strcmp.                                     
+CZMQ_EXPORT void
+    zhashx_set_key_comparator (zhashx_t *self, zhashx_comparator_fn comparator);
+
+//  Set a user-defined comparator for keys; by default keys are
+//  compared using strcmp.                                     
+CZMQ_EXPORT void
+    zhashx_set_key_hasher (zhashx_t *self, zhashx_hash_fn hasher);
+
+//  Make copy of hash table; if supplied table is null, returns null.    
+//  Does not copy items themselves. Rebuilds new table so may be slow on 
+//  very large tables. NOTE: only works with item values that are strings
+//  since there's no other way to know how to duplicate the item value.  
+CZMQ_EXPORT zhashx_t *
+    zhashx_dup_v2 (zhashx_t *self);
+
+//  *** Deprecated method, slated for removal: avoid using it ***
+//  Set hash for automatic value destruction. This method is deprecated
+//  and you should use set_destructor instead.                         
+CZMQ_EXPORT void
+    zhashx_autofree (zhashx_t *self);
+
+//  *** Deprecated method, slated for removal: avoid using it ***
+//  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). This method 
+//  is deprecated and you should use zhashx_first/_next instead.           
+CZMQ_EXPORT int
+    zhashx_foreach (zhashx_t *self, zhashx_foreach_fn callback, void *argument);
+
+//  Self test of this class.
+CZMQ_EXPORT void
+    zhashx_test (bool verbose);
+
+#ifdef CZMQ_BUILD_DRAFT_API
+//  *** Draft method, for development use, may change without warning ***
+//  Same as unpack but uses a user-defined deserializer function to convert
+//  a longstr back into item format.                                       
+CZMQ_EXPORT zhashx_t *
+    zhashx_unpack_own (zframe_t *frame, zhashx_deserializer_fn deserializer);
+
+//  *** Draft method, for development use, may change without warning ***
+//  Same as pack but uses a user-defined serializer function to convert items
+//  into longstr.                                                            
+//  Caller owns return value and must destroy it when done.
+CZMQ_EXPORT zframe_t *
+    zhashx_pack_own (zhashx_t *self, zhashx_serializer_fn serializer);
+
+#endif // CZMQ_BUILD_DRAFT_API
+//  @end
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/vendor/local/include/ziflist.h

@@ -0,0 +1,77 @@
+/*  =========================================================================
+    ziflist - List of network interfaces available on system
+    
+    Copyright (c) the 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 Source Code Form is subject to the terms of the Mozilla Public
+    License, v. 2.0. If a copy of the MPL was not distributed with this
+    file, You can obtain one at http://mozilla.org/MPL/2.0/.
+    =========================================================================
+*/
+
+#ifndef __ZIFLIST_H_INCLUDED__
+#define __ZIFLIST_H_INCLUDED__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//  @warning THE FOLLOWING @INTERFACE BLOCK IS AUTO-GENERATED BY ZPROJECT
+//  @warning Please edit the model at "api/ziflist.api" to make changes.
+//  @interface
+//  This is a stable class, and may not change except for emergencies. It
+//  is provided in stable builds.
+//  Get a list of network interfaces currently defined on the system
+CZMQ_EXPORT ziflist_t *
+    ziflist_new (void);
+
+//  Destroy a ziflist instance
+CZMQ_EXPORT void
+    ziflist_destroy (ziflist_t **self_p);
+
+//  Reload network interfaces from system
+CZMQ_EXPORT void
+    ziflist_reload (ziflist_t *self);
+
+//  Return the number of network interfaces on system
+CZMQ_EXPORT size_t
+    ziflist_size (ziflist_t *self);
+
+//  Get first network interface, return NULL if there are none
+CZMQ_EXPORT const char *
+    ziflist_first (ziflist_t *self);
+
+//  Get next network interface, return NULL if we hit the last one
+CZMQ_EXPORT const char *
+    ziflist_next (ziflist_t *self);
+
+//  Return the current interface IP address as a printable string
+CZMQ_EXPORT const char *
+    ziflist_address (ziflist_t *self);
+
+//  Return the current interface broadcast address as a printable string
+CZMQ_EXPORT const char *
+    ziflist_broadcast (ziflist_t *self);
+
+//  Return the current interface network mask as a printable string
+CZMQ_EXPORT const char *
+    ziflist_netmask (ziflist_t *self);
+
+//  Return the list of interfaces.
+CZMQ_EXPORT void
+    ziflist_print (ziflist_t *self);
+
+//  Self test of this class.
+CZMQ_EXPORT void
+    ziflist_test (bool verbose);
+
+//  @end
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/vendor/local/include/zlist.h

@@ -0,0 +1,158 @@
+/*  =========================================================================
+    zlist - simple generic list container
+
+    Copyright (c) the 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 Source Code Form is subject to the terms of the Mozilla Public
+    License, v. 2.0. If a copy of the MPL was not distributed with this
+    file, You can obtain one at http://mozilla.org/MPL/2.0/.
+    =========================================================================
+*/
+
+#ifndef __ZLIST_H_INCLUDED__
+#define __ZLIST_H_INCLUDED__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//  @warning THE FOLLOWING @INTERFACE BLOCK IS AUTO-GENERATED BY ZPROJECT
+//  @warning Please edit the model at "api/zlist.api" to make changes.
+//  @interface
+//  This is a stable class, and may not change except for emergencies. It
+//  is provided in stable builds.
+// Comparison function e.g. for sorting and removing.
+typedef int (zlist_compare_fn) (
+    void *item1, void *item2);
+
+// Callback function for zlist_freefn method
+typedef void (zlist_free_fn) (
+    void *data);
+
+//  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 the item at the head of list. If the list is empty, returns NULL.
+//  Leaves cursor pointing at the head item, or NULL if the list is empty.  
+CZMQ_EXPORT void *
+    zlist_first (zlist_t *self);
+
+//  Return the next item. If the list is empty, returns NULL. To move to
+//  the start of the list call zlist_first (). Advances the cursor.     
+CZMQ_EXPORT void *
+    zlist_next (zlist_t *self);
+
+//  Return the item at the tail of list. If the list is empty, returns NULL.
+//  Leaves cursor pointing at the tail item, or NULL if the list is empty.  
+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 the current item of list. If the list is empty, returns NULL.     
+//  Leaves cursor pointing at the current item, or NULL if the list is empty.
+CZMQ_EXPORT void *
+    zlist_item (zlist_t *self);
+
+//  Append an item to the end of the list, return 0 if OK or -1 if this  
+//  failed for some reason (out of memory). Note that if a duplicator has
+//  been set, this method will also duplicate the item.                  
+CZMQ_EXPORT int
+    zlist_append (zlist_t *self, void *item);
+
+//  Push an item to the start of the list, return 0 if OK or -1 if this  
+//  failed for some reason (out of memory). Note that if a duplicator has
+//  been set, this method will also duplicate the item.                  
+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);
+
+//  Checks if an item already is present. Uses compare method to determine if 
+//  items are equal. If the compare method is NULL the check will only compare
+//  pointers. Returns true if item is present else false.                     
+CZMQ_EXPORT bool
+    zlist_exists (zlist_t *self, void *item);
+
+//  Remove the specified item from the list if present
+CZMQ_EXPORT void
+    zlist_remove (zlist_t *self, void *item);
+
+//  Make a copy of list. If the list has autofree set, the copied list will  
+//  duplicate all items, which must be strings. Otherwise, the list will hold
+//  pointers back to the items in the original list. If list is null, returns
+//  NULL.                                                                    
+//  Caller owns return value and must destroy it when done.
+CZMQ_EXPORT zlist_t *
+    zlist_dup (zlist_t *self);
+
+//  Purge all items from list
+CZMQ_EXPORT void
+    zlist_purge (zlist_t *self);
+
+//  Return number of items in the list
+CZMQ_EXPORT size_t
+    zlist_size (zlist_t *self);
+
+//  Sort the list. If the compare function is null, sorts the list by     
+//  ascending key value using a straight ASCII comparison. If you specify 
+//  a compare function, this decides how items are sorted. The sort is not
+//  stable, so may reorder items with the same keys. The algorithm used is
+//  combsort, a compromise between performance and simplicity.            
+CZMQ_EXPORT void
+    zlist_sort (zlist_t *self, zlist_compare_fn compare);
+
+//  Set list for automatic item destruction; item values MUST be strings. 
+//  By default a list item refers to a value held elsewhere. When you set 
+//  this, each time you append or push a list item, zlist will take a copy
+//  of the string value. Then, when you destroy the list, it will free all
+//  item values automatically. If you use any other technique to allocate 
+//  list values, you must free them explicitly before destroying the list.
+//  The usual technique is to pop list items and destroy them, until the  
+//  list is empty.                                                        
+CZMQ_EXPORT void
+    zlist_autofree (zlist_t *self);
+
+//  Sets a compare function for this list. The function compares two items.
+//  It returns an integer less than, equal to, or greater than zero if the 
+//  first item is found, respectively, to be less than, to match, or be    
+//  greater than the second item.                                          
+//  This function is used for sorting, removal and exists checking.        
+CZMQ_EXPORT void
+    zlist_comparefn (zlist_t *self, zlist_compare_fn fn);
+
+//  Set a free function for the specified list item. When the item is     
+//  destroyed, the free function, if any, is called on that item.         
+//  Use this when list 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 *
+    zlist_freefn (zlist_t *self, void *item, zlist_free_fn fn, bool at_tail);
+
+//  Self test of this class.
+CZMQ_EXPORT void
+    zlist_test (bool verbose);
+
+//  @end
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif