Merge pull request #97 from hintjens/master

Added load/save methods to zhash class

Author: methodmissing

include/zhash.h

@@ -100,6 +100,22 @@ CZMQ_EXPORT zlist_t *
 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
 void
     zhash_test (int verbose);

src/zclock.c

@@ -27,15 +27,6 @@ The zclock class provides essential sleep and system time functions, used
 to slow down threads for testing, and calculate timers for polling. Wraps
 the non-portable system calls in a simple portable API.
 @discuss
-This class contains some small surprises. Most amazing, win32 did an API
-better than POSIX. The win32 Sleep() call is not only a neat 1-liner, it
-also sleeps for milliseconds, whereas the POSIX call asks us to think in
-terms of nanoseconds, which is insane. I've decided every single man page
-for this library will say "insane" at least once. Anyhow, milliseconds
-are a concept we can deal with. Seconds are too fat, nanoseconds too
-tiny, but milliseconds are just right for slices of time we want to work
-with at the 0MQ scale. zclock doesn't give you objects to work with, we
-like the czmq class model but we're not insane. There, got it in again.
 The Win32 Sleep() call defaults to 16ms resolution unless the system timer
 resolution is increased with a call to timeBeginPeriod() permitting 1ms
 granularity.
@@ -52,9 +43,10 @@ granularity.
 static int64_t
 s_filetime_to_msec (const FILETIME *ft)
 {
-//  As per Windows documentation for FILETIME, copy the resulting FILETIME structure to a
-//  ULARGE_INTEGER structure using memcpy (using memcpy instead of direct assignment can
-//  prevent alignment faults on 64-bit Windows).
+    //  As per Windows documentation for FILETIME, copy the resulting FILETIME
+    //  structure to a ULARGE_INTEGER structure using memcpy (using memcpy
+    //  instead of direct assignment can prevent alignment faults on 64-bit
+    //  Windows).
     ULARGE_INTEGER dateTime;
     memcpy (&dateTime, ft, sizeof (dateTime));
 
@@ -75,11 +67,12 @@ zclock_sleep (int msecs)
     t.tv_nsec = (msecs % 1000) * 1000000;
     nanosleep (&t, NULL);
 #elif (defined (__WINDOWS__))
-//  Windows XP/2000:  A value of zero causes the thread to relinquish the
-//  remainder of its time slice to any other thread of equal priority that is
-//  ready to run. If there are no other threads of equal priority ready to run,
-//  the function returns immediately, and the thread continues execution. This
-//  behavior changed starting with Windows Server 2003.
+    //  Windows XP/2000:  A value of zero causes the thread to relinquish the
+    //  remainder of its time slice to any other thread of equal priority that
+    //  is ready to run. If there are no other threads of equal priority ready
+    //  to run, the function returns immediately, and the thread continues
+    //  execution. This behavior changed starting with Windows Server 2003.
+    
 #   if defined (NTDDI_VERSION) && defined (NTDDI_WS03) && (NTDDI_VERSION >= NTDDI_WS03)
     Sleep (msecs);
 #   else

src/zhash.c

@@ -46,31 +46,23 @@
 //  Hash item, used internally only
 
 typedef struct _item_t {
-    void
-        *value;                 //  Opaque item value
-    struct _item_t
-        *next;                  //  Next item in the hash slot
-    qbyte
-        index;                  //  Index of item in table
-    char
-        *key;                   //  Item's original key
-    zhash_free_fn
-        *free_fn;               //  Value free function if any
+    void *value;                //  Opaque item value
+    struct _item_t *next;       //  Next item in the hash slot
+    qbyte index;                //  Index of item in table
+    char *key;                  //  Item's original key
+    zhash_free_fn *free_fn;     //  Value free function if any
 } item_t;
 
 
 //  ---------------------------------------------------------------------
 //  Structure of our class
 
 struct _zhash {
-    size_t
-        size;                   //  Current size of hash table
-    size_t
-        limit;                  //  Current hash table limit
-    item_t
-        **items;                //  Array of items
-    uint
-        cached_index;           //  Avoids duplicate hash calculations
+    size_t size;                //  Current size of hash table
+    size_t limit;               //  Current hash table limit
+    item_t **items;             //  Array of items
+    uint cached_index;          //  Avoids duplicate hash calculations
+    bool autofree;              //  If true, free values in destructor
 };
 
 
@@ -81,10 +73,8 @@ struct _zhash {
 static uint
 s_item_hash (const char *key, size_t limit)
 {
-    uint
-        key_hash = 0;
-
     //  Modified Bernstein hashing function
+    uint key_hash = 0;
     while (*key)
         key_hash = 33 * key_hash ^ *key++;
     key_hash %= limit;
@@ -162,6 +152,10 @@ s_item_destroy (zhash_t *self, item_t *item, bool hard)
     if (hard) {
         if (item->free_fn)
             (item->free_fn) (item->value);
+        else
+        if (self->autofree)
+            free (item->value);
+        
         free (item->key);
         free (item);
     }
@@ -271,6 +265,9 @@ zhash_update (zhash_t *self, const char *key, void *value)
     if (item) {
         if (item->free_fn)
             (item->free_fn) (item->value);
+        else
+        if (self->autofree)
+            free (item->value);
         item->value = value;
     }
     else
@@ -386,20 +383,21 @@ zhash_dup (zhash_t *self)
         return NULL;
 
     zhash_t *copy = zhash_new ();
+    zhash_autofree (copy);
     if (copy) {
         uint index;
         for (index = 0; index != self->limit; index++) {
             item_t *item = self->items [index];
             while (item) {
                 zhash_insert (copy, item->key, strdup (item->value));
-                zhash_freefn (copy, item->key, free);
                 item = item->next;
             }
         }
     }
     return copy;
 }
 
+
 //  --------------------------------------------------------------------------
 //  Return keys for items in table
 
@@ -448,6 +446,76 @@ 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
+
+int
+zhash_save (zhash_t *self, char *filename)
+{
+    assert (self);
+
+    FILE *handle = fopen (filename, "w");
+    if (!handle)
+        return -1;              //  Failed to create file
+    
+    uint index;
+    for (index = 0; index != self->limit; index++) {
+        item_t *item = self->items [index];
+        while (item) {
+            fprintf (handle, "%s=%s\n", item->key, (char *) item->value);
+            item = item->next;
+        }
+    }
+    fclose (handle);
+    return 0;
+}
+
+
+//  --------------------------------------------------------------------------
+//  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.
+
+int
+zhash_load (zhash_t *self, char *filename)
+{
+    assert (self);
+    zhash_autofree (self);
+    
+    FILE *handle = fopen (filename, "r");
+    if (!handle)
+        return -1;              //  Failed to create file
+
+    char buffer [1024];
+    while (fgets (buffer, 1024, handle)) {
+        //  Buffer may end in newline, which we don't want
+        if (buffer [strlen (buffer) - 1] == '\n')
+            buffer [strlen (buffer) - 1] = 0;
+        //  Split at equals, if any
+        char *equals = strchr (buffer, '=');
+        if (!equals)
+            break;              //  Some error, stop parsing it
+        *equals++ = 0;
+        zhash_update (self, buffer, strdup (equals));
+    }
+    fclose (handle);
+    return 0;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Set hash for automatic value destruction
+
+void
+zhash_autofree (zhash_t *self)
+{
+    assert (self);
+    self->autofree = true;
+}
+
+
 //  --------------------------------------------------------------------------
 //  Runs selftest of class
 //  TODO: add unit test for free_fn, foreach
@@ -509,8 +577,25 @@ zhash_test (int verbose)
     //  Test dup method
     zhash_t *copy = zhash_dup (hash);
     assert (zhash_size (copy) == 4);
+    item = zhash_lookup (copy, "LIVEBEEF");
+    assert (item);
+    assert (streq (item, "dead beef"));
     zhash_destroy (&copy);
 
+    //  Test save and load
+    zhash_save (hash, ".cache");
+    copy = zhash_new ();
+    zhash_load (copy, ".cache");
+    item = zhash_lookup (copy, "LIVEBEEF");
+    assert (item);
+    assert (streq (item, "dead beef"));
+    zhash_destroy (&copy);
+#if (defined (WIN32))
+    DeleteFile (".cache");
+#else
+    unlink (".cache");
+#endif
+        
     //  Delete a item
     zhash_delete (hash, "LIVEBEEF");
     item = zhash_lookup (hash, "LIVEBEEF");

src/zlist.c

@@ -350,6 +350,7 @@ s_compare (void *item1, void *item2)
         return false;
 }
 
+
 //  --------------------------------------------------------------------------
 //  Set list for automatic item destruction
 
@@ -360,6 +361,7 @@ zlist_autofree (zlist_t *self)
     self->autofree = true;
 }
 
+
 //  --------------------------------------------------------------------------
 //  Runs selftest of class