use 'bool' for BLI_/BKE_ functions.
[blender.git] / source / blender / blenlib / intern / BLI_ghash.c
index 0cae9ba..ebc40eb 100644 (file)
@@ -39,7 +39,7 @@
 #include "BLI_mempool.h"
 #include "BLI_ghash.h"
 
-#include "BLO_sys_types.h" // for intptr_t support
+#include "MEM_sys_types.h"  /* for intptr_t support */
 /***/
 
 unsigned int hashsizes[] = {
@@ -78,9 +78,9 @@ void BLI_ghash_insert(GHash *gh, void *key, void *val)
        unsigned int hash = gh->hashfp(key) % gh->nbuckets;
        Entry *e = (Entry *)BLI_mempool_alloc(gh->entrypool);
 
+       e->next = gh->buckets[hash];
        e->key = key;
        e->val = val;
-       e->next = gh->buckets[hash];
        gh->buckets[hash] = e;
 
        if (++gh->nentries > (float)gh->nbuckets / 2) {
@@ -109,18 +109,18 @@ void BLI_ghash_insert(GHash *gh, void *key, void *val)
 
 void *BLI_ghash_lookup(GHash *gh, const void *key)
 {
-       if (gh) {
-               unsigned int hash = gh->hashfp(key) % gh->nbuckets;
-               Entry *e;
+       const unsigned int hash = gh->hashfp(key) % gh->nbuckets;
+       Entry *e;
 
-               for (e = gh->buckets[hash]; e; e = e->next)
-                       if (gh->cmpfp(key, e->key) == 0)
-                               return e->val;
+       for (e = gh->buckets[hash]; e; e = e->next) {
+               if (gh->cmpfp(key, e->key) == 0) {
+                       return e->val;
+               }
        }
        return NULL;
 }
 
-int BLI_ghash_remove(GHash *gh, void *key, GHashKeyFreeFP keyfreefp, GHashValFreeFP valfreefp)
+bool BLI_ghash_remove(GHash *gh, void *key, GHashKeyFreeFP keyfreefp, GHashValFreeFP valfreefp)
 {
        unsigned int hash = gh->hashfp(key) % gh->nbuckets;
        Entry *e;
@@ -140,12 +140,12 @@ int BLI_ghash_remove(GHash *gh, void *key, GHashKeyFreeFP keyfreefp, GHashValFre
                        else   gh->buckets[hash] = n;
 
                        gh->nentries--;
-                       return 1;
+                       return true;
                }
                p = e;
        }
 
-       return 0;
+       return false;
 }
 
 /* same as above but return the value,
@@ -178,16 +178,16 @@ void *BLI_ghash_pop(GHash *gh, void *key, GHashKeyFreeFP keyfreefp)
        return NULL;
 }
 
-int BLI_ghash_haskey(GHash *gh, void *key)
+bool BLI_ghash_haskey(GHash *gh, const void *key)
 {
        unsigned int hash = gh->hashfp(key) % gh->nbuckets;
        Entry *e;
 
        for (e = gh->buckets[hash]; e; e = e->next)
                if (gh->cmpfp(key, e->key) == 0)
-                       return 1;
+                       return true;
 
-       return 0;
+       return false;
 }
 
 void BLI_ghash_free(GHash *gh, GHashKeyFreeFP keyfreefp, GHashValFreeFP valfreefp)
@@ -271,9 +271,9 @@ void BLI_ghashIterator_step(GHashIterator *ghi)
                }
        }
 }
-int BLI_ghashIterator_isDone(GHashIterator *ghi)
+bool BLI_ghashIterator_notDone(GHashIterator *ghi)
 {
-       return !ghi->curEntry;
+       return ghi->curEntry != NULL;
 }
 
 /***/
@@ -312,17 +312,25 @@ int BLI_ghashutil_intcmp(const void *a, const void *b)
                return (a < b) ? -1 : 1;
 }
 
+/**
+ * This function implements the widely used "djb" hash apparently posted
+ * by Daniel Bernstein to comp.lang.c some time ago.  The 32 bit
+ * unsigned hash value starts at 5381 and for each byte 'c' in the
+ * string, is updated: <literal>hash = hash * 33 + c</literal>.  This
+ * function uses the signed value of each byte.
+ *
+ * note: this is the same hash method that glib 2.34.0 uses.
+ */
 unsigned int BLI_ghashutil_strhash(const void *ptr)
 {
-       const char *s = ptr;
-       unsigned int i = 0;
-       unsigned char c;
+       const signed char *p;
+       unsigned int h = 5381;
 
-       while ((c = *s++)) {
-               i = i * 37 + c;
+       for (p = ptr; *p != '\0'; p++) {
+               h = (h << 5) + h + *p;
        }
 
-       return i;
+       return h;
 }
 int BLI_ghashutil_strcmp(const void *a, const void *b)
 {
@@ -376,4 +384,3 @@ void BLI_ghashutil_pairfree(void *ptr)
 {
        MEM_freeN((void *)ptr);
 }
-