Change delete API to return key and data.

Instead of passing delete function at initialization time, instead pass it as a parameter to clear and free functions (i.e. where used).

anagram.c

@@ -29,7 +29,7 @@ main(int argc, char *argv[])
 	exit(1);
     }
 
-    rb_tree *tree = rb_tree_new(dict_str_cmp, NULL);
+    rb_tree *tree = rb_tree_new(dict_str_cmp);
 
     char buf[512];
     while (fgets(buf, sizeof(buf), fp)) {
@@ -89,7 +89,7 @@ main(int argc, char *argv[])
 	}
     } while (rb_itor_next(itor));
     rb_itor_free(itor);
-    rb_tree_free(tree);
+    rb_tree_free(tree, NULL);
 
     return 0;
 }

benchmark.c

@@ -240,8 +240,11 @@ main(int argc, char **argv)
 
     timer_start(&start);
     for (unsigned i = 0; i < nwords; i++) {
-	if (!dict_remove(dct, words[i]))
+	dict_remove_result result = dict_remove(dct, words[i]);
+	if (!result.removed)
 	    quit("removing #%d '%s' failed!\n", i, words[i]);
+	ASSERT(result.key == words[i]);
+	ASSERT(result.datum == words[i]);
     }
     timer_end(&start, &end, &total);
     printf("       %s remove: %6.03fs %9zu cmp (%.2f/remove)",
@@ -265,7 +268,7 @@ main(int argc, char **argv)
     if ((n = dict_count(dct)) != 0)
 	quit("error - count not zero (%u)!", n);
 
-    dict_free(dct);
+    dict_free(dct, key_str_free);
 
     printf("        %s total: %6.03fs %9zu cmp",
 	   container_name,
@@ -293,39 +296,39 @@ create_dictionary(char type, const char **container_name)
     switch (type) {
 	case 'h':
 	    *container_name = "hb";
-	    return hb_dict_new(cmp_func, key_str_free);
+	    return hb_dict_new(cmp_func);
 
 	case 'p':
 	    *container_name = "pr";
-	    return pr_dict_new(cmp_func, key_str_free);
+	    return pr_dict_new(cmp_func);
 
 	case 'r':
 	    *container_name = "rb";
-	    return rb_dict_new(cmp_func, key_str_free);
+	    return rb_dict_new(cmp_func);
 
 	case 't':
 	    *container_name = "tr";
-	    return tr_dict_new(cmp_func, NULL, key_str_free);
+	    return tr_dict_new(cmp_func, NULL);
 
 	case 's':
 	    *container_name = "sp";
-	    return sp_dict_new(cmp_func, key_str_free);
+	    return sp_dict_new(cmp_func);
 
 	case 'S':
 	    *container_name = "sk";
-	    return skiplist_dict_new(cmp_func, key_str_free, 12);
+	    return skiplist_dict_new(cmp_func, 12);
 
 	case 'w':
 	    *container_name = "wb";
-	    return wb_dict_new(cmp_func, key_str_free);
+	    return wb_dict_new(cmp_func);
 
 	case 'H':
 	    *container_name = "ht";
-	    return hashtable_dict_new(cmp_func, hash_func, key_str_free, HASHTABLE_SIZE);
+	    return hashtable_dict_new(cmp_func, hash_func, HASHTABLE_SIZE);
 
 	case '2':
 	    *container_name = "h2";
-	    return hashtable2_dict_new(cmp_func, hash_func, key_str_free, HASHTABLE_SIZE);
+	    return hashtable2_dict_new(cmp_func, hash_func, HASHTABLE_SIZE);
 
 	default:
 	    quit("type must be one of h, p, r, t, s, w or H");

demo.c

@@ -51,35 +51,31 @@ main(int argc, char **argv)
     ++argv;
     switch (argv[0][0]) {
 	case 'h':
-	    dct = hb_dict_new((dict_compare_func)strcmp, key_val_free);
+	    dct = hb_dict_new((dict_compare_func)strcmp);
 	    break;
 	case 'p':
-	    dct = pr_dict_new((dict_compare_func)strcmp, key_val_free);
+	    dct = pr_dict_new((dict_compare_func)strcmp);
 	    break;
 	case 'r':
-	    dct = rb_dict_new((dict_compare_func)strcmp, key_val_free);
+	    dct = rb_dict_new((dict_compare_func)strcmp);
 	    break;
 	case 't':
-	    dct = tr_dict_new((dict_compare_func)strcmp, NULL, key_val_free);
+	    dct = tr_dict_new((dict_compare_func)strcmp, NULL);
 	    break;
 	case 's':
-	    dct = sp_dict_new((dict_compare_func)strcmp, key_val_free);
+	    dct = sp_dict_new((dict_compare_func)strcmp);
 	    break;
 	case 'w':
-	    dct = wb_dict_new((dict_compare_func)strcmp, key_val_free);
+	    dct = wb_dict_new((dict_compare_func)strcmp);
+	    break;
+	case 'S':
+	    dct = skiplist_dict_new((dict_compare_func)strcmp, SKIPLINKS);
 	    break;
-        case 'S':
-            dct = skiplist_dict_new((dict_compare_func)strcmp, key_val_free, SKIPLINKS);
-            break;
 	case 'H':
-	    dct = hashtable_dict_new((dict_compare_func)strcmp,
-				     dict_str_hash,
-				     key_val_free, HSIZE);
+	    dct = hashtable_dict_new((dict_compare_func)strcmp, dict_str_hash, HSIZE);
 	    break;
 	case '2':
-	    dct = hashtable2_dict_new((dict_compare_func)strcmp,
-				      dict_str_hash,
-				      key_val_free, HSIZE);
+	    dct = hashtable2_dict_new((dict_compare_func)strcmp, dict_str_hash, HSIZE);
 	    break;
 	default:
 	    quit("type must be one of h, p, r, t, s, w, S, H, or 2");
@@ -193,9 +189,12 @@ main(int argc, char **argv)
 		printf("usage: remove <key>\n");
 		continue;
 	    }
-	    if (dict_remove(dct, ptr))
-		printf("removed '%s' from dict\n", ptr);
-	    else
+	    dict_remove_result result = dict_remove(dct, ptr);
+	    if (result.removed) {
+		printf("removed '%s' from dict: %s\n", result.key, result.datum);
+		free(result.key);
+		free(result.datum);
+	    } else
 		printf("key '%s' not in dict!\n", ptr);
 	} else if (strcmp(buf, "show") == 0) {
 	    if (ptr) {
@@ -226,7 +225,7 @@ main(int argc, char **argv)
 		printf("usage: clear\n");
 		continue;
 	    }
-	    dict_clear(dct);
+	    dict_clear(dct, key_val_free);
 	} else if (strcmp(buf, "count") == 0) {
 	    if (ptr) {
 		printf("usage: count\n");
@@ -252,7 +251,7 @@ main(int argc, char **argv)
 	}
     }
 
-    dict_free(dct);
+    dict_free(dct, key_val_free);
 
     exit(0);
 }

include/dict.h

@@ -75,13 +75,20 @@ typedef struct {
     bool    inserted;
 } dict_insert_result;
 
+typedef struct {
+    void*   key;
+    void*   datum;
+    bool    removed;
+} dict_remove_result;
+
 typedef dict_itor*  (*dict_inew_func)(void* obj);
-typedef size_t      (*dict_dfree_func)(void* obj);
+typedef size_t      (*dict_dfree_func)(void* obj, dict_delete_func delete_func);
 typedef dict_insert_result
                     (*dict_insert_func)(void* obj, void* key);
 typedef void**      (*dict_search_func)(void* obj, const void* key);
-typedef bool	    (*dict_remove_func)(void* obj, const void* key);
-typedef size_t      (*dict_clear_func)(void* obj);
+typedef dict_remove_result
+		    (*dict_remove_func)(void* obj, const void* key);
+typedef size_t      (*dict_clear_func)(void* obj, dict_delete_func delete_func);
 typedef size_t      (*dict_traverse_func)(void* obj, dict_visit_func visit);
 typedef size_t      (*dict_count_func)(const void* obj);
 typedef bool	    (*dict_verify_func)(const void* obj);
@@ -155,9 +162,9 @@ typedef struct {
 #define dict_traverse(dct,func)	    ((dct)->_vtable->traverse((dct)->_object, (func)))
 #define dict_count(dct)		    ((dct)->_vtable->count((dct)->_object))
 #define dict_verify(dct)	    ((dct)->_vtable->verify((dct)->_object))
-#define dict_clear(dct)		    ((dct)->_vtable->clear((dct)->_object))
+#define dict_clear(dct,func)	    ((dct)->_vtable->clear((dct)->_object, (func)))
 #define dict_itor_new(dct)	    (dct)->_vtable->inew((dct)->_object)
-size_t dict_free(dict* dct);
+size_t dict_free(dict* dct, dict_delete_func delete_func);
 
 struct dict_itor {
     void*	    _itor;

include/hashtable.h

@@ -34,19 +34,16 @@ BEGIN_DECL
 
 typedef struct hashtable hashtable;
 
-hashtable*	hashtable_new(dict_compare_func cmp_func,
-			      dict_hash_func hash_func,
-			      dict_delete_func del_func, unsigned size);
-dict*		hashtable_dict_new(dict_compare_func cmp_func,
-				   dict_hash_func hash_func,
-				   dict_delete_func del_func, unsigned size);
-size_t		hashtable_free(hashtable* table);
+hashtable*	hashtable_new(dict_compare_func cmp_func, dict_hash_func hash_func, unsigned size);
+dict*		hashtable_dict_new(dict_compare_func cmp_func, dict_hash_func hash_func, unsigned size);
+size_t		hashtable_free(hashtable* table, dict_delete_func delete_func);
 
 dict_insert_result
                 hashtable_insert(hashtable* table, void* key);
 void**		hashtable_search(hashtable* table, const void* key);
-bool		hashtable_remove(hashtable* table, const void* key);
-size_t		hashtable_clear(hashtable* table);
+dict_remove_result
+		hashtable_remove(hashtable* table, const void* key);
+size_t		hashtable_clear(hashtable* table, dict_delete_func delete_func);
 size_t		hashtable_traverse(hashtable* table, dict_visit_func visit);
 size_t		hashtable_count(const hashtable* table);
 size_t		hashtable_size(const hashtable* table);

include/hashtable2.h

@@ -34,19 +34,16 @@ BEGIN_DECL
 
 typedef struct hashtable2 hashtable2;
 
-hashtable2*	hashtable2_new(dict_compare_func cmp_func,
-			       dict_hash_func hash_func,
-			       dict_delete_func del_func, unsigned initial_size);
-dict*		hashtable2_dict_new(dict_compare_func cmp_func,
-				    dict_hash_func hash_func,
-				    dict_delete_func del_func, unsigned initial_size);
-size_t		hashtable2_free(hashtable2* table);
+hashtable2*	hashtable2_new(dict_compare_func cmp_func, dict_hash_func hash_func, unsigned initial_size);
+dict*		hashtable2_dict_new(dict_compare_func cmp_func, dict_hash_func hash_func, unsigned initial_size);
+size_t		hashtable2_free(hashtable2* table, dict_delete_func delete_func);
 
 dict_insert_result
                 hashtable2_insert(hashtable2* table, void* key);
 void**		hashtable2_search(hashtable2* table, const void* key);
-bool		hashtable2_remove(hashtable2* table, const void* key);
-size_t		hashtable2_clear(hashtable2* table);
+dict_remove_result
+		hashtable2_remove(hashtable2* table, const void* key);
+size_t		hashtable2_clear(hashtable2* table, dict_delete_func delete_func);
 size_t		hashtable2_traverse(hashtable2* table, dict_visit_func visit);
 size_t		hashtable2_count(const hashtable2* table);
 size_t		hashtable2_size(const hashtable2* table);

include/hb_tree.h

@@ -34,11 +34,9 @@ BEGIN_DECL
 
 typedef struct hb_tree hb_tree;
 
-hb_tree*	hb_tree_new(dict_compare_func cmp_func,
-			    dict_delete_func del_func);
-dict*		hb_dict_new(dict_compare_func cmp_func,
-			    dict_delete_func del_func);
-size_t		hb_tree_free(hb_tree* tree);
+hb_tree*	hb_tree_new(dict_compare_func cmp_func);
+dict*		hb_dict_new(dict_compare_func cmp_func);
+size_t		hb_tree_free(hb_tree* tree, dict_delete_func delete_func);
 
 dict_insert_result
                 hb_tree_insert(hb_tree* tree, void* key);
@@ -47,8 +45,9 @@ void**		hb_tree_search_le(hb_tree* tree, const void* key);
 void**		hb_tree_search_lt(hb_tree* tree, const void* key);
 void**		hb_tree_search_ge(hb_tree* tree, const void* key);
 void**		hb_tree_search_gt(hb_tree* tree, const void* key);
-bool		hb_tree_remove(hb_tree* tree, const void* key);
-size_t		hb_tree_clear(hb_tree* tree);
+dict_remove_result
+		hb_tree_remove(hb_tree* tree, const void* key);
+size_t		hb_tree_clear(hb_tree* tree, dict_delete_func delete_func);
 size_t		hb_tree_traverse(hb_tree* tree, dict_visit_func visit);
 size_t		hb_tree_count(const hb_tree* tree);
 size_t		hb_tree_height(const hb_tree* tree);

include/pr_tree.h

@@ -34,11 +34,9 @@ BEGIN_DECL
 
 typedef struct pr_tree pr_tree;
 
-pr_tree*	pr_tree_new(dict_compare_func cmp_func,
-			    dict_delete_func del_func);
-dict*		pr_dict_new(dict_compare_func cmp_func,
-			    dict_delete_func del_func);
-size_t		pr_tree_free(pr_tree* tree);
+pr_tree*	pr_tree_new(dict_compare_func cmp_func);
+dict*		pr_dict_new(dict_compare_func cmp_func);
+size_t		pr_tree_free(pr_tree* tree, dict_delete_func delete_func);
 
 dict_insert_result
                 pr_tree_insert(pr_tree* tree, void* key);
@@ -47,8 +45,9 @@ void**		pr_tree_search_le(pr_tree* tree, const void* key);
 void**		pr_tree_search_lt(pr_tree* tree, const void* key);
 void**		pr_tree_search_ge(pr_tree* tree, const void* key);
 void**		pr_tree_search_gt(pr_tree* tree, const void* key);
-bool		pr_tree_remove(pr_tree* tree, const void* key);
-size_t		pr_tree_clear(pr_tree* tree);
+dict_remove_result
+		pr_tree_remove(pr_tree* tree, const void* key);
+size_t		pr_tree_clear(pr_tree* tree, dict_delete_func delete_func);
 size_t		pr_tree_traverse(pr_tree* tree, dict_visit_func visit);
 size_t		pr_tree_count(const pr_tree* tree);
 size_t		pr_tree_height(const pr_tree* tree);

include/rb_tree.h

@@ -34,11 +34,9 @@ BEGIN_DECL
 
 typedef struct rb_tree rb_tree;
 
-rb_tree*	rb_tree_new(dict_compare_func cmp_func,
-			    dict_delete_func del_func);
-dict*		rb_dict_new(dict_compare_func cmp_func,
-			    dict_delete_func del_func);
-size_t		rb_tree_free(rb_tree* tree);
+rb_tree*	rb_tree_new(dict_compare_func cmp_func);
+dict*		rb_dict_new(dict_compare_func cmp_func);
+size_t		rb_tree_free(rb_tree* tree, dict_delete_func delete_func);
 
 dict_insert_result
                 rb_tree_insert(rb_tree* tree, void* key);
@@ -47,8 +45,9 @@ void**		rb_tree_search_le(rb_tree* tree, const void* key);
 void**		rb_tree_search_lt(rb_tree* tree, const void* key);
 void**		rb_tree_search_ge(rb_tree* tree, const void* key);
 void**		rb_tree_search_gt(rb_tree* tree, const void* key);
-bool		rb_tree_remove(rb_tree* tree, const void* key);
-size_t		rb_tree_clear(rb_tree* tree);
+dict_remove_result
+		rb_tree_remove(rb_tree* tree, const void* key);
+size_t		rb_tree_clear(rb_tree* tree, dict_delete_func delete_func);
 size_t		rb_tree_traverse(rb_tree* tree, dict_visit_func visit);
 size_t		rb_tree_count(const rb_tree* tree);
 size_t		rb_tree_height(const rb_tree* tree);

include/skiplist.h

@@ -34,13 +34,9 @@ BEGIN_DECL
 
 typedef struct skiplist skiplist;
 
-skiplist*	skiplist_new(dict_compare_func cmp_func,
-			     dict_delete_func del_func,
-			     unsigned max_link);
-dict*		skiplist_dict_new(dict_compare_func cmp_func,
-				  dict_delete_func del_func,
-				  unsigned max_link);
-size_t		skiplist_free(skiplist* list);
+skiplist*	skiplist_new(dict_compare_func cmp_func, unsigned max_link);
+dict*		skiplist_dict_new(dict_compare_func cmp_func, unsigned max_link);
+size_t		skiplist_free(skiplist* list, dict_delete_func delete_func);
 
 dict_insert_result
                 skiplist_insert(skiplist* list, void* key);
@@ -49,8 +45,9 @@ void**		skiplist_search_le(skiplist* tree, const void* key);
 void**		skiplist_search_lt(skiplist* tree, const void* key);
 void**		skiplist_search_ge(skiplist* tree, const void* key);
 void**		skiplist_search_gt(skiplist* tree, const void* key);
-bool		skiplist_remove(skiplist* list, const void* key);
-size_t		skiplist_clear(skiplist* list);
+dict_remove_result
+		skiplist_remove(skiplist* list, const void* key);
+size_t		skiplist_clear(skiplist* list, dict_delete_func delete_func);
 size_t		skiplist_traverse(skiplist* list, dict_visit_func visit);
 size_t		skiplist_count(const skiplist* list);
 bool		skiplist_verify(const skiplist* list);

include/sp_tree.h

@@ -34,11 +34,9 @@ BEGIN_DECL
 
 typedef struct sp_tree sp_tree;
 
-sp_tree*	sp_tree_new(dict_compare_func cmp_func,
-			    dict_delete_func del_func);
-dict*		sp_dict_new(dict_compare_func cmp_func,
-			    dict_delete_func del_func);
-size_t		sp_tree_free(sp_tree* tree);
+sp_tree*	sp_tree_new(dict_compare_func cmp_func);
+dict*		sp_dict_new(dict_compare_func cmp_func);
+size_t		sp_tree_free(sp_tree* tree, dict_delete_func delete_func);
 
 dict_insert_result
                 sp_tree_insert(sp_tree* tree, void* key);
@@ -47,8 +45,9 @@ void**		sp_tree_search_le(sp_tree* tree, const void* key);
 void**		sp_tree_search_lt(sp_tree* tree, const void* key);
 void**		sp_tree_search_ge(sp_tree* tree, const void* key);
 void**		sp_tree_search_gt(sp_tree* tree, const void* key);
-bool		sp_tree_remove(sp_tree* tree, const void* key);
-size_t		sp_tree_clear(sp_tree* tree);
+dict_remove_result
+		sp_tree_remove(sp_tree* tree, const void* key);
+size_t		sp_tree_clear(sp_tree* tree, dict_delete_func delete_func);
 size_t		sp_tree_traverse(sp_tree* tree, dict_visit_func visit);
 size_t		sp_tree_count(const sp_tree* tree);
 size_t		sp_tree_height(const sp_tree* tree);