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

data/vendor/local/include/zarmour.h

@@ -40,14 +40,14 @@ CZMQ_EXPORT void
 
 //  Encode a stream of bytes into an armoured string. Returns the armoured
 //  string, or NULL if there was insufficient memory available to allocate
-//  a new string.                                                         
+//  a new string.
 //  Caller owns return value and must destroy it when done.
 CZMQ_EXPORT char *
     zarmour_encode (zarmour_t *self, const byte *data, size_t size);
 
-//  Decode an armoured string into a chunk. The decoded output is    
+//  Decode an armoured string into a chunk. The decoded output is
 //  null-terminated, so it may be treated as a string, if that's what
-//  it was prior to encoding.                                        
+//  it was prior to encoding.
 //  Caller owns return value and must destroy it when done.
 CZMQ_EXPORT zchunk_t *
     zarmour_decode (zarmour_t *self, const char *data);

data/vendor/local/include/zcert.h

@@ -62,16 +62,16 @@ CZMQ_EXPORT void
     zcert_set_meta (zcert_t *self, const char *name, const char *format, ...) CHECK_PRINTF (3);
 
 //  Get metadata value from certificate; if the metadata value doesn't
-//  exist, returns NULL.                                              
+//  exist, returns NULL.
 CZMQ_EXPORT const char *
     zcert_meta (zcert_t *self, const char *name);
 
 //  Get list of metadata fields from certificate. Caller is responsible for
-//  destroying list. Caller should not modify the values of list items.    
+//  destroying list. Caller should not modify the values of list items.
 CZMQ_EXPORT zlist_t *
     zcert_meta_keys (zcert_t *self);
 
-//  Save full certificate (public + secret) to file for persistent storage  
+//  Save full certificate (public + secret) to file for persistent storage
 //  This creates one public file and one secret file (filename + "_secret").
 CZMQ_EXPORT int
     zcert_save (zcert_t *self, const char *filename);
@@ -85,13 +85,13 @@ CZMQ_EXPORT int
     zcert_save_secret (zcert_t *self, const char *filename);
 
 //  Apply certificate to socket, i.e. use for CURVE security on socket.
-//  If certificate was loaded from public file, the secret key will be 
-//  undefined, and this certificate will not work successfully.        
+//  If certificate was loaded from public file, the secret key will be
+//  undefined, and this certificate will not work successfully.
 CZMQ_EXPORT void
     zcert_apply (zcert_t *self, void *socket);
 
 //  Return copy of certificate; if certificate is NULL or we exhausted
-//  heap memory, returns NULL.                                        
+//  heap memory, returns NULL.
 //  Caller owns return value and must destroy it when done.
 CZMQ_EXPORT zcert_t *
     zcert_dup (zcert_t *self);
@@ -109,6 +109,11 @@ CZMQ_EXPORT void
     zcert_test (bool verbose);
 
 #ifdef CZMQ_BUILD_DRAFT_API
+//  *** Draft method, for development use, may change without warning ***
+//  Accepts public/secret key text pair from caller
+CZMQ_EXPORT zcert_t *
+    zcert_new_from_txt (const char *public_txt, const char *secret_txt);
+
 //  *** Draft method, for development use, may change without warning ***
 //  Unset certificate metadata.
 CZMQ_EXPORT void

data/vendor/local/include/zcertstore.h

@@ -25,28 +25,28 @@ extern "C" {
 //  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.
-//  Create a new certificate store from a disk directory, loading and        
-//  indexing all certificates in that location. The directory itself may be  
+//  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.                      
+//  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.
 CZMQ_EXPORT zcertstore_t *
     zcertstore_new (const char *location);
 
 //  Destroy a certificate store object in memory. Does not affect anything
-//  stored on disk.                                                       
+//  stored on disk.
 CZMQ_EXPORT void
     zcertstore_destroy (zcertstore_t **self_p);
 
 //  Look up certificate by public key, returns zcert_t object if found,
-//  else returns NULL. The public key is provided in Z85 text format.  
+//  else returns NULL. The public key is provided in Z85 text format.
 CZMQ_EXPORT zcert_t *
     zcertstore_lookup (zcertstore_t *self, const char *public_key);
 
 //  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.    
+//  directly on the certificate. Takes ownership of zcert_t object.
 CZMQ_EXPORT void
     zcertstore_insert (zcertstore_t *self, zcert_t **cert_p);
 
@@ -74,10 +74,19 @@ CZMQ_EXPORT void
 
 //  *** Draft method, for development use, may change without warning ***
 //  Empty certificate hashtable. This wrapper exists to be friendly to bindings,
-//  which don't usually have access to struct internals.                        
+//  which don't usually have access to struct internals.
 CZMQ_EXPORT void
     zcertstore_empty (zcertstore_t *self);
 
+//  *** Draft method, for development use, may change without warning ***
+//  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.
+//  Caller owns return value and must destroy it when done.
+CZMQ_EXPORT zlistx_t *
+    zcertstore_certs (zcertstore_t *self);
+
 #endif // CZMQ_BUILD_DRAFT_API
 //  @end
 

data/vendor/local/include/zchunk.h

@@ -23,8 +23,8 @@ extern "C" {
 //  @interface
 //  This is a stable class, and may not change except for emergencies. It
 //  is provided in stable builds.
-//  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  
+//  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.
 CZMQ_EXPORT zchunk_t *
     zchunk_new (const void *data, size_t size);
@@ -50,7 +50,7 @@ CZMQ_EXPORT byte *
     zchunk_data (zchunk_t *self);
 
 //  Set chunk data from user-supplied data; truncate if too large. Data may
-//  be null. Returns actual size of chunk                                  
+//  be null. Returns actual size of chunk
 CZMQ_EXPORT size_t
     zchunk_set (zchunk_t *self, const void *data, size_t size);
 
@@ -58,26 +58,26 @@ CZMQ_EXPORT size_t
 CZMQ_EXPORT size_t
     zchunk_fill (zchunk_t *self, byte filler, size_t size);
 
-//  Append user-supplied data to chunk, return resulting chunk size. If the 
+//  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.   
+//  grow the chunk to accommodate new data, use the zchunk_extend method.
 CZMQ_EXPORT size_t
     zchunk_append (zchunk_t *self, 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.      
+//  data would exceeded the available space, the chunk grows in size.
 CZMQ_EXPORT size_t
     zchunk_extend (zchunk_t *self, 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  
+//  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. 
+//  it is exhausted. If source was already exhausted, does not change chunk.
 CZMQ_EXPORT size_t
     zchunk_consume (zchunk_t *self, zchunk_t *source);
 
 //  Returns true if the chunk was exhausted by consume methods, or if the
-//  chunk has a size of zero.                                            
+//  chunk has a size of zero.
 CZMQ_EXPORT bool
     zchunk_exhausted (zchunk_t *self);
 
@@ -90,29 +90,29 @@ CZMQ_EXPORT zchunk_t *
 CZMQ_EXPORT int
     zchunk_write (zchunk_t *self, 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  
+//  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.
 //  Caller owns return value and must destroy it when done.
 CZMQ_EXPORT zchunk_t *
     zchunk_slurp (const char *filename, size_t maxsize);
 
-//  Create copy of chunk, as new chunk object. Returns a fresh zchunk_t   
+//  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.                                                         
+//  returns null.
 //  Caller owns return value and must destroy it when done.
 CZMQ_EXPORT zchunk_t *
     zchunk_dup (zchunk_t *self);
 
 //  Return chunk data encoded as printable hex string. Caller must free
-//  string when finished with it.                                      
+//  string when finished with it.
 //  Caller owns return value and must destroy it when done.
 CZMQ_EXPORT char *
     zchunk_strhex (zchunk_t *self);
 
 //  Return chunk data copied into freshly allocated string
-//  Caller must free string when finished with it.        
+//  Caller must free string when finished with it.
 //  Caller owns return value and must destroy it when done.
 CZMQ_EXPORT char *
     zchunk_strdup (zchunk_t *self);
@@ -140,7 +140,7 @@ CZMQ_EXPORT void
     zchunk_fprint (zchunk_t *self, FILE *file);
 
 //  Dump message to stderr, for debugging and tracing.
-//  See zchunk_fprint for details                     
+//  See zchunk_fprint for details
 CZMQ_EXPORT void
     zchunk_print (zchunk_t *self);
 

data/vendor/local/include/zclock.h

@@ -27,21 +27,21 @@ extern "C" {
 CZMQ_EXPORT void
     zclock_sleep (int msecs);
 
-//  Return current system clock as milliseconds. Note that this clock can  
+//  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.             
+//  timers and time offsets. Use zclock_mono for that instead.
 CZMQ_EXPORT int64_t
     zclock_time (void);
 
 //  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.                 
+//  time offsets. The monotonic clock is not affected by system changes and
+//  so will never be reset backwards, unlike a system clock.
 CZMQ_EXPORT int64_t
     zclock_mono (void);
 
 //  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.                 
+//  time offsets. The monotonic clock is not affected by system changes and
+//  so will never be reset backwards, unlike a system clock.
 CZMQ_EXPORT int64_t
     zclock_usecs (void);
 

data/vendor/local/include/zconfig.h

@@ -23,7 +23,9 @@ 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.
+//
 typedef int (zconfig_fct) (
     zconfig_t *self, void *arg, int level);
 
@@ -31,14 +33,14 @@ typedef int (zconfig_fct) (
 CZMQ_EXPORT zconfig_t *
     zconfig_new (const char *name, zconfig_t *parent);
 
-//  Load a config tree from a specified ZPL text file; returns a zconfig_t  
+//  Load a config tree from a specified ZPL text file; returns a zconfig_t
 //  reference for the root, if the file exists and is readable. Returns NULL
-//  if the file does not exist.                                             
+//  if the file does not exist.
 CZMQ_EXPORT zconfig_t *
     zconfig_load (const char *filename);
 
 //  Equivalent to zconfig_load, taking a format string instead of a fixed
-//  filename.                                                            
+//  filename.
 CZMQ_EXPORT zconfig_t *
     zconfig_loadf (const char *format, ...) CHECK_PRINTF (1);
 
@@ -59,12 +61,12 @@ CZMQ_EXPORT void
     zconfig_put (zconfig_t *self, const char *path, const char *value);
 
 //  Equivalent to zconfig_put, accepting a format specifier and variable
-//  argument list, instead of a single string value.                    
+//  argument list, instead of a single string value.
 CZMQ_EXPORT void
     zconfig_putf (zconfig_t *self, const char *path, const char *format, ...) CHECK_PRINTF (3);
 
 //  Get value for config item into a string value; leading slash is optional
-//  and ignored.                                                            
+//  and ignored.
 CZMQ_EXPORT char *
     zconfig_get (zconfig_t *self, const char *path, const char *default_value);
 
@@ -72,10 +74,10 @@ CZMQ_EXPORT char *
 CZMQ_EXPORT void
     zconfig_set_name (zconfig_t *self, const char *name);
 
-//  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 
+//  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.                                                          
+//  by the string.
 CZMQ_EXPORT void
     zconfig_set_value (zconfig_t *self, const char *format, ...) CHECK_PRINTF (2);
 
@@ -96,13 +98,13 @@ CZMQ_EXPORT zconfig_t *
     zconfig_at_depth (zconfig_t *self, int level);
 
 //  Execute a callback for each config item in the tree; returns zero if
-//  successful, else -1.                                                
+//  successful, else -1.
 CZMQ_EXPORT int
     zconfig_execute (zconfig_t *self, zconfig_fct handler, void *arg);
 
 //  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.                                                             
+//  deleted.
 CZMQ_EXPORT void
     zconfig_set_comment (zconfig_t *self, const char *format, ...) CHECK_PRINTF (2);
 
@@ -111,12 +113,12 @@ CZMQ_EXPORT zlist_t *
     zconfig_comments (zconfig_t *self);
 
 //  Save a config tree to a specified ZPL text file, where a filename
-//  "-" means dump to standard output.                               
+//  "-" means dump to standard output.
 CZMQ_EXPORT int
     zconfig_save (zconfig_t *self, const char *filename);
 
 //  Equivalent to zconfig_save, taking a format string instead of a fixed
-//  filename.                                                            
+//  filename.
 CZMQ_EXPORT int
     zconfig_savef (zconfig_t *self, const char *format, ...) CHECK_PRINTF (2);
 
@@ -125,8 +127,8 @@ CZMQ_EXPORT const char *
     zconfig_filename (zconfig_t *self);
 
 //  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).                                                      
+//  Returns 0 if OK, -1 if there was an error (and then does not change
+//  existing data).
 CZMQ_EXPORT int
     zconfig_reload (zconfig_t **self_p);
 
@@ -149,7 +151,7 @@ CZMQ_EXPORT char *
     zconfig_str_save (zconfig_t *self);
 
 //  Return true if a configuration tree was loaded from a file and that
-//  file has changed in since the tree was loaded.                     
+//  file has changed in since the tree was loaded.
 CZMQ_EXPORT bool
     zconfig_has_changed (zconfig_t *self);
 
@@ -165,6 +167,13 @@ CZMQ_EXPORT void
 CZMQ_EXPORT void
     zconfig_test (bool verbose);
 
+#ifdef CZMQ_BUILD_DRAFT_API
+//  *** Draft method, for development use, may change without warning ***
+//  Destroy subtree (child)
+CZMQ_EXPORT void
+    zconfig_remove (zconfig_t *self);
+
+#endif // CZMQ_BUILD_DRAFT_API
 //  @end
 
 //  Self test of this class

data/vendor/local/include/zdigest.h

@@ -24,7 +24,7 @@ extern "C" {
 //  This is a stable class, and may not change except for emergencies. It
 //  is provided in stable builds.
 //  Constructor - creates new digest object, which you use to build up a
-//  digest by repeatedly calling zdigest_update() on chunks of data.    
+//  digest by repeatedly calling zdigest_update() on chunks of data.
 CZMQ_EXPORT zdigest_t *
     zdigest_new (void);
 
@@ -37,7 +37,7 @@ CZMQ_EXPORT void
     zdigest_update (zdigest_t *self, const byte *buffer, size_t length);
 
 //  Return final digest hash data. If built without crypto support,
-//  returns NULL.                                                  
+//  returns NULL.
 CZMQ_EXPORT const byte *
     zdigest_data (zdigest_t *self);
 
@@ -45,9 +45,9 @@ CZMQ_EXPORT const byte *
 CZMQ_EXPORT size_t
     zdigest_size (zdigest_t *self);
 
-//  Return digest as printable hex string; caller should not modify nor   
+//  Return digest as printable hex string; caller should not modify nor
 //  free this string. After calling this, you may not use zdigest_update()
-//  on the same digest. If built without crypto support, returns NULL.    
+//  on the same digest. If built without crypto support, returns NULL.
 CZMQ_EXPORT char *
     zdigest_string (zdigest_t *self);
 

data/vendor/local/include/zdir.h

@@ -24,8 +24,8 @@ extern "C" {
 //  This is a stable class, and may not change except for emergencies. It
 //  is provided in stable builds.
 //  Create a new directory item that loads in the full tree of the specified
-//  path, optionally located under some parent path. If parent is "-", then 
-//  loads only the top-level directory, and does not use parent as a path.  
+//  path, optionally located under some parent path. If parent is "-", then
+//  loads only the top-level directory, and does not use parent as a path.
 CZMQ_EXPORT zdir_t *
     zdir_new (const char *path, const char *parent);
 
@@ -42,7 +42,7 @@ CZMQ_EXPORT time_t
     zdir_modified (zdir_t *self);
 
 //  Return total hierarchy size, in bytes of data contained in all files
-//  in the directory tree.                                              
+//  in the directory tree.
 CZMQ_EXPORT off_t
     zdir_cursize (zdir_t *self);
 
@@ -51,22 +51,22 @@ CZMQ_EXPORT size_t
     zdir_count (zdir_t *self);
 
 //  Returns a sorted list of zfile objects; Each entry in the list is a pointer
-//  to a zfile_t item already allocated in the zdir tree. Do not destroy the   
-//  original zdir tree until you are done with this list.                      
+//  to a zfile_t item already allocated in the zdir tree. Do not destroy the
+//  original zdir tree until you are done with this list.
 //  Caller owns return value and must destroy it when done.
 CZMQ_EXPORT zlist_t *
     zdir_list (zdir_t *self);
 
-//  Remove directory, optionally including all files that it contains, at  
+//  Remove directory, optionally including all files that it contains, at
 //  all levels. If force is false, will only remove the directory if empty.
-//  If force is true, will remove all files and all subdirectories.        
+//  If force is true, will remove all files and all subdirectories.
 CZMQ_EXPORT void
     zdir_remove (zdir_t *self, bool force);
 
-//  Calculate differences between two versions of a directory tree.    
-//  Returns a list of zdir_patch_t patches. Either older or newer may  
+//  Calculate differences between two versions of a directory tree.
+//  Returns a list of zdir_patch_t patches. Either older or newer may
 //  be null, indicating the directory is empty/absent. If alias is set,
-//  generates virtual filename (minus path, plus alias).               
+//  generates virtual filename (minus path, plus alias).
 //  Caller owns return value and must destroy it when done.
 CZMQ_EXPORT zlist_t *
     zdir_diff (zdir_t *older, zdir_t *newer, const char *alias);
@@ -77,7 +77,7 @@ CZMQ_EXPORT zlist_t *
     zdir_resync (zdir_t *self, const char *alias);
 
 //  Load directory cache; returns a hash table containing the SHA-1 digests
-//  of every file in the tree. The cache is saved between runs in .cache.  
+//  of every file in the tree. The cache is saved between runs in .cache.
 //  Caller owns return value and must destroy it when done.
 CZMQ_EXPORT zhash_t *
     zdir_cache (zdir_t *self);
@@ -90,32 +90,32 @@ CZMQ_EXPORT void
 CZMQ_EXPORT void
     zdir_print (zdir_t *self, int indent);
 
-//  Create a new zdir_watch actor instance:                       
-//                                                                
-//      zactor_t *watch = zactor_new (zdir_watch, NULL);          
-//                                                                
-//  Destroy zdir_watch instance:                                  
-//                                                                
-//      zactor_destroy (&watch);                                  
-//                                                                
-//  Enable verbose logging of commands and activity:              
-//                                                                
-//      zstr_send (watch, "VERBOSE");                             
-//                                                                
-//  Subscribe to changes to a directory path:                     
-//                                                                
-//      zsock_send (watch, "ss", "SUBSCRIBE", "directory_path");  
-//                                                                
-//  Unsubscribe from changes to a directory path:                 
-//                                                                
+//  Create a new zdir_watch actor instance:
+//
+//      zactor_t *watch = zactor_new (zdir_watch, NULL);
+//
+//  Destroy zdir_watch instance:
+//
+//      zactor_destroy (&watch);
+//
+//  Enable verbose logging of commands and activity:
+//
+//      zstr_send (watch, "VERBOSE");
+//
+//  Subscribe to changes to a directory path:
+//
+//      zsock_send (watch, "ss", "SUBSCRIBE", "directory_path");
+//
+//  Unsubscribe from changes to a directory path:
+//
 //      zsock_send (watch, "ss", "UNSUBSCRIBE", "directory_path");
-//                                                                
-//  Receive directory changes:                                    
-//      zsock_recv (watch, "sp", &path, &patches);                
-//                                                                
-//      // Delete the received data.                              
-//      free (path);                                              
-//      zlist_destroy (&patches);                                 
+//
+//  Receive directory changes:
+//      zsock_recv (watch, "sp", &path, &patches);
+//
+//      // Delete the received data.
+//      free (path);
+//      zlist_destroy (&patches);
 CZMQ_EXPORT void
     zdir_watch (zsock_t *pipe, void *unused);