Mercurial > hg > webserver / file comparison

comparison: src/ucx/hash_map.c

src/ucx/hash_map.c

changeset 579
e10457d74fe1
parent 504
c094afcdfb27
equal deleted inserted replaced
578:eb48f716b31c 579:e10457d74fe1
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE. 26 * POSSIBILITY OF SUCH DAMAGE.
27 */ 27 */
28 28
29 #include "cx/hash_map.h" 29 #include "cx/hash_map.h"
30 #include "cx/utils.h"
31 30
32 #include <string.h> 31 #include <string.h>
33 #include <assert.h> 32 #include <assert.h>
33 #include <errno.h>
34 34
35 struct cx_hash_map_element_s { 35 struct cx_hash_map_element_s {
36 /** A pointer to the next element in the current bucket. */ 36 /** A pointer to the next element in the current bucket. */
37 struct cx_hash_map_element_s *next; 37 struct cx_hash_map_element_s *next;
38 38
43 char data[]; 43 char data[];
44 }; 44 };
45 45
46 static void cx_hash_map_clear(struct cx_map_s *map) { 46 static void cx_hash_map_clear(struct cx_map_s *map) {
47 struct cx_hash_map_s *hash_map = (struct cx_hash_map_s *) map; 47 struct cx_hash_map_s *hash_map = (struct cx_hash_map_s *) map;
48 cx_for_n(i, hash_map->bucket_count) { 48 for (size_t i = 0; i < hash_map->bucket_count; i++) {
49 struct cx_hash_map_element_s *elem = hash_map->buckets[i]; 49 struct cx_hash_map_element_s *elem = hash_map->buckets[i];
50 if (elem != NULL) { 50 if (elem != NULL) {
51 do { 51 do {
52 struct cx_hash_map_element_s *next = elem->next; 52 struct cx_hash_map_element_s *next = elem->next;
53 // invoke the destructor 53 // invoke the destructor
54 cx_invoke_destructor(map, elem->data); 54 cx_invoke_destructor(map, elem->data);
55 // free the key data 55 // free the key data
56 cxFree(map->allocator, (void *) elem->key.data); 56 cxFree(map->collection.allocator, (void *) elem->key.data);
57 // free the node 57 // free the node
58 cxFree(map->allocator, elem); 58 cxFree(map->collection.allocator, elem);
59 // proceed 59 // proceed
60 elem = next; 60 elem = next;
61 } while (elem != NULL); 61 } while (elem != NULL);
62 62
63 // do not leave a dangling pointer 63 // do not leave a dangling pointer
64 hash_map->buckets[i] = NULL; 64 hash_map->buckets[i] = NULL;
65 } 65 }
66 } 66 }
67 map->size = 0; 67 map->collection.size = 0;
68 } 68 }
69 69
70 static void cx_hash_map_destructor(struct cx_map_s *map) { 70 static void cx_hash_map_destructor(struct cx_map_s *map) {
71 struct cx_hash_map_s *hash_map = (struct cx_hash_map_s *) map; 71 struct cx_hash_map_s *hash_map = (struct cx_hash_map_s *) map;
72 72
73 // free the buckets 73 // free the buckets
74 cx_hash_map_clear(map); 74 cx_hash_map_clear(map);
75 cxFree(map->allocator, hash_map->buckets); 75 cxFree(map->collection.allocator, hash_map->buckets);
76 76
77 // free the map structure 77 // free the map structure
78 cxFree(map->allocator, map); 78 cxFree(map->collection.allocator, map);
79 } 79 }
80 80
81 static int cx_hash_map_put( 81 static int 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;
87 CxAllocator const *allocator = map->allocator; 87 const CxAllocator *allocator = map->collection.allocator;
88 88
89 unsigned hash = key.hash; 89 unsigned hash = key.hash;
90 if (hash == 0) { 90 if (hash == 0) {
91 cx_hash_murmur(&key); 91 cx_hash_murmur(&key);
92 hash = key.hash; 92 hash = key.hash;
101 elm = elm->next; 101 elm = elm->next;
102 } 102 }
103 103
104 if (elm != NULL && elm->key.hash == hash && elm->key.len == key.len && 104 if (elm != NULL && elm->key.hash == hash && elm->key.len == key.len &&
105 memcmp(elm->key.data, key.data, key.len) == 0) { 105 memcmp(elm->key.data, key.data, key.len) == 0) {
106 // overwrite existing element 106 // overwrite existing element, but call destructors first
107 if (map->store_pointer) { 107 cx_invoke_destructor(map, elm->data);
108 if (map->collection.store_pointer) {
108 memcpy(elm->data, &value, sizeof(void *)); 109 memcpy(elm->data, &value, sizeof(void *));
109 } else { 110 } else {
110 memcpy(elm->data, value, map->item_size); 111 memcpy(elm->data, value, map->collection.elem_size);
111 } 112 }
112 } else { 113 } else {
113 // allocate new element 114 // allocate new element
114 struct cx_hash_map_element_s *e = cxMalloc( 115 struct cx_hash_map_element_s *e = cxMalloc(
115 allocator, 116 allocator,
116 sizeof(struct cx_hash_map_element_s) + map->item_size 117 sizeof(struct cx_hash_map_element_s) + map->collection.elem_size
117 ); 118 );
118 if (e == NULL) { 119 if (e == NULL) return -1;
119 return -1;
120 }
121 120
122 // write the value 121 // write the value
123 if (map->store_pointer) { 122 if (map->collection.store_pointer) {
124 memcpy(e->data, &value, sizeof(void *)); 123 memcpy(e->data, &value, sizeof(void *));
125 } else { 124 } else {
126 memcpy(e->data, value, map->item_size); 125 memcpy(e->data, value, map->collection.elem_size);
127 } 126 }
128 127
129 // copy the key 128 // copy the key
130 void *kd = cxMalloc(allocator, key.len); 129 void *kd = cxMalloc(allocator, key.len);
131 if (kd == NULL) { 130 if (kd == NULL) return -1;
132 return -1;
133 }
134 memcpy(kd, key.data, key.len); 131 memcpy(kd, key.data, key.len);
135 e->key.data = kd; 132 e->key.data = kd;
136 e->key.len = key.len; 133 e->key.len = key.len;
137 e->key.hash = hash; 134 e->key.hash = hash;
138 135
143 prev->next = e; 140 prev->next = e;
144 } 141 }
145 e->next = elm; 142 e->next = elm;
146 143
147 // increase the size 144 // increase the size
148 map->size++; 145 map->collection.size++;
149 } 146 }
150 147
151 return 0; 148 return 0;
152 } 149 }
153 150
162 hash_map->buckets[slot] = elm->next; 159 hash_map->buckets[slot] = elm->next;
163 } else { 160 } else {
164 prev->next = elm->next; 161 prev->next = elm->next;
165 } 162 }
166 // free element 163 // free element
167 cxFree(hash_map->base.allocator, (void *) elm->key.data); 164 cxFree(hash_map->base.collection.allocator, (void *) elm->key.data);
168 cxFree(hash_map->base.allocator, elm); 165 cxFree(hash_map->base.collection.allocator, elm);
169 // decrease size 166 // decrease size
170 hash_map->base.size--; 167 hash_map->base.collection.size--;
171 } 168 }
172 169
173 /** 170 /**
174 * Helper function to avoid code duplication. 171 * Helper function to avoid code duplication.
175 * 172 *
173 * If @p remove is true, and @p targetbuf is @c NULL, the element
174 * will be destroyed when found.
175 *
176 * If @p remove is true, and @p targetbuf is set, the element will
177 * be copied to that buffer and no destructor function is called.
178 *
179 * If @p remove is false, @p targetbuf must not be non-null and
180 * either the pointer, when the map is storing pointers, is copied
181 * to the target buffer, or a pointer to the stored object will
182 * be copied to the target buffer.
183 *
176 * @param map the map 184 * @param map the map
177 * @param key the key to look up 185 * @param key the key to look up
186 * @param targetbuf see description
178 * @param remove flag indicating whether the looked up entry shall be removed 187 * @param remove flag indicating whether the looked up entry shall be removed
179 * @param destroy flag indicating whether the destructor shall be invoked 188 * @return zero, if the key was found, non-zero otherwise
180 * @return a pointer to the value corresponding to the key or \c NULL
181 */ 189 */
182 static void *cx_hash_map_get_remove( 190 static int cx_hash_map_get_remove(
183 CxMap *map, 191 CxMap *map,
184 CxHashKey key, 192 CxHashKey key,
185 bool remove, 193 void *targetbuf,
186 bool destroy 194 bool remove
187 ) { 195 ) {
188 struct cx_hash_map_s *hash_map = (struct cx_hash_map_s *) map; 196 struct cx_hash_map_s *hash_map = (struct cx_hash_map_s *) map;
189 197
190 unsigned hash = key.hash; 198 unsigned hash = key.hash;
191 if (hash == 0) { 199 if (hash == 0) {
197 struct cx_hash_map_element_s *elm = hash_map->buckets[slot]; 205 struct cx_hash_map_element_s *elm = hash_map->buckets[slot];
198 struct cx_hash_map_element_s *prev = NULL; 206 struct cx_hash_map_element_s *prev = NULL;
199 while (elm && elm->key.hash <= hash) { 207 while (elm && elm->key.hash <= hash) {
200 if (elm->key.hash == hash && elm->key.len == key.len) { 208 if (elm->key.hash == hash && elm->key.len == key.len) {
201 if (memcmp(elm->key.data, key.data, key.len) == 0) { 209 if (memcmp(elm->key.data, key.data, key.len) == 0) {
202 void *data = NULL; 210 if (remove) {
203 if (destroy) { 211 if (targetbuf == NULL) {
204 cx_invoke_destructor(map, elm->data); 212 cx_invoke_destructor(map, elm->data);
213 } else {
214 memcpy(targetbuf, elm->data, map->collection.elem_size);
215 }
216 cx_hash_map_unlink(hash_map, slot, prev, elm);
205 } else { 217 } else {
206 if (map->store_pointer) { 218 assert(targetbuf != NULL);
219 void *data = NULL;
220 if (map->collection.store_pointer) {
207 data = *(void **) elm->data; 221 data = *(void **) elm->data;
208 } else { 222 } else {
209 data = elm->data; 223 data = elm->data;
210 } 224 }
225 memcpy(targetbuf, &data, sizeof(void *));
211 } 226 }
212 if (remove) { 227 return 0;
213 cx_hash_map_unlink(hash_map, slot, prev, elm);
214 }
215 return data;
216 } 228 }
217 } 229 }
218 prev = elm; 230 prev = elm;
219 elm = prev->next; 231 elm = prev->next;
220 } 232 }
221 233
222 return NULL; 234 return 1;
223 } 235 }
224 236
225 static void *cx_hash_map_get( 237 static void *cx_hash_map_get(
226 CxMap const *map, 238 const CxMap *map,
227 CxHashKey key 239 CxHashKey key
228 ) { 240 ) {
229 // we can safely cast, because we know the map stays untouched 241 // we can safely cast, because we know the map stays untouched
230 return cx_hash_map_get_remove((CxMap *) map, key, false, false); 242 void *ptr = NULL;
231 } 243 int found = cx_hash_map_get_remove((CxMap *) map, key, &ptr, false);
232 244 return found == 0 ? ptr : NULL;
233 static void *cx_hash_map_remove( 245 }
246
247 static int cx_hash_map_remove(
234 CxMap *map, 248 CxMap *map,
235 CxHashKey key, 249 CxHashKey key,
236 bool destroy 250 void *targetbuf
237 ) { 251 ) {
238 return cx_hash_map_get_remove(map, key, true, destroy); 252 return cx_hash_map_get_remove(map, key, targetbuf, true);
239 } 253 }
240 254
241 static void *cx_hash_map_iter_current_entry(void const *it) { 255 static void *cx_hash_map_iter_current_entry(const void *it) {
242 struct cx_iterator_s const *iter = it; 256 const CxMapIterator *iter = it;
243 // struct has to have a compatible signature 257 // we have to cast away const, because of the signature
244 return (struct cx_map_entry_s *) &(iter->kv_data); 258 return (void*) &iter->entry;
245 } 259 }
246 260
247 static void *cx_hash_map_iter_current_key(void const *it) { 261 static void *cx_hash_map_iter_current_key(const void *it) {
248 struct cx_iterator_s const *iter = it; 262 const CxMapIterator *iter = it;
249 struct cx_hash_map_element_s *elm = iter->elem_handle; 263 struct cx_hash_map_element_s *elm = iter->elem;
250 return &elm->key; 264 return &elm->key;
251 } 265 }
252 266
253 static void *cx_hash_map_iter_current_value(void const *it) { 267 static void *cx_hash_map_iter_current_value(const void *it) {
254 struct cx_iterator_s const *iter = it; 268 const CxMapIterator *iter = it;
255 struct cx_hash_map_s const *map = iter->src_handle; 269 const CxMap *map = iter->map.c;
256 struct cx_hash_map_element_s *elm = iter->elem_handle; 270 struct cx_hash_map_element_s *elm = iter->elem;
257 if (map->base.store_pointer) { 271 if (map->collection.store_pointer) {
258 return *(void **) elm->data; 272 return *(void **) elm->data;
259 } else { 273 } else {
260 return elm->data; 274 return elm->data;
261 } 275 }
262 } 276 }
263 277
264 static bool cx_hash_map_iter_valid(void const *it) { 278 static bool cx_hash_map_iter_valid(const void *it) {
265 struct cx_iterator_s const *iter = it; 279 const CxMapIterator *iter = it;
266 return iter->elem_handle != NULL; 280 return iter->elem != NULL;
267 } 281 }
268 282
269 static void cx_hash_map_iter_next(void *it) { 283 static void cx_hash_map_iter_next(void *it) {
270 struct cx_iterator_s *iter = it; 284 CxMapIterator *iter = it;
271 struct cx_hash_map_element_s *elm = iter->elem_handle; 285 CxMap *map = iter->map.m;
286 struct cx_hash_map_s *hmap = (struct cx_hash_map_s *) map;
287 struct cx_hash_map_element_s *elm = iter->elem;
272 288
273 // remove current element, if asked 289 // remove current element, if asked
274 if (iter->base.remove) { 290 if (iter->base.remove) {
275 // obtain mutable pointer to the map
276 struct cx_mut_iterator_s *miter = it;
277 struct cx_hash_map_s *map = miter->src_handle;
278 291
279 // clear the flag 292 // clear the flag
280 iter->base.remove = false; 293 iter->base.remove = false;
281 294
282 // determine the next element 295 // determine the next element
283 struct cx_hash_map_element_s *next = elm->next; 296 struct cx_hash_map_element_s *next = elm->next;
284 297
285 // search the previous element 298 // search the previous element
286 struct cx_hash_map_element_s *prev = NULL; 299 struct cx_hash_map_element_s *prev = NULL;
287 if (map->buckets[iter->slot] != elm) { 300 if (hmap->buckets[iter->slot] != elm) {
288 prev = map->buckets[iter->slot]; 301 prev = hmap->buckets[iter->slot];
289 while (prev->next != elm) { 302 while (prev->next != elm) {
290 prev = prev->next; 303 prev = prev->next;
291 } 304 }
292 } 305 }
293 306
294 // destroy 307 // destroy
295 cx_invoke_destructor((struct cx_map_s *) map, elm->data); 308 cx_invoke_destructor(map, elm->data);
296 309
297 // unlink 310 // unlink
298 cx_hash_map_unlink(map, iter->slot, prev, elm); 311 cx_hash_map_unlink(hmap, iter->slot, prev, elm);
299 312
300 // advance 313 // advance
301 elm = next; 314 elm = next;
302 } else { 315 } else {
303 // just advance 316 // just advance
304 elm = elm->next; 317 elm = elm->next;
305 iter->index++; 318 iter->index++;
306 } 319 }
307 320
308 // search the next bucket, if required 321 // search the next bucket, if required
309 struct cx_hash_map_s const *map = iter->src_handle; 322 while (elm == NULL && ++iter->slot < hmap->bucket_count) {
310 while (elm == NULL && ++iter->slot < map->bucket_count) { 323 elm = hmap->buckets[iter->slot];
311 elm = map->buckets[iter->slot]; 324 }
312 } 325 iter->elem = elm;
313 326
314 // fill the struct with the next element 327 // copy data to a location where the iterator can point to
315 iter->elem_handle = elm; 328 // we need to do it here, because the iterator function call
316 if (elm == NULL) { 329 // must not modify the iterator (the parameter is const)
317 iter->kv_data.key = NULL; 330 if (elm != NULL) {
318 iter->kv_data.value = NULL; 331 iter->entry.key = &elm->key;
319 } else { 332 if (iter->map.c->collection.store_pointer) {
320 iter->kv_data.key = &elm->key; 333 iter->entry.value = *(void **) elm->data;
321 if (map->base.store_pointer) {
322 iter->kv_data.value = *(void **) elm->data;
323 } else { 334 } else {
324 iter->kv_data.value = elm->data; 335 iter->entry.value = elm->data;
325 } 336 }
326 } 337 }
327 } 338 }
328 339
329 static bool cx_hash_map_iter_flag_rm(void *it) { 340 static CxMapIterator cx_hash_map_iterator(
330 struct cx_iterator_base_s *iter = it; 341 const CxMap *map,
331 if (iter->mutating) {
332 iter->remove = true;
333 return true;
334 } else {
335 return false;
336 }
337 }
338
339 static CxIterator cx_hash_map_iterator(
340 CxMap const *map,
341 enum cx_map_iterator_type type 342 enum cx_map_iterator_type type
342 ) { 343 ) {
343 CxIterator iter; 344 CxMapIterator iter;
344 345
345 iter.src_handle = map; 346 iter.map.c = map;
346 iter.base.valid = cx_hash_map_iter_valid; 347 iter.elem_count = map->collection.size;
347 iter.base.next = cx_hash_map_iter_next;
348 348
349 switch (type) { 349 switch (type) {
350 case CX_MAP_ITERATOR_PAIRS: 350 case CX_MAP_ITERATOR_PAIRS:
351 iter.elem_size = sizeof(CxMapEntry);
351 iter.base.current = cx_hash_map_iter_current_entry; 352 iter.base.current = cx_hash_map_iter_current_entry;
352 break; 353 break;
353 case CX_MAP_ITERATOR_KEYS: 354 case CX_MAP_ITERATOR_KEYS:
355 iter.elem_size = sizeof(CxHashKey);
354 iter.base.current = cx_hash_map_iter_current_key; 356 iter.base.current = cx_hash_map_iter_current_key;
355 break; 357 break;
356 case CX_MAP_ITERATOR_VALUES: 358 case CX_MAP_ITERATOR_VALUES:
359 iter.elem_size = map->collection.elem_size;
357 iter.base.current = cx_hash_map_iter_current_value; 360 iter.base.current = cx_hash_map_iter_current_value;
358 break; 361 break;
359 default: 362 default:
360 assert(false); 363 assert(false); // LCOV_EXCL_LINE
361 } 364 }
362 365
363 iter.base.flag_removal = cx_hash_map_iter_flag_rm; 366 iter.base.valid = cx_hash_map_iter_valid;
367 iter.base.next = cx_hash_map_iter_next;
364 iter.base.remove = false; 368 iter.base.remove = false;
365 iter.base.mutating = false; 369 iter.base.mutating = false;
366 370
367 iter.slot = 0; 371 iter.slot = 0;
368 iter.index = 0; 372 iter.index = 0;
369 373
370 if (map->size > 0) { 374 if (map->collection.size > 0) {
371 struct cx_hash_map_s *hash_map = (struct cx_hash_map_s *) map; 375 struct cx_hash_map_s *hash_map = (struct cx_hash_map_s *) map;
372 struct cx_hash_map_element_s *elm = hash_map->buckets[0]; 376 struct cx_hash_map_element_s *elm = hash_map->buckets[0];
373 while (elm == NULL) { 377 while (elm == NULL) {
374 elm = hash_map->buckets[++iter.slot]; 378 elm = hash_map->buckets[++iter.slot];
375 } 379 }
376 iter.elem_handle = elm; 380 iter.elem = elm;
377 iter.kv_data.key = &elm->key; 381 iter.entry.key = &elm->key;
378 if (map->store_pointer) { 382 if (map->collection.store_pointer) {
379 iter.kv_data.value = *(void **) elm->data; 383 iter.entry.value = *(void **) elm->data;
380 } else { 384 } else {
381 iter.kv_data.value = elm->data; 385 iter.entry.value = elm->data;
382 } 386 }
383 } else { 387 } else {
384 iter.elem_handle = NULL; 388 iter.elem = NULL;
385 iter.kv_data.key = NULL;
386 iter.kv_data.value = NULL;
387 } 389 }
388 390
389 return iter; 391 return iter;
390 } 392 }
391 393
397 cx_hash_map_remove, 399 cx_hash_map_remove,
398 cx_hash_map_iterator, 400 cx_hash_map_iterator,
399 }; 401 };
400 402
401 CxMap *cxHashMapCreate( 403 CxMap *cxHashMapCreate(
402 CxAllocator const *allocator, 404 const CxAllocator *allocator,
403 size_t itemsize, 405 size_t itemsize,
404 size_t buckets 406 size_t buckets
405 ) { 407 ) {
408 if (allocator == NULL) {
409 allocator = cxDefaultAllocator;
410 }
411
406 if (buckets == 0) { 412 if (buckets == 0) {
407 // implementation defined default 413 // implementation defined default
408 buckets = 16; 414 buckets = 16;
409 } 415 }
410 416
414 420
415 // initialize hash map members 421 // initialize hash map members
416 map->bucket_count = buckets; 422 map->bucket_count = buckets;
417 map->buckets = cxCalloc(allocator, buckets, 423 map->buckets = cxCalloc(allocator, buckets,
418 sizeof(struct cx_hash_map_element_s *)); 424 sizeof(struct cx_hash_map_element_s *));
419 if (map->buckets == NULL) { 425 if (map->buckets == NULL) { // LCOV_EXCL_START
420 cxFree(allocator, map); 426 cxFree(allocator, map);
421 return NULL; 427 return NULL;
422 } 428 } // LCOV_EXCL_STOP
423 429
424 // initialize base members 430 // initialize base members
425 map->base.cl = &cx_hash_map_class; 431 map->base.cl = &cx_hash_map_class;
426 map->base.allocator = allocator; 432 map->base.collection.allocator = allocator;
427 433
428 if (itemsize > 0) { 434 if (itemsize > 0) {
429 map->base.store_pointer = false; 435 map->base.collection.elem_size = itemsize;
430 map->base.item_size = itemsize; 436 } else {
431 } else { 437 map->base.collection.elem_size = sizeof(void *);
432 map->base.store_pointer = true; 438 map->base.collection.store_pointer = true;
433 map->base.item_size = sizeof(void *);
434 } 439 }
435 440
436 return (CxMap *) map; 441 return (CxMap *) map;
437 } 442 }
438 443
439 int cxMapRehash(CxMap *map) { 444 int cxMapRehash(CxMap *map) {
440 struct cx_hash_map_s *hash_map = (struct cx_hash_map_s *) map; 445 struct cx_hash_map_s *hash_map = (struct cx_hash_map_s *) map;
441 if (map->size > ((hash_map->bucket_count * 3) >> 2)) { 446 if (map->collection.size > ((hash_map->bucket_count * 3) >> 2)) {
442 447
443 size_t new_bucket_count = (map->size * 5) >> 1; 448 size_t new_bucket_count = (map->collection.size * 5) >> 1;
449 if (new_bucket_count < hash_map->bucket_count) {
450 errno = EOVERFLOW;
451 return 1;
452 }
444 struct cx_hash_map_element_s **new_buckets = cxCalloc( 453 struct cx_hash_map_element_s **new_buckets = cxCalloc(
445 map->allocator, 454 map->collection.allocator,
446 new_bucket_count, sizeof(struct cx_hash_map_element_s *) 455 new_bucket_count, sizeof(struct cx_hash_map_element_s *)
447 ); 456 );
448 457
449 if (new_buckets == NULL) { 458 if (new_buckets == NULL) return 1;
450 return 1;
451 }
452 459
453 // iterate through the elements and assign them to their new slots 460 // iterate through the elements and assign them to their new slots
454 cx_for_n(slot, hash_map->bucket_count) { 461 for (size_t slot = 0; slot < hash_map->bucket_count; slot++) {
455 struct cx_hash_map_element_s *elm = hash_map->buckets[slot]; 462 struct cx_hash_map_element_s *elm = hash_map->buckets[slot];
456 while (elm != NULL) { 463 while (elm != NULL) {
457 struct cx_hash_map_element_s *next = elm->next; 464 struct cx_hash_map_element_s *next = elm->next;
458 size_t new_slot = elm->key.hash % new_bucket_count; 465 size_t new_slot = elm->key.hash % new_bucket_count;
459 466
480 } 487 }
481 } 488 }
482 489
483 // assign result to the map 490 // assign result to the map
484 hash_map->bucket_count = new_bucket_count; 491 hash_map->bucket_count = new_bucket_count;
485 cxFree(map->allocator, hash_map->buckets); 492 cxFree(map->collection.allocator, hash_map->buckets);
486 hash_map->buckets = new_buckets; 493 hash_map->buckets = new_buckets;
487 } 494 }
488 return 0; 495 return 0;
489 } 496 }

Mercurial Repository: webserver

mercurial