czmq-ffi-gen 0.13.0-x86-mingw32 → 0.14.1-x86-mingw32

data/vendor/local/include/ziflist.h

@@ -1,6 +1,6 @@
 /*  =========================================================================
     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.
@@ -23,6 +23,8 @@ extern "C" {
 //  @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.
 //  Get a list of network interfaces currently defined on the system
 CZMQ_EXPORT ziflist_t *
     ziflist_new (void);
@@ -67,6 +69,25 @@ CZMQ_EXPORT void
 CZMQ_EXPORT void
     ziflist_test (bool verbose);
 
+#ifdef CZMQ_BUILD_DRAFT_API
+//  *** Draft method, for development use, may change without warning ***
+//  Get a list of network interfaces currently defined on the system
+//  Includes IPv6 interfaces
+//  Caller owns return value and must destroy it when done.
+CZMQ_EXPORT ziflist_t *
+    ziflist_new_ipv6 (void);
+
+//  *** Draft method, for development use, may change without warning ***
+//  Reload network interfaces from system, including IPv6
+CZMQ_EXPORT void
+    ziflist_reload_ipv6 (ziflist_t *self);
+
+//  *** Draft method, for development use, may change without warning ***
+//  Return true if the current interface uses IPv6
+CZMQ_EXPORT bool
+    ziflist_is_ipv6 (ziflist_t *self);
+
+#endif // CZMQ_BUILD_DRAFT_API
 //  @end
 
 

data/vendor/local/include/zlist.h

@@ -40,17 +40,17 @@ 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.  
+//  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.     
+//  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.  
+//  Leaves cursor pointing at the tail item, or NULL if the list is empty.
 CZMQ_EXPORT void *
     zlist_last (zlist_t *self);
 
@@ -62,20 +62,20 @@ CZMQ_EXPORT void *
 CZMQ_EXPORT void *
     zlist_tail (zlist_t *self);
 
-//  Return the current item of list. If the list is empty, returns NULL.     
+//  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  
+//  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.                  
+//  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  
+//  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.                  
+//  been set, this method will also duplicate the item.
 CZMQ_EXPORT int
     zlist_push (zlist_t *self, void *item);
 
@@ -83,9 +83,9 @@ CZMQ_EXPORT int
 CZMQ_EXPORT void *
     zlist_pop (zlist_t *self);
 
-//  Checks if an item already is present. Uses compare method to determine if 
+//  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.                     
+//  pointers. Returns true if item is present else false.
 CZMQ_EXPORT bool
     zlist_exists (zlist_t *self, void *item);
 
@@ -93,10 +93,10 @@ CZMQ_EXPORT bool
 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  
+//  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.                                                                    
+//  NULL.
 //  Caller owns return value and must destroy it when done.
 CZMQ_EXPORT zlist_t *
     zlist_dup (zlist_t *self);
@@ -109,38 +109,38 @@ CZMQ_EXPORT void
 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 
+//  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.            
+//  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 
+//  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 
+//  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.                                                        
+//  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.        
+//  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    
+//  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.                   
+//  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);
 

data/vendor/local/include/zlistx.h

@@ -40,19 +40,19 @@ CZMQ_EXPORT zlistx_t *
     zlistx_new (void);
 
 //  Destroy a list. If an item destructor was specified, all items in the
-//  list are automatically destroyed as well.                            
+//  list are automatically destroyed as well.
 CZMQ_EXPORT void
     zlistx_destroy (zlistx_t **self_p);
 
 //  Add an item to the head of the list. Calls the item duplicator, if any,
-//  on the item. Resets cursor to list head. Returns an item handle on     
-//  success, NULL if memory was exhausted.                                 
+//  on the item. Resets cursor to list head. Returns an item handle on
+//  success, NULL if memory was exhausted.
 CZMQ_EXPORT void *
     zlistx_add_start (zlistx_t *self, void *item);
 
 //  Add an item to the tail of the list. Calls the item duplicator, if any,
-//  on the item. Resets cursor to list head. Returns an item handle on     
-//  success, NULL if memory was exhausted.                                 
+//  on the item. Resets cursor to list head. Returns an item handle on
+//  success, NULL if memory was exhausted.
 CZMQ_EXPORT void *
     zlistx_add_end (zlistx_t *self, void *item);
 
@@ -69,68 +69,68 @@ CZMQ_EXPORT void *
     zlistx_tail (zlistx_t *self);
 
 //  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.  
+//  Leaves cursor pointing at the head item, or NULL if the list is empty.
 CZMQ_EXPORT void *
     zlistx_first (zlistx_t *self);
 
-//  Return the next item. At the end of the list (or in an empty list),     
+//  Return the next item. At the end of the list (or in an empty list),
 //  returns NULL. Use repeated zlistx_next () calls to work through the list
-//  from zlistx_first (). First time, acts as zlistx_first().               
+//  from zlistx_first (). First time, acts as zlistx_first().
 CZMQ_EXPORT void *
     zlistx_next (zlistx_t *self);
 
 //  Return the previous item. At the start of the list (or in an empty list),
-//  returns NULL. Use repeated zlistx_prev () calls to work through the list 
-//  backwards from zlistx_last (). First time, acts as zlistx_last().        
+//  returns NULL. Use repeated zlistx_prev () calls to work through the list
+//  backwards from zlistx_last (). First time, acts as zlistx_last().
 CZMQ_EXPORT void *
     zlistx_prev (zlistx_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.  
+//  Leaves cursor pointing at the tail item, or NULL if the list is empty.
 CZMQ_EXPORT void *
     zlistx_last (zlistx_t *self);
 
 //  Returns the value of the item at the cursor, or NULL if the cursor is
-//  not pointing to an item.                                             
+//  not pointing to an item.
 CZMQ_EXPORT void *
     zlistx_item (zlistx_t *self);
 
 //  Returns the handle of the item at the cursor, or NULL if the cursor is
-//  not pointing to an item.                                              
+//  not pointing to an item.
 CZMQ_EXPORT void *
     zlistx_cursor (zlistx_t *self);
 
-//  Returns the item associated with the given list handle, or NULL if passed     
+//  Returns the item associated with the given list handle, or NULL if passed
 //  in handle is NULL. Asserts that the passed in handle points to a list element.
 CZMQ_EXPORT void *
     zlistx_handle_item (void *handle);
 
-//  Find an item in the list, searching from the start. Uses the item     
-//  comparator, if any, else compares item values directly. Returns the   
+//  Find an item in the list, searching from the start. Uses the item
+//  comparator, if any, else compares item values directly. Returns the
 //  item handle found, or NULL. Sets the cursor to the found item, if any.
 CZMQ_EXPORT void *
     zlistx_find (zlistx_t *self, void *item);
 
-//  Detach an item from the list, using its handle. The item is not modified, 
+//  Detach an item from the list, using its handle. The item is not modified,
 //  and the caller is responsible for destroying it if necessary. If handle is
 //  null, detaches the first item on the list. Returns item that was detached,
 //  or null if none was. If cursor was at item, moves cursor to previous item,
-//  so you can detach items while iterating forwards through a list.          
+//  so you can detach items while iterating forwards through a list.
 CZMQ_EXPORT void *
     zlistx_detach (zlistx_t *self, void *handle);
 
 //  Detach item at the cursor, if any, from the list. The item is not modified,
-//  and the caller is responsible for destroying it as necessary. Returns item 
-//  that was detached, or null if none was. Moves cursor to previous item, so  
-//  you can detach items while iterating forwards through a list.              
+//  and the caller is responsible for destroying it as necessary. Returns item
+//  that was detached, or null if none was. Moves cursor to previous item, so
+//  you can detach items while iterating forwards through a list.
 CZMQ_EXPORT void *
     zlistx_detach_cur (zlistx_t *self);
 
-//  Delete an item, using its handle. Calls the item destructor is any is 
-//  set. If handle is null, deletes the first item on the list. Returns 0 
+//  Delete an item, using its handle. Calls the item destructor is any is
+//  set. If handle is null, deletes the first item on the list. Returns 0
 //  if an item was deleted, -1 if not. If cursor was at item, moves cursor
-//  to previous item, so you can delete items while iterating forwards    
-//  through a list.                                                       
+//  to previous item, so you can delete items while iterating forwards
+//  through a list.
 CZMQ_EXPORT int
     zlistx_delete (zlistx_t *self, void *handle);
 
@@ -143,51 +143,51 @@ CZMQ_EXPORT void
     zlistx_move_end (zlistx_t *self, void *handle);
 
 //  Remove all items from the list, and destroy them if the item destructor
-//  is set.                                                                
+//  is set.
 CZMQ_EXPORT void
     zlistx_purge (zlistx_t *self);
 
-//  Sort the list. If an item comparator was set, calls that to compare    
+//  Sort the list. If an item comparator was set, calls that to compare
 //  items, otherwise compares on item value. The sort is not stable, so may
-//  reorder equal items.                                                   
+//  reorder equal items.
 CZMQ_EXPORT void
     zlistx_sort (zlistx_t *self);
 
-//  Create a new node and insert it into a sorted list. Calls the item        
-//  duplicator, if any, on the item. If low_value is true, starts searching   
-//  from the start of the list, otherwise searches from the end. Use the item 
-//  comparator, if any, to find where to place the new node. Returns a handle 
+//  Create a new node and insert it into a sorted list. Calls the item
+//  duplicator, if any, on the item. If low_value is true, starts searching
+//  from the start of the list, otherwise searches from the end. Use the item
+//  comparator, if any, to find where to place the new node. Returns a handle
 //  to the new node, or NULL if memory was exhausted. Resets the cursor to the
-//  list head.                                                                
+//  list head.
 CZMQ_EXPORT void *
     zlistx_insert (zlistx_t *self, void *item, bool low_value);
 
-//  Move an item, specified by handle, into position in a sorted list. Uses 
+//  Move an item, specified by handle, into position in a sorted list. Uses
 //  the item comparator, if any, to determine the new location. If low_value
 //  is true, starts searching from the start of the list, otherwise searches
-//  from the end.                                                           
+//  from the end.
 CZMQ_EXPORT void
     zlistx_reorder (zlistx_t *self, void *handle, bool low_value);
 
 //  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.                                                           
+//  for the list, otherwise not. Copying a null reference returns a null
+//  reference.
 CZMQ_EXPORT zlistx_t *
     zlistx_dup (zlistx_t *self);
 
 //  Set a user-defined deallocator for list items; by default items are not
-//  freed when the list is destroyed.                                      
+//  freed when the list is destroyed.
 CZMQ_EXPORT void
     zlistx_set_destructor (zlistx_t *self, zlistx_destructor_fn destructor);
 
 //  Set a user-defined duplicator for list items; by default items are not
-//  copied when the list is duplicated.                                   
+//  copied when the list is duplicated.
 CZMQ_EXPORT void
     zlistx_set_duplicator (zlistx_t *self, zlistx_duplicator_fn duplicator);
 
-//  Set a user-defined comparator for zlistx_find and zlistx_sort; the method 
+//  Set a user-defined comparator for zlistx_find and zlistx_sort; the method
 //  must return -1, 0, or 1 depending on whether item1 is less than, equal to,
-//  or greater than, item2.                                                   
+//  or greater than, item2.
 CZMQ_EXPORT void
     zlistx_set_comparator (zlistx_t *self, zlistx_comparator_fn comparator);
 

data/vendor/local/include/zloop.h

@@ -43,106 +43,106 @@ CZMQ_EXPORT zloop_t *
 CZMQ_EXPORT void
     zloop_destroy (zloop_t **self_p);
 
-//  Register socket reader with the reactor. When the reader has messages, 
+//  Register socket reader with the reactor. When the reader has messages,
 //  the reactor will call the handler, passing the arg. Returns 0 if OK, -1
-//  if there was an error. If you register the same socket more than once, 
-//  each instance will invoke its corresponding handler.                   
+//  if there was an error. If you register the same socket more than once,
+//  each instance will invoke its corresponding handler.
 CZMQ_EXPORT int
     zloop_reader (zloop_t *self, zsock_t *sock, zloop_reader_fn handler, void *arg);
 
 //  Cancel a socket reader from the reactor. If multiple readers exist for
-//  same socket, cancels ALL of them.                                     
+//  same socket, cancels ALL of them.
 CZMQ_EXPORT void
     zloop_reader_end (zloop_t *self, zsock_t *sock);
 
 //  Configure a registered reader to ignore errors. If you do not set this,
-//  then readers that have errors are removed from the reactor silently.   
+//  then readers that have errors are removed from the reactor silently.
 CZMQ_EXPORT void
     zloop_reader_set_tolerant (zloop_t *self, zsock_t *sock);
 
-//  Register low-level libzmq pollitem with the reactor. When the pollitem  
-//  is ready, will call the handler, passing the arg. Returns 0 if OK, -1   
+//  Register low-level libzmq 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. A pollitem with         
-//  socket=NULL and fd=0 means 'poll on FD zero'.                           
+//  instance will invoke its corresponding handler. A pollitem with
+//  socket=NULL and fd=0 means 'poll on FD zero'.
 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.                                       
+//  socket/FD, cancels ALL of them.
 CZMQ_EXPORT void
     zloop_poller_end (zloop_t *self, zmq_pollitem_t *item);
 
 //  Configure a registered poller to ignore errors. If you do not set this,
-//  then poller that have errors are removed from the reactor silently.    
+//  then poller that have errors are removed from the reactor silently.
 CZMQ_EXPORT void
     zloop_poller_set_tolerant (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  
+//  times. At each expiry, will call the handler, passing the arg. To run a
 //  timer forever, use 0 times. Returns a timer_id that is used to cancel the
-//  timer in the future. Returns -1 if there was an error.                   
+//  timer in the future. Returns -1 if there was an error.
 CZMQ_EXPORT int
     zloop_timer (zloop_t *self, size_t delay, size_t times, zloop_timer_fn handler, void *arg);
 
 //  Cancel a specific timer identified by a specific timer_id (as returned by
-//  zloop_timer).                                                            
+//  zloop_timer).
 CZMQ_EXPORT int
     zloop_timer_end (zloop_t *self, int timer_id);
 
-//  Register a ticket timer. Ticket timers are very fast in the case where   
-//  you use a lot of timers (thousands), and frequently remove and add them. 
-//  The main use case is expiry timers for servers that handle many clients, 
+//  Register a ticket timer. Ticket timers are very fast in the case where
+//  you use a lot of timers (thousands), and frequently remove and add them.
+//  The main use case is expiry timers for servers that handle many clients,
 //  and which reset the expiry timer for each message received from a client.
-//  Whereas normal timers perform poorly as the number of clients grows, the 
-//  cost of ticket timers is constant, no matter the number of clients. You  
-//  must set the ticket delay using zloop_set_ticket_delay before creating a 
-//  ticket. Returns a handle to the timer that you should use in             
-//  zloop_ticket_reset and zloop_ticket_delete.                              
+//  Whereas normal timers perform poorly as the number of clients grows, the
+//  cost of ticket timers is constant, no matter the number of clients. You
+//  must set the ticket delay using zloop_set_ticket_delay before creating a
+//  ticket. Returns a handle to the timer that you should use in
+//  zloop_ticket_reset and zloop_ticket_delete.
 CZMQ_EXPORT void *
     zloop_ticket (zloop_t *self, zloop_timer_fn handler, void *arg);
 
 //  Reset a ticket timer, which moves it to the end of the ticket list and
-//  resets its execution time. This is a very fast operation.             
+//  resets its execution time. This is a very fast operation.
 CZMQ_EXPORT void
     zloop_ticket_reset (zloop_t *self, void *handle);
 
-//  Delete a ticket timer. We do not actually delete the ticket here, as    
+//  Delete a ticket timer. We do not actually delete the ticket here, as
 //  other code may still refer to the ticket. We mark as deleted, and remove
-//  later and safely.                                                       
+//  later and safely.
 CZMQ_EXPORT void
     zloop_ticket_delete (zloop_t *self, void *handle);
 
-//  Set the ticket delay, which applies to all tickets. If you lower the   
+//  Set the ticket delay, which applies to all tickets. If you lower the
 //  delay and there are already tickets created, the results are undefined.
 CZMQ_EXPORT void
     zloop_set_ticket_delay (zloop_t *self, size_t ticket_delay);
 
-//  Set hard limit on number of timers allowed. Setting more than a small  
+//  Set hard limit on number of timers allowed. Setting more than a small
 //  number of timers (10-100) can have a dramatic impact on the performance
-//  of the reactor. For high-volume cases, use ticket timers. If the hard  
-//  limit is reached, the reactor stops creating new timers and logs an    
-//  error.                                                                 
+//  of the reactor. For high-volume cases, use ticket timers. If the hard
+//  limit is reached, the reactor stops creating new timers and logs an
+//  error.
 CZMQ_EXPORT void
     zloop_set_max_timers (zloop_t *self, size_t max_timers);
 
 //  Set verbose tracing of reactor on/off. The default verbose setting is
-//  off (false).                                                         
+//  off (false).
 CZMQ_EXPORT void
     zloop_set_verbose (zloop_t *self, bool verbose);
 
-//  By default the reactor stops if the process receives a SIGINT or SIGTERM 
+//  By default the reactor 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).                                          
+//  nonstop setting is off (false).
 CZMQ_EXPORT void
     zloop_set_nonstop (zloop_t *self, bool nonstop);
 
-//  Start the reactor. Takes control of the thread and returns when the 0MQ  
+//  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 canceled by a handler.   
+//  returns -1. Event handlers may register new sockets and timers, and
+//  cancel sockets. Returns 0 if interrupted, -1 if canceled by a handler.
 CZMQ_EXPORT int
     zloop_start (zloop_t *self);