/*
This file is part of GNUnet.
- (C) 2008, 2012 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2008, 2012 GNUnet e.V.
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
You should have received a copy of the GNU General Public License
along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
+ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
*/
/**
* @file util/container_multihashmap.c
*/
#include "platform.h"
-#include "gnunet_util_lib.h"
+#include "gnunet_container_lib.h"
-#define LOG(kind,...) GNUNET_log_from (kind, "util", __VA_ARGS__)
+#define LOG(kind,...) GNUNET_log_from (kind, "util-container-multihashmap", __VA_ARGS__)
/**
* An entry in the hash map with the full key.
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
+ * @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
* key-value pairs with value NULL
*/
void *
-GNUNET_CONTAINER_multihashmap_get (const struct GNUNET_CONTAINER_MultiHashMap
- *map, const struct GNUNET_HashCode *key)
+GNUNET_CONTAINER_multihashmap_get (const struct GNUNET_CONTAINER_MultiHashMap *map,
+ const struct GNUNET_HashCode *key)
{
union MapEntry me;
*
* @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
* @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
* @return number of values removed
*/
int
-GNUNET_CONTAINER_multihashmap_remove_all (struct GNUNET_CONTAINER_MultiHashMap
- *map, const struct GNUNET_HashCode *key)
+GNUNET_CONTAINER_multihashmap_remove_all (struct GNUNET_CONTAINER_MultiHashMap *map,
+ const struct GNUNET_HashCode *key)
{
union MapEntry me;
unsigned int i;
sme = map->map[i].sme;
else
sme = p->next;
- ret++;
+ ret++;
}
else
{
}
+/**
+ * Callback used to remove all entries from the map.
+ *
+ * @param cls the `struct GNUNET_CONTAINER_MultiHashMap`
+ * @param key the key
+ * @param value the value
+ * @return #GNUNET_OK (continue to iterate)
+ */
+static int
+remove_all (void *cls,
+ const struct GNUNET_HashCode *key,
+ void *value)
+{
+ struct GNUNET_CONTAINER_MultiHashMap *map = cls;
+
+ GNUNET_CONTAINER_multihashmap_remove (map,
+ key,
+ value);
+ return GNUNET_OK;
+}
+
+
+/**
+ * @ingroup hashmap
+ * Remove all entries from the map.
+ * Note that the values would not be "freed".
+ *
+ * @param map the map
+ * @return number of values removed
+ */
+unsigned int
+GNUNET_CONTAINER_multihashmap_clear (struct GNUNET_CONTAINER_MultiHashMap *map)
+{
+ unsigned int ret;
+
+ ret = map->size;
+ GNUNET_CONTAINER_multihashmap_iterate (map,
+ &remove_all,
+ map);
+ return ret;
+}
+
+
/**
* Check if the map contains any value under the given
* key (including values that are NULL).
*
* @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
* @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
}
+/**
+ * @ingroup hashmap
+ * Call @a it on a random value from the map, or not at all
+ * if the map is empty. Note that this function has linear
+ * complexity (in the size of the map).
+ *
+ * @param map the map
+ * @param it function to call on a random entry
+ * @param it_cls extra argument to @a it
+ * @return the number of key value pairs processed, zero or one.
+ */
+unsigned int
+GNUNET_CONTAINER_multihashmap_get_random (const struct GNUNET_CONTAINER_MultiHashMap *map,
+ GNUNET_CONTAINER_HashMapIterator it,
+ void *it_cls)
+{
+ unsigned int off;
+ unsigned int idx;
+ union MapEntry me;
+
+ if (0 == map->size)
+ return 0;
+ if (NULL == it)
+ return 1;
+ off = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
+ map->size);
+ for (idx = 0; idx < map->map_length; idx++)
+ {
+ me = map->map[idx];
+ if (map->use_small_entries)
+ {
+ struct SmallMapEntry *sme;
+ struct SmallMapEntry *nxt;
+
+ nxt = me.sme;
+ while (NULL != (sme = nxt))
+ {
+ nxt = sme->next;
+ if (0 == off)
+ {
+ if (GNUNET_OK != it (it_cls,
+ sme->key,
+ sme->value))
+ return GNUNET_SYSERR;
+ return 1;
+ }
+ off--;
+ }
+ }
+ else
+ {
+ struct BigMapEntry *bme;
+ struct BigMapEntry *nxt;
+
+ nxt = me.bme;
+ while (NULL != (bme = nxt))
+ {
+ nxt = bme->next;
+ if (0 == off)
+ {
+ if (GNUNET_OK != it (it_cls,
+ &bme->key, bme->value))
+ return GNUNET_SYSERR;
+ return 1;
+ }
+ off--;
+ }
+ }
+ }
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
+}
+
+
/**
* 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, const void **value)
+ struct GNUNET_HashCode *key,
+ const void **value)
{
/* make sure the map has not been modified */
GNUNET_assert (iter->modification_counter == iter->map->modification_counter);
projects / oweals / gnunet.git / blobdiff