HashFunc hash;
EqualFunc compare;
FreeFunc free;
+ PrintFunc print;
Node** nodes;
};
return (ht->hash(key) % ht->size);
}
+static void hash_table_default_print(void* data) {
+ printf("%p", data);
+}
+
Hashtable* hash_table_create(HashFunc hf, EqualFunc ef) {
- return hash_table_create_full(hf, ef, TABLESIZE, NULL);
+ return hash_table_create_full(hf, ef, TABLESIZE, NULL, NULL);
}
Hashtable* hash_table_create_notify(HashFunc hf, EqualFunc ef, FreeFunc ff) {
- return hash_table_create_full(hf, ef, TABLESIZE, ff);
+ return hash_table_create_full(hf, ef, TABLESIZE, ff, NULL);
}
-Hashtable* hash_table_create_full(HashFunc hf, EqualFunc ef, uint32_t size, FreeFunc ff) {
+Hashtable* hash_table_create_full(HashFunc hf, EqualFunc ef, uint32_t size, FreeFunc ff, PrintFunc pf) {
Hashtable* ht = malloc(sizeof(*ht));
ht->size = size;
ht->hash = hf;
} else {
ht->free = free;
}
+ if (pf) {
+ ht->print = pf;
+ } else {
+ ht->print = hash_table_default_print;
+ }
ht->nodes = calloc(sizeof(Node*), ht->size);
return ht;
}
free(ht);
}
+void hash_table_set_print_func(Hashtable* ht, PrintFunc pf) {
+ ht->print = pf;
+}
+
void hash_table_print(Hashtable* ht) {
printf("Start Table\n");
for (uint32_t i = 0; i < ht->size; i++) {
printf("\t%i\t\n", i);
Node* node = ht->nodes[i];
while (node != NULL) {
- printf("\"%p\" - (%p)", node->key, node->data);
+ printf("\"%p\" - (", node->key);
+ ht->print(node->data);
+ printf(")");
node = node->next;
}
printf("\n");
typedef uint64_t (*HashFunc)(const void*);
typedef bool (*EqualFunc)(const void*, const void*);
typedef void (*FreeFunc)(void*);
+typedef void (*PrintFunc)(void*);
typedef struct _Hashtable Hashtable;
typedef void (*ForeachFunc)(void*, void*, void*);
Hashtable* hash_table_create(HashFunc hf, EqualFunc ef);
Hashtable* hash_table_create_notify(HashFunc hf, EqualFunc ef, FreeFunc ff);
-Hashtable* hash_table_create_full(HashFunc hf, EqualFunc ef, uint32_t size, FreeFunc ff);
+Hashtable* hash_table_create_full(HashFunc hf, EqualFunc ef, uint32_t size, FreeFunc ff, PrintFunc pf);
void hash_table_destroy(Hashtable* ht);
void hash_table_print(Hashtable* ht);
bool hash_table_insert(Hashtable* ht, const void* key, void* obj);
bool hash_table_contains(Hashtable* ht, const void* key);
uint64_t hash_table_size(Hashtable* ht);
bool hash_table_replace(Hashtable* ht, void* key, void* value);
+void hash_table_set_print_func(Hashtable* ht, PrintFunc pf);
#endif
free(node);
}
+void my_print(void* o) {
+ Node* n = (Node *) o;
+ printf("%s", n->name);
+}
+
bool my_ptr_equal(const void* a, const void* b) {
const Node* nodea = a;
const Node* nodeb = b;
fclose(fp);
printf("Loaded %d words into the table.\n", numwords);
+ hash_table_print(table);
+ hash_table_set_print_func(table, my_print);
+ hash_table_print(table);
/*
uint32_t good_guesses = 0;
}
hash_table_destroy(table);
+
+ table = hash_table_create(str_hash, str_equal);
+ char *names[] = { "Adam", "Eva", "Abraham", "Kain", "Abel", NULL };
+ for (int i = 0; names[i]; i++) {
+ void* name = names[i];
+ hash_table_insert(table, name, strdup(name));
+ }
+ hash_table_iter_init(&iter, table);
+ while (hash_table_iter_next(&iter, &key, &value)) {
+ printf("Key: %p value: %s\n", (char*)key, (char*)value);
+ }
+ data = hash_table_delete(table, (void*) names[4]);
+ printf("Deleted: [%p] %s\n", data, (char*) data);
+ free(data);
+ hash_table_replace(table, (void*) names[4], strdup(names[4]));
+ hash_table_replace(table, (void*) names[4], strdup("Johannes"));
+ hash_table_iter_init(&iter, table);
+ while (hash_table_iter_next(&iter, &key, &value)) {
+ printf("Key: %p value: %s\n", (char*)key, (char*)value);
+ }
+
+ hash_table_destroy(table);
}