GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
- by the Free Software Foundation; either version 2, or (at your
+ by the Free Software Foundation; either version 3, or (at your
option) any later version.
GNUnet is distributed in the hope that it will be useful, but
*/
#include "platform.h"
-#include "gnunet_common.h"
-#include "gnunet_container_lib.h"
-#include "gnunet_crypto_lib.h"
+#include "gnunet_util_lib.h"
#define LOG(kind,...) GNUNET_log_from (kind, "util", __VA_ARGS__)
* If there is a hash collision, we create a linked list.
*/
struct SmallMapEntry *next;
-
+
/**
* Key for the entry.
*/
unsigned int map_length;
/**
- * GNUNET_NO if the map entries are of type 'struct BigMapEntry',
- * GNUNET_YES if the map entries are of type 'struct SmallMapEntry'.
+ * #GNUNET_NO if the map entries are of type 'struct BigMapEntry',
+ * #GNUNET_YES if the map entries are of type 'struct SmallMapEntry'.
*/
int use_small_entries;
* Create a multi hash map.
*
* @param len initial size (map will grow as needed)
- * @param do_not_copy_keys GNUNET_NO is always safe and should be used by default;
- * GNUNET_YES means that on 'put', the 'key' does not have
- * to be copied as the destination of the pointer is
+ * @param do_not_copy_keys #GNUNET_NO is always safe and should be used by default;
+ * #GNUNET_YES means that on 'put', the 'key' does not have
+ * to be copied as the destination of the pointer is
* guaranteed to be life as long as the value is stored in
- * the hashmap. This can significantly reduce memory
- * consumption, but of course is also a recipie for
+ * the hashmap. This can significantly reduce memory
+ * consumption, but of course is also a recipie for
* heap corruption if the assumption is not true. Only
* use this if (1) memory use is important in this case and
* (2) you have triple-checked that the invariant holds
struct GNUNET_CONTAINER_MultiHashMap *map;
GNUNET_assert (len > 0);
- map = GNUNET_malloc (sizeof (struct GNUNET_CONTAINER_MultiHashMap));
+ map = GNUNET_new (struct GNUNET_CONTAINER_MultiHashMap);
map->map = GNUNET_malloc (len * sizeof (union MapEntry));
map->map_length = len;
map->use_small_entries = do_not_copy_keys;
*
* @param map the map
* @param it function to call on each entry
- * @param it_cls extra argument to it
+ * @param it_cls extra argument to @a it
* @return the number of key value pairs processed,
- * GNUNET_SYSERR if it aborted iteration
+ * #GNUNET_SYSERR if it aborted iteration
*/
int
GNUNET_CONTAINER_multihashmap_iterate (const struct
struct SmallMapEntry *sme;
struct SmallMapEntry *nxt;
- nxt = me.sme;
+ nxt = me.sme;
while (NULL != (sme = nxt))
{
nxt = sme->next;
struct BigMapEntry *bme;
struct BigMapEntry *nxt;
- nxt = me.bme;
+ nxt = me.bme;
while (NULL != (bme = nxt))
{
nxt = bme->next;
* @param map the map
* @param key key of the key-value pair
* @param value value of the key-value pair
- * @return GNUNET_YES on success, GNUNET_NO if the key-value pair
+ * @return #GNUNET_YES on success, #GNUNET_NO if the key-value pair
* is not in the map
*/
int
GNUNET_CONTAINER_multihashmap_remove (struct GNUNET_CONTAINER_MultiHashMap *map,
- const struct GNUNET_HashCode *key,
+ const struct GNUNET_HashCode *key,
const void *value)
{
union MapEntry me;
i = idx_of (map, key);
me = map->map[i];
if (map->use_small_entries)
- {
+ {
struct SmallMapEntry *sme;
struct SmallMapEntry *p;
i = idx_of (map, key);
me = map->map[i];
if (map->use_small_entries)
- {
+ {
struct SmallMapEntry *sme;
struct SmallMapEntry *p;
sme = map->map[i].sme;
else
sme = p->next;
- ret++;
+ ret++;
}
else
{
*
* @param map the map
* @param key the key to test if a value exists for it
- * @return GNUNET_YES if such a value exists,
- * GNUNET_NO if not
+ * @return #GNUNET_YES if such a value exists,
+ * #GNUNET_NO if not
*/
int
GNUNET_CONTAINER_multihashmap_contains (const struct
* @param map the map
* @param key the key to test if a value exists for it
* @param value value to test for
- * @return GNUNET_YES if such a value exists,
- * GNUNET_NO if not
+ * @return #GNUNET_YES if such a value exists,
+ * #GNUNET_NO if not
*/
int
GNUNET_CONTAINER_multihashmap_contains_value (const struct
struct BigMapEntry *bme;
while (NULL != (bme = old_map[i].bme))
- {
+ {
old_map[i].bme = bme->next;
idx = idx_of (map, &bme->key);
bme->next = new_map[idx].bme;
* @param key key to use
* @param value value to use
* @param opt options for put
- * @return GNUNET_OK on success,
- * GNUNET_NO if a value was replaced (with REPLACE)
- * GNUNET_SYSERR if UNIQUE_ONLY was the option and the
+ * @return #GNUNET_OK on success,
+ * #GNUNET_NO if a value was replaced (with REPLACE)
+ * #GNUNET_SYSERR if UNIQUE_ONLY was the option and the
* value already exists
*/
int
GNUNET_CONTAINER_multihashmap_put (struct GNUNET_CONTAINER_MultiHashMap *map,
- const struct GNUNET_HashCode *key,
+ const struct GNUNET_HashCode *key,
void *value,
enum GNUNET_CONTAINER_MultiHashMapOption opt)
{
{
struct SmallMapEntry *sme;
- for (sme = me.sme; NULL != sme; sme = sme->next)
+ for (sme = me.sme; NULL != sme; sme = sme->next)
if (0 == memcmp (key, sme->key, sizeof (struct GNUNET_HashCode)))
{
if (opt == GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)
{
struct BigMapEntry *bme;
- for (bme = me.bme; NULL != bme; bme = bme->next)
+ for (bme = me.bme; NULL != bme; bme = bme->next)
if (0 == memcmp (key, &bme->key, sizeof (struct GNUNET_HashCode)))
{
if (opt == GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)
if (map->use_small_entries)
{
struct SmallMapEntry *sme;
-
- sme = GNUNET_malloc (sizeof (struct SmallMapEntry));
+
+ sme = GNUNET_new (struct SmallMapEntry);
sme->key = key;
sme->value = value;
sme->next = map->map[i].sme;
else
{
struct BigMapEntry *bme;
-
- bme = GNUNET_malloc (sizeof (struct BigMapEntry));
+
+ bme = GNUNET_new (struct BigMapEntry);
bme->key = *key;
bme->value = value;
bme->next = map->map[i].bme;
* @param it function to call on each entry
* @param it_cls extra argument to it
* @return the number of key value pairs processed,
- * GNUNET_SYSERR if it aborted iteration
+ * #GNUNET_SYSERR if it aborted iteration
*/
int
GNUNET_CONTAINER_multihashmap_get_multiple (const struct
me = map->map[idx_of (map, key)];
if (map->use_small_entries)
{
- struct SmallMapEntry *sme;
+ struct SmallMapEntry *sme;
struct SmallMapEntry *nxt;
-
+
nxt = me.sme;
while (NULL != (sme = nxt))
{
}
else
{
- struct BigMapEntry *bme;
+ struct BigMapEntry *bme;
struct BigMapEntry *nxt;
-
+
nxt = me.bme;
while (NULL != (bme = nxt))
{
* Create an iterator for a multihashmap.
* The iterator can be used to retrieve all the elements in the multihashmap
* one by one, without having to handle all elements at once (in contrast to
- * 'GNUNET_CONTAINER_multihashmap_iterate'). Note that the iterator can not be
+ * GNUNET_CONTAINER_multihashmap_iterate()). Note that the iterator can not be
* used anymore if elements have been removed from 'map' after the creation of
* the iterator, or 'map' has been destroyed. Adding elements to 'map' may
* result in skipped or repeated elements.
* @param iter the iterator to get the next element from
* @param key pointer to store the key in, can be NULL
* @param value pointer to store the value in, can be NULL
- * @return GNUNET_YES we returned an element,
- * GNUNET_NO if we are out of elements
+ * @return #GNUNET_YES we returned an element,
+ * #GNUNET_NO if we are out of elements
*/
int
GNUNET_CONTAINER_multihashmap_iterator_next (struct GNUNET_CONTAINER_MultiHashMapIterator *iter,
- struct GNUNET_HashCode *key, void **value)
+ struct GNUNET_HashCode *key,
+ const void **value)
{
- /* make sure nobody modified the map */
+ /* make sure the map has not been modified */
GNUNET_assert (iter->modification_counter == iter->map->modification_counter);
/* look for the next entry, skipping empty buckets */
return GNUNET_YES;
}
}
- iter->idx++;
+ iter->idx += 1;
+ if (iter->idx < iter->map->map_length)
+ iter->me = iter->map->map[iter->idx];
}
}
* @param iter the iterator to destroy
*/
void
-GNUNET_CONTAINER_multihashmap_enumerator_destroy (struct GNUNET_CONTAINER_MultiHashMapIterator *iter)
+GNUNET_CONTAINER_multihashmap_iterator_destroy (struct GNUNET_CONTAINER_MultiHashMapIterator *iter)
{
GNUNET_free (iter);
}
projects / oweals / gnunet.git / blobdiff