diff options
author | Christian Grothoff <christian@grothoff.org> | 2011-10-11 09:43:04 +0000 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2011-10-11 09:43:04 +0000 |
commit | d9d94d0e53d26af75ec8241383d166544ebd79f3 (patch) | |
tree | 9080b73624389403a198257fe0547bb4634e64d2 /src/util/container_multihashmap.c | |
parent | 2d792ee2e9cc0c993b8907e2c8edb0c2b8465343 (diff) | |
download | gnunet-d9d94d0e53d26af75ec8241383d166544ebd79f3.tar.gz gnunet-d9d94d0e53d26af75ec8241383d166544ebd79f3.zip |
converting to GNUNET_LOG_from*
Diffstat (limited to 'src/util/container_multihashmap.c')
-rw-r--r-- | src/util/container_multihashmap.c | 237 |
1 files changed, 121 insertions, 116 deletions
diff --git a/src/util/container_multihashmap.c b/src/util/container_multihashmap.c index 974d6c7f7..60d4a43d5 100644 --- a/src/util/container_multihashmap.c +++ b/src/util/container_multihashmap.c | |||
@@ -28,6 +28,8 @@ | |||
28 | #include "gnunet_container_lib.h" | 28 | #include "gnunet_container_lib.h" |
29 | #include "gnunet_crypto_lib.h" | 29 | #include "gnunet_crypto_lib.h" |
30 | 30 | ||
31 | #define LOG(kind,...) GNUNET_log_from (kind, "util", __VA_ARGS__) | ||
32 | |||
31 | /** | 33 | /** |
32 | * An entry in the hash map. | 34 | * An entry in the hash map. |
33 | */ | 35 | */ |
@@ -101,19 +103,19 @@ GNUNET_CONTAINER_multihashmap_create (unsigned int len) | |||
101 | */ | 103 | */ |
102 | void | 104 | void |
103 | GNUNET_CONTAINER_multihashmap_destroy (struct GNUNET_CONTAINER_MultiHashMap | 105 | GNUNET_CONTAINER_multihashmap_destroy (struct GNUNET_CONTAINER_MultiHashMap |
104 | *map) | 106 | *map) |
105 | { | 107 | { |
106 | unsigned int i; | 108 | unsigned int i; |
107 | struct MapEntry *e; | 109 | struct MapEntry *e; |
108 | 110 | ||
109 | for (i = 0; i < map->map_length; i++) | 111 | for (i = 0; i < map->map_length; i++) |
110 | { | ||
111 | while (NULL != (e = map->map[i])) | ||
112 | { | 112 | { |
113 | map->map[i] = e->next; | 113 | while (NULL != (e = map->map[i])) |
114 | GNUNET_free (e); | 114 | { |
115 | map->map[i] = e->next; | ||
116 | GNUNET_free (e); | ||
117 | } | ||
115 | } | 118 | } |
116 | } | ||
117 | GNUNET_free (map->map); | 119 | GNUNET_free (map->map); |
118 | GNUNET_free (map); | 120 | GNUNET_free (map); |
119 | } | 121 | } |
@@ -128,7 +130,7 @@ GNUNET_CONTAINER_multihashmap_destroy (struct GNUNET_CONTAINER_MultiHashMap | |||
128 | */ | 130 | */ |
129 | static unsigned int | 131 | static unsigned int |
130 | idx_of (const struct GNUNET_CONTAINER_MultiHashMap *m, | 132 | idx_of (const struct GNUNET_CONTAINER_MultiHashMap *m, |
131 | const GNUNET_HashCode * key) | 133 | const GNUNET_HashCode * key) |
132 | { | 134 | { |
133 | GNUNET_assert (m != NULL); | 135 | GNUNET_assert (m != NULL); |
134 | return (*(unsigned int *) key) % m->map_length; | 136 | return (*(unsigned int *) key) % m->map_length; |
@@ -143,7 +145,7 @@ idx_of (const struct GNUNET_CONTAINER_MultiHashMap *m, | |||
143 | */ | 145 | */ |
144 | unsigned int | 146 | unsigned int |
145 | GNUNET_CONTAINER_multihashmap_size (const struct GNUNET_CONTAINER_MultiHashMap | 147 | GNUNET_CONTAINER_multihashmap_size (const struct GNUNET_CONTAINER_MultiHashMap |
146 | *map) | 148 | *map) |
147 | { | 149 | { |
148 | return map->size; | 150 | return map->size; |
149 | } | 151 | } |
@@ -161,17 +163,17 @@ GNUNET_CONTAINER_multihashmap_size (const struct GNUNET_CONTAINER_MultiHashMap | |||
161 | */ | 163 | */ |
162 | void * | 164 | void * |
163 | GNUNET_CONTAINER_multihashmap_get (const struct GNUNET_CONTAINER_MultiHashMap | 165 | GNUNET_CONTAINER_multihashmap_get (const struct GNUNET_CONTAINER_MultiHashMap |
164 | *map, const GNUNET_HashCode * key) | 166 | *map, const GNUNET_HashCode * key) |
165 | { | 167 | { |
166 | struct MapEntry *e; | 168 | struct MapEntry *e; |
167 | 169 | ||
168 | e = map->map[idx_of (map, key)]; | 170 | e = map->map[idx_of (map, key)]; |
169 | while (e != NULL) | 171 | while (e != NULL) |
170 | { | 172 | { |
171 | if (0 == memcmp (key, &e->key, sizeof (GNUNET_HashCode))) | 173 | if (0 == memcmp (key, &e->key, sizeof (GNUNET_HashCode))) |
172 | return e->value; | 174 | return e->value; |
173 | e = e->next; | 175 | e = e->next; |
174 | } | 176 | } |
175 | return NULL; | 177 | return NULL; |
176 | } | 178 | } |
177 | 179 | ||
@@ -187,9 +189,9 @@ GNUNET_CONTAINER_multihashmap_get (const struct GNUNET_CONTAINER_MultiHashMap | |||
187 | */ | 189 | */ |
188 | int | 190 | int |
189 | GNUNET_CONTAINER_multihashmap_iterate (const struct | 191 | GNUNET_CONTAINER_multihashmap_iterate (const struct |
190 | GNUNET_CONTAINER_MultiHashMap *map, | 192 | GNUNET_CONTAINER_MultiHashMap *map, |
191 | GNUNET_CONTAINER_HashMapIterator it, | 193 | GNUNET_CONTAINER_HashMapIterator it, |
192 | void *it_cls) | 194 | void *it_cls) |
193 | { | 195 | { |
194 | int count; | 196 | int count; |
195 | unsigned int i; | 197 | unsigned int i; |
@@ -200,20 +202,20 @@ GNUNET_CONTAINER_multihashmap_iterate (const struct | |||
200 | count = 0; | 202 | count = 0; |
201 | GNUNET_assert (map != NULL); | 203 | GNUNET_assert (map != NULL); |
202 | for (i = 0; i < map->map_length; i++) | 204 | for (i = 0; i < map->map_length; i++) |
203 | { | ||
204 | n = map->map[i]; | ||
205 | while (NULL != (e = n)) | ||
206 | { | 205 | { |
207 | n = e->next; | 206 | n = map->map[i]; |
208 | if (NULL != it) | 207 | while (NULL != (e = n)) |
209 | { | 208 | { |
210 | kc = e->key; | 209 | n = e->next; |
211 | if (GNUNET_OK != it (it_cls, &kc, e->value)) | 210 | if (NULL != it) |
212 | return GNUNET_SYSERR; | 211 | { |
213 | } | 212 | kc = e->key; |
214 | count++; | 213 | if (GNUNET_OK != it (it_cls, &kc, e->value)) |
214 | return GNUNET_SYSERR; | ||
215 | } | ||
216 | count++; | ||
217 | } | ||
215 | } | 218 | } |
216 | } | ||
217 | return count; | 219 | return count; |
218 | } | 220 | } |
219 | 221 | ||
@@ -230,8 +232,9 @@ GNUNET_CONTAINER_multihashmap_iterate (const struct | |||
230 | * is not in the map | 232 | * is not in the map |
231 | */ | 233 | */ |
232 | int | 234 | int |
233 | GNUNET_CONTAINER_multihashmap_remove (struct GNUNET_CONTAINER_MultiHashMap *map, | 235 | GNUNET_CONTAINER_multihashmap_remove (struct GNUNET_CONTAINER_MultiHashMap |
234 | const GNUNET_HashCode * key, void *value) | 236 | *map, const GNUNET_HashCode * key, |
237 | void *value) | ||
235 | { | 238 | { |
236 | struct MapEntry *e; | 239 | struct MapEntry *e; |
237 | struct MapEntry *p; | 240 | struct MapEntry *p; |
@@ -241,21 +244,21 @@ GNUNET_CONTAINER_multihashmap_remove (struct GNUNET_CONTAINER_MultiHashMap *map, | |||
241 | p = NULL; | 244 | p = NULL; |
242 | e = map->map[i]; | 245 | e = map->map[i]; |
243 | while (e != NULL) | 246 | while (e != NULL) |
244 | { | ||
245 | if ((0 == memcmp (key, &e->key, sizeof (GNUNET_HashCode))) && | ||
246 | (value == e->value)) | ||
247 | { | 247 | { |
248 | if (p == NULL) | 248 | if ((0 == memcmp (key, &e->key, sizeof (GNUNET_HashCode))) && |
249 | map->map[i] = e->next; | 249 | (value == e->value)) |
250 | else | 250 | { |
251 | p->next = e->next; | 251 | if (p == NULL) |
252 | GNUNET_free (e); | 252 | map->map[i] = e->next; |
253 | map->size--; | 253 | else |
254 | return GNUNET_YES; | 254 | p->next = e->next; |
255 | GNUNET_free (e); | ||
256 | map->size--; | ||
257 | return GNUNET_YES; | ||
258 | } | ||
259 | p = e; | ||
260 | e = e->next; | ||
255 | } | 261 | } |
256 | p = e; | ||
257 | e = e->next; | ||
258 | } | ||
259 | return GNUNET_NO; | 262 | return GNUNET_NO; |
260 | } | 263 | } |
261 | 264 | ||
@@ -270,7 +273,7 @@ GNUNET_CONTAINER_multihashmap_remove (struct GNUNET_CONTAINER_MultiHashMap *map, | |||
270 | */ | 273 | */ |
271 | int | 274 | int |
272 | GNUNET_CONTAINER_multihashmap_remove_all (struct GNUNET_CONTAINER_MultiHashMap | 275 | GNUNET_CONTAINER_multihashmap_remove_all (struct GNUNET_CONTAINER_MultiHashMap |
273 | *map, const GNUNET_HashCode * key) | 276 | *map, const GNUNET_HashCode * key) |
274 | { | 277 | { |
275 | struct MapEntry *e; | 278 | struct MapEntry *e; |
276 | struct MapEntry *p; | 279 | struct MapEntry *p; |
@@ -282,27 +285,27 @@ GNUNET_CONTAINER_multihashmap_remove_all (struct GNUNET_CONTAINER_MultiHashMap | |||
282 | p = NULL; | 285 | p = NULL; |
283 | e = map->map[i]; | 286 | e = map->map[i]; |
284 | while (e != NULL) | 287 | while (e != NULL) |
285 | { | ||
286 | if (0 == memcmp (key, &e->key, sizeof (GNUNET_HashCode))) | ||
287 | { | 288 | { |
288 | if (p == NULL) | 289 | if (0 == memcmp (key, &e->key, sizeof (GNUNET_HashCode))) |
289 | map->map[i] = e->next; | 290 | { |
290 | else | 291 | if (p == NULL) |
291 | p->next = e->next; | 292 | map->map[i] = e->next; |
292 | GNUNET_free (e); | 293 | else |
293 | map->size--; | 294 | p->next = e->next; |
294 | if (p == NULL) | 295 | GNUNET_free (e); |
295 | e = map->map[i]; | 296 | map->size--; |
297 | if (p == NULL) | ||
298 | e = map->map[i]; | ||
299 | else | ||
300 | e = p->next; | ||
301 | ret++; | ||
302 | } | ||
296 | else | 303 | else |
297 | e = p->next; | 304 | { |
298 | ret++; | 305 | p = e; |
299 | } | 306 | e = e->next; |
300 | else | 307 | } |
301 | { | ||
302 | p = e; | ||
303 | e = e->next; | ||
304 | } | 308 | } |
305 | } | ||
306 | return ret; | 309 | return ret; |
307 | } | 310 | } |
308 | 311 | ||
@@ -318,18 +321,18 @@ GNUNET_CONTAINER_multihashmap_remove_all (struct GNUNET_CONTAINER_MultiHashMap | |||
318 | */ | 321 | */ |
319 | int | 322 | int |
320 | GNUNET_CONTAINER_multihashmap_contains (const struct | 323 | GNUNET_CONTAINER_multihashmap_contains (const struct |
321 | GNUNET_CONTAINER_MultiHashMap *map, | 324 | GNUNET_CONTAINER_MultiHashMap *map, |
322 | const GNUNET_HashCode * key) | 325 | const GNUNET_HashCode * key) |
323 | { | 326 | { |
324 | struct MapEntry *e; | 327 | struct MapEntry *e; |
325 | 328 | ||
326 | e = map->map[idx_of (map, key)]; | 329 | e = map->map[idx_of (map, key)]; |
327 | while (e != NULL) | 330 | while (e != NULL) |
328 | { | 331 | { |
329 | if (0 == memcmp (key, &e->key, sizeof (GNUNET_HashCode))) | 332 | if (0 == memcmp (key, &e->key, sizeof (GNUNET_HashCode))) |
330 | return GNUNET_YES; | 333 | return GNUNET_YES; |
331 | e = e->next; | 334 | e = e->next; |
332 | } | 335 | } |
333 | return GNUNET_NO; | 336 | return GNUNET_NO; |
334 | } | 337 | } |
335 | 338 | ||
@@ -346,20 +349,21 @@ GNUNET_CONTAINER_multihashmap_contains (const struct | |||
346 | */ | 349 | */ |
347 | int | 350 | int |
348 | GNUNET_CONTAINER_multihashmap_contains_value (const struct | 351 | GNUNET_CONTAINER_multihashmap_contains_value (const struct |
349 | GNUNET_CONTAINER_MultiHashMap | 352 | GNUNET_CONTAINER_MultiHashMap |
350 | *map, const GNUNET_HashCode * key, | 353 | *map, |
351 | const void *value) | 354 | const GNUNET_HashCode * key, |
355 | const void *value) | ||
352 | { | 356 | { |
353 | struct MapEntry *e; | 357 | struct MapEntry *e; |
354 | 358 | ||
355 | e = map->map[idx_of (map, key)]; | 359 | e = map->map[idx_of (map, key)]; |
356 | while (e != NULL) | 360 | while (e != NULL) |
357 | { | 361 | { |
358 | if ((0 == memcmp (key, &e->key, sizeof (GNUNET_HashCode))) && | 362 | if ((0 == memcmp (key, &e->key, sizeof (GNUNET_HashCode))) && |
359 | (e->value == value)) | 363 | (e->value == value)) |
360 | return GNUNET_YES; | 364 | return GNUNET_YES; |
361 | e = e->next; | 365 | e = e->next; |
362 | } | 366 | } |
363 | return GNUNET_NO; | 367 | return GNUNET_NO; |
364 | } | 368 | } |
365 | 369 | ||
@@ -387,15 +391,15 @@ grow (struct GNUNET_CONTAINER_MultiHashMap *map) | |||
387 | map->map_length = new_len; | 391 | map->map_length = new_len; |
388 | map->map = new_map; | 392 | map->map = new_map; |
389 | for (i = 0; i < old_len; i++) | 393 | for (i = 0; i < old_len; i++) |
390 | { | ||
391 | while (NULL != (e = old_map[i])) | ||
392 | { | 394 | { |
393 | old_map[i] = e->next; | 395 | while (NULL != (e = old_map[i])) |
394 | idx = idx_of (map, &e->key); | 396 | { |
395 | e->next = new_map[idx]; | 397 | old_map[i] = e->next; |
396 | new_map[idx] = e; | 398 | idx = idx_of (map, &e->key); |
399 | e->next = new_map[idx]; | ||
400 | new_map[idx] = e; | ||
401 | } | ||
397 | } | 402 | } |
398 | } | ||
399 | GNUNET_free (old_map); | 403 | GNUNET_free (old_map); |
400 | } | 404 | } |
401 | 405 | ||
@@ -414,8 +418,9 @@ grow (struct GNUNET_CONTAINER_MultiHashMap *map) | |||
414 | */ | 418 | */ |
415 | int | 419 | int |
416 | GNUNET_CONTAINER_multihashmap_put (struct GNUNET_CONTAINER_MultiHashMap *map, | 420 | GNUNET_CONTAINER_multihashmap_put (struct GNUNET_CONTAINER_MultiHashMap *map, |
417 | const GNUNET_HashCode * key, void *value, | 421 | const GNUNET_HashCode * key, void *value, |
418 | enum GNUNET_CONTAINER_MultiHashMapOption opt) | 422 | enum GNUNET_CONTAINER_MultiHashMapOption |
423 | opt) | ||
419 | { | 424 | { |
420 | struct MapEntry *e; | 425 | struct MapEntry *e; |
421 | unsigned int i; | 426 | unsigned int i; |
@@ -423,25 +428,25 @@ GNUNET_CONTAINER_multihashmap_put (struct GNUNET_CONTAINER_MultiHashMap *map, | |||
423 | i = idx_of (map, key); | 428 | i = idx_of (map, key); |
424 | if ((opt != GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE) && | 429 | if ((opt != GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE) && |
425 | (opt != GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)) | 430 | (opt != GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)) |
426 | { | ||
427 | e = map->map[i]; | ||
428 | while (e != NULL) | ||
429 | { | 431 | { |
430 | if (0 == memcmp (key, &e->key, sizeof (GNUNET_HashCode))) | 432 | e = map->map[i]; |
431 | { | 433 | while (e != NULL) |
432 | if (opt == GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY) | 434 | { |
433 | return GNUNET_SYSERR; | 435 | if (0 == memcmp (key, &e->key, sizeof (GNUNET_HashCode))) |
434 | e->value = value; | 436 | { |
435 | return GNUNET_NO; | 437 | if (opt == GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY) |
436 | } | 438 | return GNUNET_SYSERR; |
437 | e = e->next; | 439 | e->value = value; |
440 | return GNUNET_NO; | ||
441 | } | ||
442 | e = e->next; | ||
443 | } | ||
438 | } | 444 | } |
439 | } | ||
440 | if (map->size / 3 >= map->map_length / 4) | 445 | if (map->size / 3 >= map->map_length / 4) |
441 | { | 446 | { |
442 | grow (map); | 447 | grow (map); |
443 | i = idx_of (map, key); | 448 | i = idx_of (map, key); |
444 | } | 449 | } |
445 | e = GNUNET_malloc (sizeof (struct MapEntry)); | 450 | e = GNUNET_malloc (sizeof (struct MapEntry)); |
446 | e->key = *key; | 451 | e->key = *key; |
447 | e->value = value; | 452 | e->value = value; |
@@ -464,10 +469,10 @@ GNUNET_CONTAINER_multihashmap_put (struct GNUNET_CONTAINER_MultiHashMap *map, | |||
464 | */ | 469 | */ |
465 | int | 470 | int |
466 | GNUNET_CONTAINER_multihashmap_get_multiple (const struct | 471 | GNUNET_CONTAINER_multihashmap_get_multiple (const struct |
467 | GNUNET_CONTAINER_MultiHashMap *map, | 472 | GNUNET_CONTAINER_MultiHashMap |
468 | const GNUNET_HashCode * key, | 473 | *map, const GNUNET_HashCode * key, |
469 | GNUNET_CONTAINER_HashMapIterator it, | 474 | GNUNET_CONTAINER_HashMapIterator |
470 | void *it_cls) | 475 | it, void *it_cls) |
471 | { | 476 | { |
472 | int count; | 477 | int count; |
473 | struct MapEntry *e; | 478 | struct MapEntry *e; |
@@ -476,14 +481,14 @@ GNUNET_CONTAINER_multihashmap_get_multiple (const struct | |||
476 | count = 0; | 481 | count = 0; |
477 | n = map->map[idx_of (map, key)]; | 482 | n = map->map[idx_of (map, key)]; |
478 | while (NULL != (e = n)) | 483 | while (NULL != (e = n)) |
479 | { | 484 | { |
480 | n = e->next; | 485 | n = e->next; |
481 | if (0 != memcmp (key, &e->key, sizeof (GNUNET_HashCode))) | 486 | if (0 != memcmp (key, &e->key, sizeof (GNUNET_HashCode))) |
482 | continue; | 487 | continue; |
483 | if ((it != NULL) && (GNUNET_OK != it (it_cls, key, e->value))) | 488 | if ((it != NULL) && (GNUNET_OK != it (it_cls, key, e->value))) |
484 | return GNUNET_SYSERR; | 489 | return GNUNET_SYSERR; |
485 | count++; | 490 | count++; |
486 | } | 491 | } |
487 | return count; | 492 | return count; |
488 | } | 493 | } |
489 | 494 | ||