ucx/hash_map.c

changeset 31
287484519844
parent 23
b26390e77237
equal deleted inserted replaced
30:d33eaaec15da 31:287484519844
76 76
77 // free the map structure 77 // free the map structure
78 cxFree(map->collection.allocator, map); 78 cxFree(map->collection.allocator, map);
79 } 79 }
80 80
81 static void *cx_hash_map_put( 81 static CxMapEntry cx_hash_map_put(
82 CxMap *map, 82 CxMap *map,
83 CxHashKey key, 83 CxHashKey key,
84 void *value 84 void *value
85 ) { 85 ) {
86 struct cx_hash_map_s *hash_map = (struct cx_hash_map_s *) map; 86 struct cx_hash_map_s *hash_map = (struct cx_hash_map_s *) map;
115 // allocate new element 115 // allocate new element
116 struct cx_hash_map_element_s *e = cxMalloc( 116 struct cx_hash_map_element_s *e = cxMalloc(
117 allocator, 117 allocator,
118 sizeof(struct cx_hash_map_element_s) + map->collection.elem_size 118 sizeof(struct cx_hash_map_element_s) + map->collection.elem_size
119 ); 119 );
120 if (e == NULL) return NULL; // LCOV_EXCL_LINE 120 if (e == NULL) return (CxMapEntry){NULL, NULL}; // LCOV_EXCL_LINE
121 121
122 // write the value 122 // write the value
123 if (value == NULL) { 123 if (value == NULL) {
124 memset(e->data, 0, map->collection.elem_size); 124 memset(e->data, 0, map->collection.elem_size);
125 } else if (map->collection.store_pointer) { 125 } else if (map->collection.store_pointer) {
130 130
131 // copy the key 131 // copy the key
132 void *kd = cxMalloc(allocator, key.len); 132 void *kd = cxMalloc(allocator, key.len);
133 if (kd == NULL) { // LCOV_EXCL_START 133 if (kd == NULL) { // LCOV_EXCL_START
134 cxFree(allocator, e); 134 cxFree(allocator, e);
135 return NULL; 135 return (CxMapEntry){NULL, NULL};
136 } // LCOV_EXCL_STOP 136 } // LCOV_EXCL_STOP
137 memcpy(kd, key.data, key.len); 137 memcpy(kd, key.data, key.len);
138 e->key.data = kd; 138 e->key.data = kd;
139 e->key.len = key.len; 139 e->key.len = key.len;
140 e->key.hash = hash; 140 e->key.hash = hash;
150 150
151 // increase the size 151 // increase the size
152 map->collection.size++; 152 map->collection.size++;
153 } 153 }
154 154
155 // return pointer to the element 155 // return the entry
156 return elm->data; 156 return (CxMapEntry){&elm->key, elm->data};
157 } 157 }
158 158
159 static void cx_hash_map_unlink( 159 static void cx_hash_map_unlink(
160 struct cx_hash_map_s *hash_map, 160 struct cx_hash_map_s *hash_map,
161 size_t slot, 161 size_t slot,
412 if (buckets == 0) { 412 if (buckets == 0) {
413 // implementation defined default 413 // implementation defined default
414 buckets = 16; 414 buckets = 16;
415 } 415 }
416 416
417 struct cx_hash_map_s *map = cxCalloc(allocator, 1, 417 struct cx_hash_map_s *map = cxZalloc(allocator, sizeof(struct cx_hash_map_s));
418 sizeof(struct cx_hash_map_s));
419 if (map == NULL) return NULL; 418 if (map == NULL) return NULL;
420 419
421 // initialize hash map members 420 // initialize hash map members
422 map->bucket_count = buckets; 421 map->bucket_count = buckets;
423 map->buckets = cxCalloc(allocator, buckets, 422 map->buckets = cxCalloc(allocator, buckets,
431 map->base.cl = &cx_hash_map_class; 430 map->base.cl = &cx_hash_map_class;
432 map->base.collection.allocator = allocator; 431 map->base.collection.allocator = allocator;
433 432
434 if (itemsize > 0) { 433 if (itemsize > 0) {
435 map->base.collection.elem_size = itemsize; 434 map->base.collection.elem_size = itemsize;
435 map->base.collection.advanced_cmp = cx_ccmp_memcmp;
436 map->base.collection.cmp_data = &map->base.collection.elem_size;
436 } else { 437 } else {
437 map->base.collection.elem_size = sizeof(void *); 438 map->base.collection.elem_size = sizeof(void *);
438 map->base.collection.store_pointer = true; 439 map->base.collection.store_pointer = true;
440 map->base.collection.simple_cmp = cx_cmp_ptr;
439 } 441 }
440 442
441 return (CxMap *) map; 443 return (CxMap *) map;
442 } 444 }
443 445

mercurial