turning hashset into hashmap

1 files changed, 63 insertions, 21 deletions

diff --git a/src/hashm.h b/src/hashm.h
index 67bb3e0..fb83391 100644
--- a/src/hashm.h
+++ b/src/hashm.h
@@ -8,40 +8,82 @@
 #define WAYC_HASHMAP_SEED 0
 #define WAYC_HASHMAP_CAP 16
 
-template <typename T> struct hashmap_s {
-  struct hashmap *inner;
+template <typename K, typename V> struct hashentry_s {
+  K key;
+  V value;
 };
 
-template <typename T>
-static inline i32 wayc_hashmap_hash(const void *item, uint64_t seed0,
-                                    uint64_t seed1) {
+template <typename K, typename V>
+inline i32 wayc_hashentry_hash(const void *item, uint64_t seed0,
+                               uint64_t seed1) {
   wayc_notnull(item);
-  return hashmap_xxhash3(item, sizeof(T), seed0, seed1);
+
+  const hashentry_s<K, V> *entry = (const hashentry_s<K, V> *)item;
+  return hashmap_murmur(&entry->key, sizeof(K), seed0, seed1);
 }
 
-template <typename T>
-static inline bool wayc_hashmap_compare(const void *a, const void *b,
-                                        void *udata) {
+template <typename K, typename V>
+inline bool wayc_hashentry_compare(const void *a, const void *b, void *udata) {
   (void)udata;
 
   wayc_notnull(a);
   wayc_notnull(b);
-  return memcmp(a, b, sizeof(T)) == 0;
+
+  const hashentry_s<K, V> *entry_a = (const hashentry_s<K, V> *)a;
+  const hashentry_s<K, V> *entry_b = (const hashentry_s<K, V> *)b;
+  return memcmp(&entry_a->key, &entry_b->key, sizeof(K)) == 0;
 }
 
-template <typename T> inline hashmap_s<T> wayc_hashmap_init(void) {
-  struct hashmap *map = hashmap_new_with_allocator(
-      mi_malloc, mi_realloc, mi_free, sizeof(T), WAYC_HASHMAP_CAP,
-      WAYC_HASHMAP_SEED, WAYC_HASHMAP_SEED, wayc_hashmap_hash<T>,
-      wayc_hashmap_compare<T>, nullptr, nullptr);
+template <typename K, typename V> struct hashmap_s {
+  struct hashmap *inner;
+};
 
-  hashmap_s<T> result;
-  result.inner = map;
+template <typename K, typename V>
+inline void wayc_hashmap_init(hashmap_s<K, V> *map) {
+  wayc_notnull(map);
+  memset(map, 0, sizeof(*map));
 
-  return result;
+  struct hashmap *inner;
+  inner = hashmap_new_with_allocator(
+      mi_malloc, mi_realloc, mi_free, sizeof(hashentry_s<K, V>),
+      WAYC_HASHMAP_CAP, WAYC_HASHMAP_SEED, WAYC_HASHMAP_SEED,
+      wayc_hashentry_hash<K, V>, wayc_hashentry_compare<K, V>, nullptr,
+      nullptr);
+
+  wayc_notnull(inner);
+
+  map->inner = inner;
 }
 
-template <typename T> inline void wayc_hashmap_deinit(hashmap_s<T> *map) {
+template <typename K, typename V>
+inline void wayc_hashmap_deinit(hashmap_s<K, V> *map) {
+  wayc_notnull(map);
   hashmap_free(map->inner);
-  map->inner = nullptr;
-}
\ No newline at end of file
+}
+
+template <typename K, typename V>
+inline V *wayc_hashmap_insert(hashmap_s<K, V> *map, const K *key) {
+  wayc_notnull(map);
+  wayc_notnull(key);
+
+  hashentry_s<K, V> entry{};
+  entry.key = *key;
+  auto *stored = (hashentry_s<K, V> *)hashmap_set(map->inner, &entry);
+
+  wayc_notnull(stored);
+  return &stored->value;
+}
+
+template <typename K, typename V>
+inline V *wayc_hashmap_get(hashmap_s<K, V> *map, const K *key) {
+  wayc_notnull(map);
+  wayc_notnull(key);
+
+  hashentry_s<K, V> entry{};
+  entry.key = *key;
+  auto *stored = (hashentry_s<K, V> *)hashmap_get(map->inner, &entry);
+  if (!stored)
+    return nullptr;
+
+  return &stored->value;
+}