Create an implementation of a generic map (#13)

include/lib/list.h

@@ -11,27 +11,27 @@ struct list {
 };
 
 /** Initializes a new list */
-void list_init(struct list *l);
+void list_init(struct list* l);
 
 /** Frees the list from memory */
-void list_free(struct list *l);
+void list_free(struct list* l);
 
 /** Adds the given element to the list */
-void list_add(struct list *l, void *elm);
+void list_add(struct list* l, void* elm);
 
 /** Removes the given element from the list */
-void list_remove(struct list *l, void *elm);
+void list_remove(struct list* l, void* elm);
 
 /** Removes all elements from the list */
-void list_clear(struct list *l);
+void list_clear(struct list* l);
 
 /** Returns true if the element is in the list, false otherwise */
-bool list_contains(struct list *l, void *elm);
+bool list_contains(struct list* l, void* elm);
 
 /** Returns the number of elements in the list */
-size_t list_size(struct list *l);
+size_t list_size(struct list* l);
 
 /** Places the first size number of elements of the list into the given array */
-void list_to_array(struct list *l, void **buffer, size_t size);
+void list_to_array(struct list* l, void** buffer, size_t size);
 
-#endif //_LIST_H_
+#endif //_LIST_H_

include/lib/map.h

@@ -4,24 +4,27 @@
 
 #include "stdlib/stdtypes.h"
 
-/** Data structure for a generic map */
 struct map {
-    //TODO
+    /** Table which holds all entries. */
+    struct entry *table;
+    /** Amount of space used. */
+    size_t used;
+    /** Maximum space to allocate for entries */
+    size_t size;
 };
 
-/** Initializes a new hashtable */
+/** Initializes a new hashmap. Returns `-1` if not allocated. */
 void map_init(struct map *m);
-
-/** Frees the hashtable from memory */
+/** Resizes the hashmap. */
+void map_resize(struct map *m, double resize_factor);
+/** Frees the hashtable from memory. */
 void map_free(struct map *m);
 
-/** Adds the key/value pair to the hashtable */
-void map_put(struct map *m, void *key, void *value);
-
-/** Gets the value associated with the specified key */
-void *map_get(struct map *m, void *key);
-
-/** Returns true if the hashtable contains the key, false otherwise */
-bool map_contains(struct map *m, void *key);
+/** Adds the key/value pair to the hashtable. */
+void map_put(struct map *m, void *key, void *value, size_t size);
+/** Gets the value associated with the specified key. */
+void *map_get(struct map *m, void *key, size_t size);
+/** Checks if key exists in hashmap. */
+bool map_contains(struct map *m, void *key, size_t size);
 
-#endif //_MAP_H_
+#endif //_MAP_H_

include/stdlib/stdhash.h

@@ -0,0 +1,4 @@
+#include <stdlib/stdtypes.h>
+
+/** FNV-1A hash for generic map. */
+size_t fnv_1a(char *str, size_t size);

include/stdlib/stdtypes.h

@@ -8,6 +8,9 @@
 #ifndef USER
 /** Size type */
 typedef unsigned int size_t;
+/** Unsigned 64 bit integer */
+typedef unsigned long long uint64_t;
+/** nullptr */
 #define NULL (void *) 0
 #else
 #include <stddef.h>

src/lib/list.c

@@ -86,4 +86,4 @@ void list_to_array(struct list *l, void **buffer, size_t size) {
         buffer[i++] = n->data;
         n = n->next;
     }
-}
+}

src/lib/map.c

@@ -1,2 +1,63 @@
 #include "lib/map.h"
+#include "stdlib/stdhash.h"
+#include "stdlib/stdalloc.h"
 
+/** Structures for a generic map. */
+struct entry {
+    /** The key associated with the entry. */
+    void *key;
+    /** The value associated with the entry. */
+    void *value;
+};
+
+void map_init(struct map *m) {
+	/** Default 1MB of data. */
+	size_t size = 1024 * 1024;
+
+	m->table = calloc(size, sizeof(struct entry));
+	m->used = 0;
+	m->size = size;
+}
+
+void map_resize(struct map *m, double resize_factor) {
+	m->size *= resize_factor;
+	m->table = realloc(m->table, m->size * sizeof(struct entry));
+}
+
+void map_free(struct map *m) {
+	free(m->table);
+}
+
+void map_put(struct map *m, void *key, void *value, size_t size) {
+	if (m->used * 2 >= m->size) {
+		map_resize(m, 2);
+	}
+
+	size_t idx = fnv_1a(key, size) % m->size;
+	size_t start = idx;
+
+	while (m->table[idx].key != NULL) {
+		idx = (++idx) % m->size;
+		if (memcmp(key, m->table[idx].key, size) == 0) break;
+	}
+
+	m->table[idx].key = key;
+	m->table[idx].value = value;
+	m->used++;
+}
+
+void *map_get(struct map *m, void *key, size_t size) {
+	size_t idx = fnv_1a(key, size) % m->size;
+
+	if (m->table[idx].key == NULL) return NULL;
+	while (m->table[idx].key != NULL) {
+		if (memcmp(key, m->table[idx].key, size) == 0) return m->table[idx].value;
+		idx = (++idx) % m->size;
+	}
+
+	return NULL;
+}
+
+bool map_contains(struct map *m, void *k, size_t size) {
+	return map_get(m, k, size) != NULL;
+}

src/stdlib/stdalloc.c

@@ -1,4 +1,5 @@
 #include "stdlib/stdalloc.h"
+#include "stdlib/stdstr.h"
 
 #include "alloc/heapalloc.h"
 #include "alloc/pagealloc.h"
@@ -13,6 +14,15 @@ void *malloc(size_t size) {
     return heap_malloc(current_heap, size);
 }
 
+void *calloc(size_t _NumOfElements, size_t _SizeOfElements) { 
+    void* buffer = malloc(_NumOfElements * _SizeOfElements);
+
+    if (buffer == NULL) return NULL;
+
+    memset(buffer, 0, _NumOfElements * _SizeOfElements);
+    return buffer;
+}
+
 void *realloc(void *p, size_t size) {
     return heap_realloc(current_heap, p, size);
 }

src/stdlib/stdhash.c

@@ -0,0 +1,12 @@
+#include <stdlib/stdtypes.h>
+
+size_t fnv_1a(char *ptr, size_t size) {
+    size_t hash = 0x811C9DC5;
+
+    for (;size--;) {
+        hash ^= ptr[size];
+        hash *= 0x01000193;
+    }
+
+    return hash;
+}