Mercurial > hg > ucx / changeset

     1.1 --- a/src/cx/map.h	Mon Apr 17 21:47:34 2023 +0200
     1.2 +++ b/src/cx/map.h	Tue Apr 18 18:01:41 2023 +0200
     1.3 @@ -56,21 +56,9 @@
     1.4  
     1.5  /** Structure for the UCX map. */
     1.6  struct cx_map_s {
     1.7 +    CX_COLLECTION_MEMBERS
     1.8      /** The map class definition. */
     1.9      cx_map_class *cl;
    1.10 -    /** An allocator that is used for the map elements. */
    1.11 -    CxAllocator *allocator;
    1.12 -    /** The number of elements currently stored. */
    1.13 -    size_t size;
    1.14 -    /**
    1.15 -     * The size of an element.
    1.16 -     */
    1.17 -    size_t item_size;
    1.18 -    /**
    1.19 -     * True, if this map shall store pointers instead
    1.20 -     * of copies of objects.
    1.21 -     */
    1.22 -    bool store_pointers;
    1.23  };
    1.24  
    1.25  /**
    1.26 @@ -179,7 +167,7 @@
    1.27   */
    1.28  __attribute__((__nonnull__))
    1.29  static inline void cxMapStoreObjects(CxMap *map) {
    1.30 -    map->store_pointers = false;
    1.31 +    map->store_pointer = false;
    1.32  }
    1.33  
    1.34  /**
    1.35 @@ -196,7 +184,7 @@
    1.36   */
    1.37  __attribute__((__nonnull__))
    1.38  static inline void cxMapStorePointers(CxMap *map) {
    1.39 -    map->store_pointers = true;
    1.40 +    map->store_pointer = true;
    1.41      map->item_size = sizeof(void *);
    1.42  }
    1.43  

     2.1 --- a/src/hash_map.c	Mon Apr 17 21:47:34 2023 +0200
     2.2 +++ b/src/hash_map.c	Tue Apr 18 18:01:41 2023 +0200
     2.3 @@ -100,7 +100,7 @@
     2.4      if (elm != NULL && elm->key.hash == hash && elm->key.len == key.len &&
     2.5          memcmp(elm->key.data.obj, key.data.obj, key.len) == 0) {
     2.6          // overwrite existing element
     2.7 -        if (map->store_pointers) {
     2.8 +        if (map->store_pointer) {
     2.9              memcpy(elm->data, &value, sizeof(void *));
    2.10          } else {
    2.11              memcpy(elm->data, value, map->item_size);
    2.12 @@ -116,7 +116,7 @@
    2.13          }
    2.14  
    2.15          // write the value
    2.16 -        if (map->store_pointers) {
    2.17 +        if (map->store_pointer) {
    2.18              memcpy(e->data, &value, sizeof(void *));
    2.19          } else {
    2.20              memcpy(e->data, value, map->item_size);
    2.21 @@ -194,7 +194,7 @@
    2.22          if (elm->key.hash == hash && elm->key.len == key.len) {
    2.23              if (memcmp(elm->key.data.obj, key.data.obj, key.len) == 0) {
    2.24                  void *data = NULL;
    2.25 -                if (map->store_pointers) {
    2.26 +                if (map->store_pointer) {
    2.27                      data = *(void **) elm->data;
    2.28                  } else if (!remove) {
    2.29                      data = elm->data;
    2.30 @@ -243,7 +243,7 @@
    2.31      struct cx_iterator_s const *iter = it;
    2.32      struct cx_hash_map_s const *map = iter->src_handle;
    2.33      struct cx_hash_map_element_s *elm = iter->elem_handle;
    2.34 -    if (map->base.store_pointers) {
    2.35 +    if (map->base.store_pointer) {
    2.36          return *(void **) elm->data;
    2.37      } else {
    2.38          return elm->data;
    2.39 @@ -304,7 +304,7 @@
    2.40          iter->kv_data.value = NULL;
    2.41      } else {
    2.42          iter->kv_data.key = &elm->key;
    2.43 -        if (map->base.store_pointers) {
    2.44 +        if (map->base.store_pointer) {
    2.45              iter->kv_data.value = *(void **) elm->data;
    2.46          } else {
    2.47              iter->kv_data.value = elm->data;
    2.48 @@ -344,7 +344,7 @@
    2.49          }
    2.50          iter.elem_handle = elm;
    2.51          iter.kv_data.key = &elm->key;
    2.52 -        if (map->store_pointers) {
    2.53 +        if (map->store_pointer) {
    2.54              iter.kv_data.value = *(void **) elm->data;
    2.55          } else {
    2.56              iter.kv_data.value = elm->data;
    2.57 @@ -416,7 +416,7 @@
    2.58          buckets = 16;
    2.59      }
    2.60  
    2.61 -    struct cx_hash_map_s *map = cxMalloc(allocator, sizeof(struct cx_hash_map_s));
    2.62 +    struct cx_hash_map_s *map = cxCalloc(allocator, 1, sizeof(struct cx_hash_map_s));
    2.63      if (map == NULL) return NULL;
    2.64  
    2.65      // initialize hash map members
    2.66 @@ -430,13 +430,12 @@
    2.67      // initialize base members
    2.68      map->base.cl = &cx_hash_map_class;
    2.69      map->base.allocator = allocator;
    2.70 -    map->base.size = 0;
    2.71  
    2.72      if (itemsize > 0) {
    2.73 -        map->base.store_pointers = false;
    2.74 +        map->base.store_pointer = false;
    2.75          map->base.item_size = itemsize;
    2.76      } else {
    2.77 -        map->base.store_pointers = true;
    2.78 +        map->base.store_pointer = true;
    2.79          map->base.item_size = sizeof(void *);
    2.80      }
    2.81  

     3.1 --- a/tests/test_map.cpp	Mon Apr 17 21:47:34 2023 +0200
     3.2 +++ b/tests/test_map.cpp	Tue Apr 18 18:01:41 2023 +0200
     3.3 @@ -124,12 +124,16 @@
     3.4      EXPECT_EQ(map->item_size, 1);
     3.5      EXPECT_EQ(map->size, 0);
     3.6      EXPECT_EQ(map->allocator, &allocator);
     3.7 -    EXPECT_FALSE(map->store_pointers);
     3.8 +    EXPECT_FALSE(map->store_pointer);
     3.9 +    EXPECT_EQ(map->cmpfunc, nullptr);
    3.10 +    EXPECT_EQ(map->simple_destructor, nullptr);
    3.11 +    EXPECT_EQ(map->advanced_destructor, nullptr);
    3.12 +    EXPECT_EQ(map->destructor_data, nullptr);
    3.13      cxMapStorePointers(map);
    3.14 -    EXPECT_TRUE(map->store_pointers);
    3.15 +    EXPECT_TRUE(map->store_pointer);
    3.16      EXPECT_EQ(map->item_size, sizeof(void *));
    3.17      cxMapStoreObjects(map);
    3.18 -    EXPECT_FALSE(map->store_pointers);
    3.19 +    EXPECT_FALSE(map->store_pointer);
    3.20  
    3.21      cxMapDestroy(map);
    3.22      EXPECT_TRUE(allocator.verify());
    3.23 @@ -145,7 +149,7 @@
    3.24      }
    3.25      EXPECT_EQ(map->size, 0);
    3.26      EXPECT_EQ(map->allocator, &allocator);
    3.27 -    EXPECT_TRUE(map->store_pointers);
    3.28 +    EXPECT_TRUE(map->store_pointer);
    3.29      EXPECT_EQ(map->item_size, sizeof(void *));
    3.30  
    3.31      cxMapDestroy(map);
    3.32 @@ -302,11 +306,11 @@
    3.33      auto map = cxHashMapCreate(&allocator, sizeof(cxstring), 8);
    3.34  
    3.35      // define some strings
    3.36 -    cxstring s1 = CX_STR("this");
    3.37 -    cxstring s2 = CX_STR("is");
    3.38 -    cxstring s3 = CX_STR("a");
    3.39 -    cxstring s4 = CX_STR("test");
    3.40 -    cxstring s5 = CX_STR("setup");
    3.41 +    auto s1 = CX_STR("this");
    3.42 +    auto s2 = CX_STR("is");
    3.43 +    auto s3 = CX_STR("a");
    3.44 +    auto s4 = CX_STR("test");
    3.45 +    auto s5 = CX_STR("setup");
    3.46  
    3.47      // put them into the map
    3.48      cxMapPut(map, cx_hash_key_str("s1"), &s1);
    3.49 @@ -339,3 +343,4 @@
    3.50      cxMapDestroy(map);
    3.51      EXPECT_TRUE(allocator.verify());
    3.52  }
    3.53 +