struct hashmap_entry {
const void *key;
void *value;
-
struct hashmap_entry *bucket_next, *bucket_previous;
struct hashmap_entry *iterate_next, *iterate_previous;
};
return h;
}
+int hashmap_ensure_allocated(Hashmap **h, hash_func_t hash_func, compare_func_t compare_func) {
+ assert(h);
+
+ if (*h)
+ return 0;
+
+ if (!(*h = hashmap_new(hash_func, compare_func)))
+ return -ENOMEM;
+
+ return 0;
+}
+
static void remove_entry(Hashmap *h, struct hashmap_entry *e) {
assert(h);
assert(e);
if (!h)
return;
- while (h->iterate_list_head)
- remove_entry(h, h->iterate_list_head);
+ hashmap_clear(h);
free(h);
}
+void hashmap_clear(Hashmap *h) {
+ if (!h)
+ return;
+
+ while (h->iterate_list_head)
+ remove_entry(h, h->iterate_list_head);
+}
+
static struct hashmap_entry *hash_scan(Hashmap *h, unsigned hash, const void *key) {
struct hashmap_entry *e;
assert(h);
hash = h->hash_func(key) % NBUCKETS;
- if (hash_scan(h, hash, key))
+ if ((e = hash_scan(h, hash, key))) {
+
+ if (e->value == value)
+ return 0;
+
return -EEXIST;
+ }
if (!(e = new(struct hashmap_entry, 1)))
return -ENOMEM;
return 0;
}
+int hashmap_replace(Hashmap *h, const void *key, void *value) {
+ struct hashmap_entry *e;
+ unsigned hash;
+
+ assert(h);
+
+ hash = h->hash_func(key) % NBUCKETS;
+
+ if ((e = hash_scan(h, hash, key))) {
+ e->value = value;
+ return 0;
+ }
+
+ return hashmap_put(h, key, value);
+}
+
void* hashmap_get(Hashmap *h, const void *key) {
unsigned hash;
struct hashmap_entry *e;
return data;
}
-void *hashmap_iterate(Hashmap *h, void **state, const void **key) {
+void* hashmap_remove_value(Hashmap *h, const void *key, void *value) {
+ struct hashmap_entry *e;
+ unsigned hash;
+
+ if (!h)
+ return NULL;
+
+ hash = h->hash_func(key) % NBUCKETS;
+
+ if (!(e = hash_scan(h, hash, key)))
+ return NULL;
+
+ if (e->value != value)
+ return NULL;
+
+ remove_entry(h, e);
+
+ return value;
+}
+
+void *hashmap_iterate(Hashmap *h, Iterator *i, const void **key) {
struct hashmap_entry *e;
- assert(state);
+ assert(i);
if (!h)
goto at_end;
- if (*state == (void*) -1)
+ if (*i == ITERATOR_LAST)
goto at_end;
- if (!*state && !h->iterate_list_head)
+ if (*i == ITERATOR_FIRST && !h->iterate_list_head)
goto at_end;
- e = *state ? *state : h->iterate_list_head;
+ e = *i == ITERATOR_FIRST ? h->iterate_list_head : (struct hashmap_entry*) *i;
if (e->iterate_next)
- *state = e->iterate_next;
+ *i = (Iterator) e->iterate_next;
else
- *state = (void*) -1;
+ *i = ITERATOR_LAST;
if (key)
*key = e->key;
return e->value;
at_end:
- *state = (void *) -1;
+ *i = ITERATOR_LAST;
if (key)
*key = NULL;
return NULL;
}
-void *hashmap_iterate_backwards(Hashmap *h, void **state, const void **key) {
+void *hashmap_iterate_backwards(Hashmap *h, Iterator *i, const void **key) {
struct hashmap_entry *e;
- assert(state);
+ assert(i);
if (!h)
goto at_beginning;
- if (*state == (void*) -1)
+ if (*i == ITERATOR_FIRST)
goto at_beginning;
- if (!*state && !h->iterate_list_tail)
+ if (*i == ITERATOR_LAST && !h->iterate_list_tail)
goto at_beginning;
- e = *state ? *state : h->iterate_list_tail;
+ e = *i == ITERATOR_LAST ? h->iterate_list_tail : (struct hashmap_entry*) *i;
if (e->iterate_previous)
- *state = e->iterate_previous;
+ *i = (Iterator) e->iterate_previous;
else
- *state = (void*) -1;
+ *i = ITERATOR_FIRST;
if (key)
*key = e->key;
return e->value;
at_beginning:
- *state = (void *) -1;
+ *i = ITERATOR_FIRST;
if (key)
*key = NULL;
return NULL;
}
+void *hashmap_iterate_skip(Hashmap *h, const void *key, Iterator *i) {
+ unsigned hash;
+ struct hashmap_entry *e;
+
+ if (!h)
+ return NULL;
+
+ hash = h->hash_func(key) % NBUCKETS;
+
+ if (!(e = hash_scan(h, hash, key)))
+ return NULL;
+
+ *i = (Iterator) e;
+
+ return e->value;
+}
+
void* hashmap_first(Hashmap *h) {
if (!h)
return h->n_entries == 0;
}
+
+int hashmap_merge(Hashmap *h, Hashmap *other) {
+ struct hashmap_entry *e;
+
+ assert(h);
+
+ if (!other)
+ return 0;
+
+ for (e = other->iterate_list_head; e; e = e->iterate_next) {
+ int r;
+
+ if ((r = hashmap_put(h, e->key, e->value)) < 0)
+ if (r != -EEXIST)
+ return r;
+ }
+
+ return 0;
+}
+
+Hashmap *hashmap_copy(Hashmap *h) {
+ Hashmap *copy;
+
+ assert(h);
+
+ if (!(copy = hashmap_new(h->hash_func, h->compare_func)))
+ return NULL;
+
+ if (hashmap_merge(copy, h) < 0) {
+ hashmap_free(copy);
+ return NULL;
+ }
+
+ return copy;
+}