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