Changeset b0f00a9 in mainline for uspace/lib/c/generic/adt/hash_table.c

Timestamp:

2011-11-06T22:21:05Z (15 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/fix-logger-deadlock, topic/msim-upgrade, topic/simplify-dev-export

Children:

898e847

Parents:

2bdf8313 (diff), 7b5f4c9 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge mainline changes.

File:

• uspace/lib/c/generic/adt/hash_table.c (modified) (9 diffs)

uspace/lib/c/generic/adt/hash_table.c

@@ -54 +54 @@
  *
  */
-int hash_table_create(hash_table_t *h, hash_count_t m, hash_count_t max_keys,
+bool hash_table_create(hash_table_t *h, hash_count_t m, hash_count_t max_keys,
     hash_table_operations_t *op)
 {
@@ -61 +61 @@
         assert(max_keys > 0);
         
-        h->entry = malloc(m * sizeof(link_t));
+        h->entry = malloc(m * sizeof(list_t));
         if (!h->entry)
                 return false;
         
-        memset((void *) h->entry, 0,  m * sizeof(link_t));
+        memset((void *) h->entry, 0,  m * sizeof(list_t));
         
         hash_count_t i;
@@ -78 +78 @@
 }
 
+/** Remove all elements from the hash table
+ *
+ * @param h Hash table to be cleared
+ */
+void hash_table_clear(hash_table_t *h)
+{
+        for (hash_count_t chain = 0; chain < h->entries; ++chain) {
+                link_t *cur;
+                link_t *next;
+                
+                for (cur = h->entry[chain].head.next;
+                    cur != &h->entry[chain].head;
+                    cur = next) {
+                        next = cur->next;
+                        list_remove(cur);
+                        h->op->remove_callback(cur);
+                }
+        }
+}
+
 /** Destroy a hash table instance.
  *
@@ -123 +143 @@
         assert(chain < h->entries);
         
-        link_t *cur;
-        for (cur = h->entry[chain].next; cur != &h->entry[chain];
-            cur = cur->next) {
+        list_foreach(h->entry[chain], cur) {
                 if (h->op->compare(key, h->max_keys, cur)) {
                         /*
@@ -152 +170 @@
             h->op->remove_callback);
         assert(keys <= h->max_keys);
-        
-        link_t *cur;
         
         if (keys == h->max_keys) {
@@ -161 +177 @@
                  */
                 
-                cur = hash_table_find(h, key);
+                link_t *cur = hash_table_find(h, key);
                 if (cur) {
                         list_remove(cur);
@@ -176 +192 @@
         hash_index_t chain;
         for (chain = 0; chain < h->entries; chain++) {
-                for (cur = h->entry[chain].next; cur != &h->entry[chain];
+                for (link_t *cur = h->entry[chain].head.next;
+                    cur != &h->entry[chain].head;
                     cur = cur->next) {
                         if (h->op->compare(key, keys, cur)) {
@@ -193 +210 @@
 }
 
-/** Apply fucntion to all items in hash table.
+/** Apply function to all items in hash table.
  *
  * @param h   Hash table.
@@ -201 +218 @@
  */
 void hash_table_apply(hash_table_t *h, void (*f)(link_t *, void *), void *arg)
-{
-        hash_index_t bucket;
-        link_t *cur;
-        
-        for (bucket = 0; bucket < h->entries; bucket++) {
-                for (cur = h->entry[bucket].next; cur != &h->entry[bucket];
-                    cur = cur->next) {
+{       
+        for (hash_index_t bucket = 0; bucket < h->entries; bucket++) {
+                link_t *cur;
+                link_t *next;
+
+                for (cur = h->entry[bucket].head.next; cur != &h->entry[bucket].head;
+                    cur = next) {
+                        /*
+                         * The next pointer must be stored prior to the functor
+                         * call to allow using destructor as the functor (the
+                         * free function could overwrite the cur->next pointer).
+                         */
+                        next = cur->next;
                         f(cur, arg);
                 }