#include "mutt.h"
+#include "lib/mem.h"
+
#define SOMEPRIME 149711
int hash_string (const unsigned char *s, int n)
HASH *hash_create (int nelem)
{
- HASH *table = safe_malloc (sizeof (HASH));
+ HASH *table = mem_malloc (sizeof (HASH));
if (nelem == 0)
nelem = 2;
table->nelem = nelem;
table->curnelem = 0;
- table->table = safe_calloc (nelem, sizeof (struct hash_elem *));
+ table->table = mem_calloc (nelem, sizeof (struct hash_elem *));
return table;
}
tmp = elem;
elem = elem->next;
hash_insert (table, tmp->key, tmp->data, 1);
- FREE (&tmp);
+ mem_free (&tmp);
}
}
- FREE (&ptr->table);
- FREE (&ptr);
+ mem_free (&ptr->table);
+ mem_free (&ptr);
return table;
}
struct hash_elem *ptr;
int h;
- ptr = (struct hash_elem *) safe_malloc (sizeof (struct hash_elem));
+ ptr = (struct hash_elem *) mem_malloc (sizeof (struct hash_elem));
h = hash_string ((unsigned char *) key, table->nelem);
ptr->key = key;
ptr->data = data;
int r;
for (tmp = table->table[h], last = NULL; tmp; last = tmp, tmp = tmp->next) {
- r = mutt_strcmp (tmp->key, key);
+ r = str_cmp (tmp->key, key);
if (r == 0) {
- FREE (&ptr);
+ mem_free (&ptr);
return (-1);
}
if (r > 0)
struct hash_elem *ptr = table->table[hash];
for (; ptr; ptr = ptr->next) {
- if (mutt_strcmp (key, ptr->key) == 0)
+ if (str_cmp (key, ptr->key) == 0)
return (ptr->data);
}
return NULL;
}
-void hash_delete_hash (HASH * table, int hash, const char *key,
- const void *data, void (*destroy) (void *))
+void hash_delete_hash (HASH * table, int hash, const char *key, const void *data,
+ void (*destroy) (void *))
{
struct hash_elem *ptr = table->table[hash];
struct hash_elem **last = &table->table[hash];
- for (; ptr; last = &ptr->next, ptr = ptr->next) {
- /* if `data' is given, look for a matching ->data member. this is
- * required for the case where we have multiple entries with the same
- * key
- */
- if ((data == ptr->data) || (!data && mutt_strcmp (ptr->key, key) == 0)) {
+ while (ptr) {
+ if ((data == ptr->data || !data) && str_cmp (ptr->key, key) == 0) {
*last = ptr->next;
if (destroy)
destroy (ptr->data);
- FREE (&ptr);
- table->curnelem--;
- return;
+ mem_free (&ptr);
+
+ ptr = *last;
+ } else {
+ last = &ptr->next;
+ ptr = ptr->next;
}
}
}
elem = elem->next;
if (destroy)
destroy (tmp->data);
- FREE (&tmp);
+ mem_free (&tmp);
}
}
- FREE (&pptr->table);
- FREE (ptr);
+ mem_free (&pptr->table);
+ mem_free (ptr);
+}
+
+void hash_map (HASH* table, void (*mapfunc) (const char* key, void* data,
+ unsigned long more),
+ unsigned long more) {
+ int i = 0;
+ struct hash_elem* elem = NULL;
+
+ if (!table || !mapfunc)
+ return;
+
+ for (i = 0; i < table->nelem; i++)
+ for (elem = table->table[i]; elem; elem = elem->next)
+ mapfunc (elem->key, elem->data, more);
}