Add a couple of macros for ergonomic set/map creation

1 files changed, 136 insertions, 85 deletions

diff --git a/src/badlib.h b/src/badlib.h
index 674045a..ada309a 100644
--- a/src/badlib.h
+++ b/src/badlib.h
@@ -816,97 +816,148 @@ queue_pop(Queue *l) {
 // Map.
 //
 
-typedef u64(HashFunc)(void *in);
-typedef bool(EqFunc)(void *a, void *b);
-
-typedef struct MapNode {
-    struct MapNode *child[4];
-    void *key;
-    void *val;
-} MapNode;
-
-typedef struct Map {
-    HashFunc *hash_func;
-    EqFunc *eq_func;
-    MapNode *root;
-    Arena *storage;
-} Map;
-
-MapNode *
-map_upsert(Map *m, void *key, Arena *a) {
-    u64 h = m->hash_func(key);
-    MapNode **item = &m->root;
-    while (*item) {
-        if (m->eq_func(key, (*item)->key)) {
-            return *item;
-        }
-        h = (h << 2) | (h >> 62);
-        item = &(*item)->child[h & 0x3];
+// Specialiced commonly used hash sets/maps as macro definitions. There is no
+// delete on these ones but are trivial to implement!
+#define SETDEF(STRUCTNAME, FUNCNAME, KEYTYPE, HASHFUNC, EQFUNC) \
+    typedef struct STRUCTNAME { \
+        struct STRUCTNAME *child[4]; \
+        KEYTYPE key; \
+    } STRUCTNAME; \
+    STRUCTNAME *\
+    FUNCNAME##_lookup(STRUCTNAME **m, KEYTYPE key) {\
+        u64 h = HASHFUNC(key);\
+        while (*m) {\
+            if (EQFUNC(key, (*m)->key)) {\
+                return *m;\
+            }\
+            h = (h << 2) | (h >> 62);\
+            m = &(*m)->child[h & 0x3];\
+        }\
+        return NULL;\
+    }\
+    STRUCTNAME *\
+    FUNCNAME##_insert(STRUCTNAME **m, KEYTYPE key, Arena *a) {\
+        u64 h = HASHFUNC(key);\
+        while (*m) {\
+            if (EQFUNC(key, (*m)->key)) {\
+                return *m;\
+            }\
+            h = (h << 2) | (h >> 62);\
+            m = &(*m)->child[h & 0x3];\
+        }\
+        *m = arena_calloc(sizeof(STRUCTNAME), a);\
+        (*m)->key = key;\
+        return *m;\
+    }\
+    typedef Queue STRUCTNAME##Iter;\
+    STRUCTNAME##Iter\
+    FUNCNAME##_iterator(STRUCTNAME *map, Arena *a) {\
+        STRUCTNAME##Iter it = {0};\
+        queue_push(&it, map, a);\
+        return it;\
+    }\
+    STRUCTNAME *\
+    FUNCNAME##_next(STRUCTNAME##Iter *it, Arena *a) {\
+        assert(it);\
+        assert(a);\
+        while (it->head) {\
+            STRUCTNAME *item = (STRUCTNAME *)queue_pop(it);\
+            for (sz i = 0; i < 4; i++) {\
+                STRUCTNAME *child = item->child[i];\
+                if (child) {\
+                    queue_push(it, child, a);\
+                }\
+            }\
+            return item;\
+        }\
+        return NULL;\
     }
-    *item = arena_calloc(sizeof(MapNode), a);
-    (*item)->key = key;
-    return *item;
-}
 
-void
-map_insert(Map *m, void *key, void *val, Arena *a) {
-    u64 h = m->hash_func(key);
-    MapNode **item = &m->root;
-    while (*item) {
-        if (m->eq_func(key, (*item)->key)) {
-            (*item)->val = val;
-            return;
-        }
-        h = (h << 2) | (h >> 62);
-        item = &(*item)->child[h & 0x3];
-    }
-    *item = arena_calloc(sizeof(MapNode), a);
-    (*item)->key = key;
-    (*item)->val = val;
-}
-
-MapNode *
-map_lookup(Map *m, void *key) {
-    u64 h = m->hash_func(key);
-    MapNode **item = &m->root;
-    while (*item) {
-        if (m->eq_func(key, (*item)->key)) {
-            return *item;
-        }
-        h = (h << 2) | (h >> 62);
-        item = &(*item)->child[h & 0x3];
+#define MAPDEF(STRUCTNAME, FUNCNAME, KEYTYPE, VALTYPE, HASHFUNC, EQFUNC) \
+    typedef struct STRUCTNAME { \
+        struct STRUCTNAME *child[4]; \
+        KEYTYPE key; \
+        VALTYPE val; \
+    } STRUCTNAME;\
+    STRUCTNAME *\
+    FUNCNAME##_insert(STRUCTNAME **m, KEYTYPE key, VALTYPE val, Arena *a) {\
+        u64 h = HASHFUNC(key);\
+        while (*m) {\
+            if (EQFUNC(key, (*m)->key)) {\
+                (*m)->val = val;\
+                return *m;\
+            }\
+            h = (h << 2) | (h >> 62);\
+            m = &(*m)->child[h & 0x3];\
+        }\
+        *m = arena_calloc(sizeof(STRUCTNAME), a);\
+        (*m)->key = key;\
+        (*m)->val = val;\
+        return *m;\
+    }\
+    STRUCTNAME *\
+    FUNCNAME##_lookup(STRUCTNAME **m, KEYTYPE key) {\
+        u64 h = HASHFUNC(key);\
+        while (*m) {\
+            if (EQFUNC(key, (*m)->key)) {\
+                return *m;\
+            }\
+            h = (h << 2) | (h >> 62);\
+            m = &(*m)->child[h & 0x3];\
+        }\
+        return NULL;\
+    }\
+    typedef Queue STRUCTNAME##Iter;\
+    STRUCTNAME##Iter\
+    FUNCNAME##_iterator(STRUCTNAME *map, Arena *a) {\
+        STRUCTNAME##Iter it = {0};\
+        queue_push(&it, map, a);\
+        return it;\
+    }\
+    STRUCTNAME *\
+    FUNCNAME##_next(STRUCTNAME##Iter *it, Arena *a) {\
+        assert(it);\
+        assert(a);\
+        while (it->head) {\
+            STRUCTNAME *item = (STRUCTNAME *)queue_pop(it);\
+            for (sz i = 0; i < 4; i++) {\
+                STRUCTNAME *child = item->child[i];\
+                if (child) {\
+                    queue_push(it, child, a);\
+                }\
+            }\
+            return item;\
+        }\
+        return NULL;\
     }
-    return NULL;
-}
-
-typedef struct MapIter {
-    Queue queue;
-} MapIter;
-
-MapIter
-map_iterator(Map map, Arena *a) {
-    MapIter it = {0};
-    queue_push(&it.queue, map.root, a);
-    return it;
-}
-
-MapNode *
-map_next(MapIter *it, Arena *a) {
-    assert(it);
-    assert(a);
-    while (it->queue.head) {
-        MapNode *item = (MapNode *)queue_pop(&it->queue);
-        for (sz i = 0; i < 4; i++) {
-            MapNode *child = item->child[i];
-            if (child) {
-                queue_push(&it->queue, child, a);
-            }
-        }
-        return item;
+
+u64
+str_hash(Str s) {
+    u64 h = 0x100;
+    for (sz i = 0; i < s.size; i++) {
+        h ^= s.mem[i];
+        h *= 1111111111111111111u;
     }
-    return NULL;
+    return h;
+}
+
+bool
+_int_eq(sz a, sz b) {
+    return a == b;
 }
 
+bool
+_int_hash(sz a) {
+    return a * UINT64_C(11400714819323198485);
+}
+
+
+// Commonly used map/set types.
+SETDEF(StrSet, strset, Str, str_hash, str_eq)
+MAPDEF(StrIntMap, strintmap, Str, sz, str_hash, str_eq)
+SETDEF(IntSet, intset, sz, _int_hash, _int_eq)
+MAPDEF(IntStrMap, intstrmap, sz, Str, _int_hash, _int_eq)
+
 //
 // Dynamic arrays.
 //