use a vtable approach for generic map interface

[nbds] / map / map.c

diff --git a/map/map.c b/map/map.c
index a8a7068c6e88f3e208dc758b250a624d2f849447..cb761ef3cddfb7b28f2dd80c67157e8bdcfb1033 100644 (file)
--- a/map/map.c
+++ b/map/map.c
@@ -11,102 +11,50 @@
 #include "map.h"
 
 struct map {
-    map_type_e type;
-    void *impl;
+    const map_impl_t *impl;
+    void *data;
 };
 
-map_t *map_alloc (map_type_e map_type) {
-    void *impl = NULL;
-    switch (map_type) {
-        case MAP_TYPE_HASHTABLE: impl = ht_alloc(); break;
-        case MAP_TYPE_SKIPLIST:  impl = sl_alloc(); break;
-        case MAP_TYPE_LIST:      impl = ll_alloc(); break;
-    }
-    map_t *map = NULL;
-    if (impl) {
-        map = nbd_malloc(sizeof(map_t));
-        map->type = map_type;
-        map->impl = impl;
-    }
+map_t *map_alloc (map_type_t map_type) { 
+    const map_impl_t *map_impl = map_type;
+    map_t *map = nbd_malloc(sizeof(map_t)); 
+    map->impl  = map_impl;
+    map->data  = map->impl->alloc();
     return map;
 }
 
 void map_free (map_t *map) {
-    switch (map->type) {
-        case MAP_TYPE_HASHTABLE: ht_free(map->impl); break;
-        case MAP_TYPE_SKIPLIST:  sl_free(map->impl); break;
-        case MAP_TYPE_LIST:      ll_free(map->impl); break;
-    }
+    map->impl->free_(map->data);
 }
 
 void map_print (map_t *map) {
-    switch (map->type) {
-        case MAP_TYPE_HASHTABLE: ht_print(map->impl); break;
-        case MAP_TYPE_SKIPLIST:  sl_print(map->impl); break;
-        case MAP_TYPE_LIST:      ll_print(map->impl); break;
-    }
+    map->impl->print(map->data);
 }
 
-uint64_t map_stat (map_t *map, map_stat_e stat_type) {
-    switch (stat_type) {
-        case MAP_STAT_COUNT: 
-            if (map->type != MAP_TYPE_HASHTABLE)
-                return ERROR_UNSUPPORTED_FEATURE;
-            return ht_count(map->impl);
-    }
-    return ERROR_INVALID_OPTION;
+uint64_t map_count (map_t *map) {
+    return map->impl->count(map->data);
 }
 
 uint64_t map_get (map_t *map, const void *key_data, uint32_t key_len) {
-    switch (map->type) {
-        case MAP_TYPE_HASHTABLE: return ht_get(map->impl, key_data, key_len);
-        case MAP_TYPE_SKIPLIST:  return sl_lookup(map->impl, key_data, key_len);
-        case MAP_TYPE_LIST:      return ll_lookup(map->impl, key_data, key_len);
-    }
-    return ERROR_INVALID_ARGUMENT;
+    return map->impl->get(map->data, key_data, key_len);
 }
 
 uint64_t map_set (map_t *map, const void *key_data, uint32_t key_len, uint64_t new_val) {
-    switch (map->type) {
-        case MAP_TYPE_HASHTABLE: return ht_cas(map->impl, key_data, key_len, CAS_EXPECT_WHATEVER, new_val);
-        case MAP_TYPE_SKIPLIST:  return sl_cas(map->impl, key_data, key_len, CAS_EXPECT_WHATEVER, new_val);
-        case MAP_TYPE_LIST:      return ll_cas(map->impl, key_data, key_len, CAS_EXPECT_WHATEVER, new_val);
-    }
-    return ERROR_INVALID_ARGUMENT;
+    return map->impl->cas(map->data, key_data, key_len, CAS_EXPECT_WHATEVER, new_val);
 }
 
 uint64_t map_add (map_t *map, const void *key_data, uint32_t key_len, uint64_t new_val) {
-    switch (map->type) {
-        case MAP_TYPE_HASHTABLE: return ht_cas(map->impl, key_data, key_len, CAS_EXPECT_DOES_NOT_EXIST, new_val);
-        case MAP_TYPE_SKIPLIST:  return sl_cas(map->impl, key_data, key_len, CAS_EXPECT_DOES_NOT_EXIST, new_val);
-        case MAP_TYPE_LIST:      return ll_cas(map->impl, key_data, key_len, CAS_EXPECT_DOES_NOT_EXIST, new_val);
-    }
-    return ERROR_INVALID_ARGUMENT;
+    return map->impl->cas(map->data, key_data, key_len, CAS_EXPECT_DOES_NOT_EXIST, new_val);
 }
 
 uint64_t map_cas (map_t *map, const void *key_data, uint32_t key_len, uint64_t expected_val, uint64_t new_val) {
-    switch (map->type) {
-        case MAP_TYPE_HASHTABLE: return ht_cas(map->impl, key_data, key_len, expected_val, new_val);
-        case MAP_TYPE_SKIPLIST:  return sl_cas(map->impl, key_data, key_len, expected_val, new_val);
-        case MAP_TYPE_LIST:      return ll_cas(map->impl, key_data, key_len, expected_val, new_val);
-    }
-    return ERROR_INVALID_ARGUMENT;
+    return map->impl->cas(map->data, key_data, key_len, expected_val, new_val);
 }
 
 uint64_t map_replace(map_t *map, const void *key_data, uint32_t key_len, uint64_t new_val) {
-    switch (map->type) {
-        case MAP_TYPE_HASHTABLE: return ht_cas(map->impl, key_data, key_len, CAS_EXPECT_EXISTS, new_val);
-        case MAP_TYPE_SKIPLIST:  return sl_cas(map->impl, key_data, key_len, CAS_EXPECT_EXISTS, new_val);
-        case MAP_TYPE_LIST:      return ll_cas(map->impl, key_data, key_len, CAS_EXPECT_EXISTS, new_val);
-    }
-    return ERROR_INVALID_ARGUMENT;
+    return map->impl->cas(map->data, key_data, key_len, CAS_EXPECT_EXISTS, new_val);
 }
 
 uint64_t map_remove (map_t *map, const void *key_data, uint32_t key_len) {
-    switch (map->type) {
-        case MAP_TYPE_HASHTABLE: return ht_remove(map->impl, key_data, key_len);
-        case MAP_TYPE_SKIPLIST:  return sl_remove(map->impl, key_data, key_len);
-        case MAP_TYPE_LIST:      return ll_remove(map->impl, key_data, key_len);
-    }
-    return ERROR_INVALID_ARGUMENT;
+    return map->impl->remove(map->data, key_data, key_len);
 }