From: Michael Rasmussen <mir@datanom.net>
Date: Fri, 31 Mar 2023 21:20:22 +0000 (+0200)
Subject: Add more functions
X-Git-Url: http://git.datanom.net/hashtable.git/commitdiff_plain/dd3da95ad9e2d06f5f39d6efea6aad33ae5daf55

Add more functions
---

diff --git a/hashtable.c b/hashtable.c
index aa30132..b642363 100644
--- a/hashtable.c
+++ b/hashtable.c
@@ -101,7 +101,7 @@ bool hash_table_insert(Hashtable* ht, const void* key, void* obj) {
 
 void* hash_table_lookup(Hashtable* ht, const void* key) {
 	if (key == NULL || ht == NULL) return false;
-	uint64_t index = hash_table_index(ht, key);
+	uint32_t index = hash_table_index(ht, key);
 
 	Node* node = ht->nodes[index];
 	while (node != NULL && ht->compare(node->data, key) == false) {
@@ -109,7 +109,7 @@ void* hash_table_lookup(Hashtable* ht, const void* key) {
 	}
 
 	if (node == NULL) return NULL;
-	printf("find: %p -> found: %p\n", key, node->data);
+	//printf("find: %p -> found: %p\n", key, node->data);
 
 	return node->data;
 }
@@ -250,6 +250,53 @@ bool hash_table_iter_next(HashtableIter* iter, void** key, void** value) {
 	return false;
 }
 
+bool hash_table_contains(Hashtable* ht, const void* key) {
+	if (ht == NULL || key == NULL) return false;
+
+	if (hash_table_lookup(ht, key) == NULL)
+		return false;
+	return true;
+}
+
+uint64_t hash_table_size(Hashtable *ht) {
+	uint64_t size = 0;
+
+	if (ht == NULL) return size;
+
+	for (uint32_t i = 0; i < ht->size; i++) {
+		if (ht->nodes[i] != NULL) {
+			Node* node = ht->nodes[i];
+			while (node != NULL) {
+				size++;
+				node = node->next;
+			}
+		}
+	}
+
+	return size;
+}
+
+bool hash_table_replace(Hashtable *ht, void* key, void* value) {
+	if (ht == NULL || key == NULL || value == NULL) return false;
+
+	uint32_t index = hash_table_index(ht, key);
+
+	Node* node = ht->nodes[index];
+	while (node != NULL && ht->compare(node->data, key) == false) {
+		node = node->next;
+	}
+
+	if (node == NULL)
+		return hash_table_insert(ht, key, value);
+	else {
+		free(node->data);
+		node->key = key;
+		node->data = value;
+	}
+
+	return true;
+}
+
 uint64_t int_hash(const void* key) {
 	return *(uint64_t*) key;
 }
diff --git a/hashtable.h b/hashtable.h
index 23c8838..b0b08f5 100644
--- a/hashtable.h
+++ b/hashtable.h
@@ -49,6 +49,9 @@ void hash_table_list_free(List* list);
 void hash_table_foreach(Hashtable* ht, ForeachFunc, void* userdata);
 void hash_table_iter_init(HashtableIter* iter, Hashtable* ht);
 bool hash_table_iter_next(HashtableIter* iter, void** key, void** value);
+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);
 
 #endif
 
diff --git a/test.c b/test.c
index 8cf65c4..49a33a9 100644
--- a/test.c
+++ b/test.c
@@ -190,16 +190,30 @@ int main(int argc, char** argv) {
 	printf("%u out of %u inserted words in table were in the table\n", good_guesses, numwords);
 
 	HashtableIter iter;
-	void* key/* = malloc(sizeof(void*))*/;
-	void* value/* = malloc(sizeof(void*))*/;
+	void* key;
+	void* value;
 
 	hash_table_iter_init(&iter, table);
 	while (hash_table_iter_next(&iter, &key, &value)) {
 		char* s1 = ((Node*) value)->name;
 		printf("Key: %p value: %s\n", key, s1);
 	}
-	//free(key);
-	//free(value);
+
+	Node* node1 = calloc(sizeof(Node*), 1);
+	node1->name = strdup("Dummy Test Name");
+	if (hash_table_insert(table, node1, node1) == true) {
+		hash_table_iter_init(&iter, table);
+		printf("Hashtable size: %lu. Key found: %d\n", hash_table_size(table), hash_table_contains(table, node1));
+		void* data = hash_table_delete(table, node1);
+		printf("Deleted: [%p] %s\n", node1, ((Node*) data)->name);
+		free(((Node*) data)->name);
+		free(data);
+		printf("Hashtable size: %lu. Key found: %d\n", hash_table_size(table), hash_table_contains(table, node1));
+		Node* node2 = calloc(sizeof(Node*), 1);
+		node2->name = strdup("Test Name");
+		hash_table_replace(table, node2, node2);
+		printf("Hashtable size: %lu. Key found: %d\n", hash_table_size(table), hash_table_contains(table, node2));
+	}
 
 	hash_table_destroy(table);
 }