along with this program. If not, see <http://www.gnu.org/licenses/>.
SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
/**
* @author Christian Grothoff
* #GNUNET_NO if compression did not help
*/
int
-GNUNET_try_compression (const char *data,
- size_t old_size,
- char **result,
- size_t *new_size);
+GNUNET_try_compression(const char *data,
+ size_t old_size,
+ char **result,
+ size_t *new_size);
/**
* @return NULL on error, buffer of @a output_size decompressed bytes otherwise
*/
char *
-GNUNET_decompress (const char *input, size_t input_size, size_t output_size);
+GNUNET_decompress(const char *input, size_t input_size, size_t output_size);
#if HAVE_EXTRACTOR_H
* Enumeration defining various sources of keywords. See also
* http://dublincore.org/documents/1998/09/dces/
*/
-enum EXTRACTOR_MetaType
-{
+enum EXTRACTOR_MetaType {
EXTRACTOR_METATYPE_RESERVED = 0,
EXTRACTOR_METATYPE_MIMETYPE = 1,
EXTRACTOR_METATYPE_FILENAME = 2,
EXTRACTOR_METATYPE_ORIGINAL_TITLE = 162,
EXTRACTOR_METATYPE_GNUNET_FULL_DATA = 174,
EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME = 180,
-
};
/**
* Format in which the extracted meta data is presented.
*/
-enum EXTRACTOR_MetaFormat
-{
+enum EXTRACTOR_MetaFormat {
/**
* Format is unknown.
*/
* @return the bloomfilter
*/
struct GNUNET_CONTAINER_BloomFilter *
-GNUNET_CONTAINER_bloomfilter_load (const char *filename,
- size_t size,
- unsigned int k);
+GNUNET_CONTAINER_bloomfilter_load(const char *filename,
+ size_t size,
+ unsigned int k);
/**
* @return the bloomfilter
*/
struct GNUNET_CONTAINER_BloomFilter *
-GNUNET_CONTAINER_bloomfilter_init (const char *data,
- size_t size,
- unsigned int k);
+GNUNET_CONTAINER_bloomfilter_init(const char *data,
+ size_t size,
+ unsigned int k);
/**
* @return #GNUNET_SYSERR if the data array of the wrong size
*/
int
-GNUNET_CONTAINER_bloomfilter_get_raw_data (
+GNUNET_CONTAINER_bloomfilter_get_raw_data(
const struct GNUNET_CONTAINER_BloomFilter *bf,
char *data,
size_t size);
* @return #GNUNET_YES if the element is in the filter, #GNUNET_NO if not
*/
int
-GNUNET_CONTAINER_bloomfilter_test (
+GNUNET_CONTAINER_bloomfilter_test(
const struct GNUNET_CONTAINER_BloomFilter *bf,
const struct GNUNET_HashCode *e);
* @param e the element
*/
void
-GNUNET_CONTAINER_bloomfilter_add (struct GNUNET_CONTAINER_BloomFilter *bf,
- const struct GNUNET_HashCode *e);
+GNUNET_CONTAINER_bloomfilter_add(struct GNUNET_CONTAINER_BloomFilter *bf,
+ const struct GNUNET_HashCode *e);
/**
* @param e the element to remove
*/
void
-GNUNET_CONTAINER_bloomfilter_remove (struct GNUNET_CONTAINER_BloomFilter *bf,
- const struct GNUNET_HashCode *e);
+GNUNET_CONTAINER_bloomfilter_remove(struct GNUNET_CONTAINER_BloomFilter *bf,
+ const struct GNUNET_HashCode *e);
/**
* @return copy of bf
*/
struct GNUNET_CONTAINER_BloomFilter *
-GNUNET_CONTAINER_bloomfilter_copy (
+GNUNET_CONTAINER_bloomfilter_copy(
const struct GNUNET_CONTAINER_BloomFilter *bf);
* @param bf the filter
*/
void
-GNUNET_CONTAINER_bloomfilter_free (struct GNUNET_CONTAINER_BloomFilter *bf);
+GNUNET_CONTAINER_bloomfilter_free(struct GNUNET_CONTAINER_BloomFilter *bf);
/**
* @return addresses set per element in the bf
*/
size_t
-GNUNET_CONTAINER_bloomfilter_get_element_addresses (
+GNUNET_CONTAINER_bloomfilter_get_element_addresses(
const struct GNUNET_CONTAINER_BloomFilter *bf);
* @return number of bytes used for the data of the bloom filter
*/
size_t
-GNUNET_CONTAINER_bloomfilter_get_size (
+GNUNET_CONTAINER_bloomfilter_get_size(
const struct GNUNET_CONTAINER_BloomFilter *bf);
* @param bf the filter
*/
void
-GNUNET_CONTAINER_bloomfilter_clear (struct GNUNET_CONTAINER_BloomFilter *bf);
+GNUNET_CONTAINER_bloomfilter_clear(struct GNUNET_CONTAINER_BloomFilter *bf);
/**
* @return #GNUNET_OK on success
*/
int
-GNUNET_CONTAINER_bloomfilter_or (struct GNUNET_CONTAINER_BloomFilter *bf,
- const char *data,
- size_t size);
+GNUNET_CONTAINER_bloomfilter_or(struct GNUNET_CONTAINER_BloomFilter *bf,
+ const char *data,
+ size_t size);
/**
* @return #GNUNET_OK on success
*/
int
-GNUNET_CONTAINER_bloomfilter_or2 (
+GNUNET_CONTAINER_bloomfilter_or2(
struct GNUNET_CONTAINER_BloomFilter *bf,
const struct GNUNET_CONTAINER_BloomFilter *to_or);
* @param k the new number of #GNUNET_CRYPTO_hash-function to apply per element
*/
void
-GNUNET_CONTAINER_bloomfilter_resize (struct GNUNET_CONTAINER_BloomFilter *bf,
- GNUNET_CONTAINER_HashCodeIterator iterator,
- void *iterator_cls,
- size_t size,
- unsigned int k);
+GNUNET_CONTAINER_bloomfilter_resize(struct GNUNET_CONTAINER_BloomFilter *bf,
+ GNUNET_CONTAINER_HashCodeIterator iterator,
+ void *iterator_cls,
+ size_t size,
+ unsigned int k);
/* ****************** metadata ******************* */
* @return empty meta-data container
*/
struct GNUNET_CONTAINER_MetaData *
-GNUNET_CONTAINER_meta_data_create (void);
+GNUNET_CONTAINER_meta_data_create(void);
/**
* @return duplicate meta-data container
*/
struct GNUNET_CONTAINER_MetaData *
-GNUNET_CONTAINER_meta_data_duplicate (
+GNUNET_CONTAINER_meta_data_duplicate(
const struct GNUNET_CONTAINER_MetaData *md);
* @param md what to free
*/
void
-GNUNET_CONTAINER_meta_data_destroy (struct GNUNET_CONTAINER_MetaData *md);
+GNUNET_CONTAINER_meta_data_destroy(struct GNUNET_CONTAINER_MetaData *md);
/**
* @return #GNUNET_YES if they are equal
*/
int
-GNUNET_CONTAINER_meta_data_test_equal (
+GNUNET_CONTAINER_meta_data_test_equal(
const struct GNUNET_CONTAINER_MetaData *md1,
const struct GNUNET_CONTAINER_MetaData *md2);
* data_mime_type and plugin_name are not considered for "exists" checks
*/
int
-GNUNET_CONTAINER_meta_data_insert (struct GNUNET_CONTAINER_MetaData *md,
- const char *plugin_name,
- enum EXTRACTOR_MetaType type,
- enum EXTRACTOR_MetaFormat format,
- const char *data_mime_type,
- const char *data,
- size_t data_size);
+GNUNET_CONTAINER_meta_data_insert(struct GNUNET_CONTAINER_MetaData *md,
+ const char *plugin_name,
+ enum EXTRACTOR_MetaType type,
+ enum EXTRACTOR_MetaFormat format,
+ const char *data_mime_type,
+ const char *data,
+ size_t data_size);
/**
* @param in metadata to merge
*/
void
-GNUNET_CONTAINER_meta_data_merge (struct GNUNET_CONTAINER_MetaData *md,
- const struct GNUNET_CONTAINER_MetaData *in);
+GNUNET_CONTAINER_meta_data_merge(struct GNUNET_CONTAINER_MetaData *md,
+ const struct GNUNET_CONTAINER_MetaData *in);
/**
* @return #GNUNET_OK on success, #GNUNET_SYSERR if the item does not exist in md
*/
int
-GNUNET_CONTAINER_meta_data_delete (struct GNUNET_CONTAINER_MetaData *md,
- enum EXTRACTOR_MetaType type,
- const char *data,
- size_t data_size);
+GNUNET_CONTAINER_meta_data_delete(struct GNUNET_CONTAINER_MetaData *md,
+ enum EXTRACTOR_MetaType type,
+ const char *data,
+ size_t data_size);
/**
* @param md metadata to manipulate
*/
void
-GNUNET_CONTAINER_meta_data_clear (struct GNUNET_CONTAINER_MetaData *md);
+GNUNET_CONTAINER_meta_data_clear(struct GNUNET_CONTAINER_MetaData *md);
/**
* @param md metadata to modify
*/
void
-GNUNET_CONTAINER_meta_data_add_publication_date (
+GNUNET_CONTAINER_meta_data_add_publication_date(
struct GNUNET_CONTAINER_MetaData *md);
* @return number of entries
*/
int
-GNUNET_CONTAINER_meta_data_iterate (const struct GNUNET_CONTAINER_MetaData *md,
- EXTRACTOR_MetaDataProcessor iter,
- void *iter_cls);
+GNUNET_CONTAINER_meta_data_iterate(const struct GNUNET_CONTAINER_MetaData *md,
+ EXTRACTOR_MetaDataProcessor iter,
+ void *iter_cls);
/**
* @return NULL if no entry was found
*/
char *
-GNUNET_CONTAINER_meta_data_get_by_type (
+GNUNET_CONTAINER_meta_data_get_by_type(
const struct GNUNET_CONTAINER_MetaData *md,
enum EXTRACTOR_MetaType type);
* otherwise client is responsible for freeing the value!
*/
char *
-GNUNET_CONTAINER_meta_data_get_first_by_types (
+GNUNET_CONTAINER_meta_data_get_first_by_types(
const struct GNUNET_CONTAINER_MetaData *md,
...);
* @return number of bytes in thumbnail, 0 if not available
*/
size_t
-GNUNET_CONTAINER_meta_data_get_thumbnail (
+GNUNET_CONTAINER_meta_data_get_thumbnail(
const struct GNUNET_CONTAINER_MetaData *md,
unsigned char **thumb);
* @ingroup metadata
* Options for metadata serialization.
*/
-enum GNUNET_CONTAINER_MetaDataSerializationOptions
-{
+enum GNUNET_CONTAINER_MetaDataSerializationOptions {
/**
* @ingroup metadata
* Serialize all of the data.
* space)
*/
ssize_t
-GNUNET_CONTAINER_meta_data_serialize (
+GNUNET_CONTAINER_meta_data_serialize(
const struct GNUNET_CONTAINER_MetaData *md,
char **target,
size_t max,
* @return number of bytes needed for serialization, -1 on error
*/
ssize_t
-GNUNET_CONTAINER_meta_data_get_serialized_size (
+GNUNET_CONTAINER_meta_data_get_serialized_size(
const struct GNUNET_CONTAINER_MetaData *md);
* bad format)
*/
struct GNUNET_CONTAINER_MetaData *
-GNUNET_CONTAINER_meta_data_deserialize (const char *input, size_t size);
+GNUNET_CONTAINER_meta_data_deserialize(const char *input, size_t size);
/* ******************************* HashMap **************************** */
* @ingroup hashmap
* Options for storing values in the HashMap.
*/
-enum GNUNET_CONTAINER_MultiHashMapOption
-{
-
+enum GNUNET_CONTAINER_MultiHashMapOption {
/**
* @ingroup hashmap
* If a value with the given key exists, replace it. Note that the
* @return NULL on error
*/
struct GNUNET_CONTAINER_MultiHashMap *
-GNUNET_CONTAINER_multihashmap_create (unsigned int len, int do_not_copy_keys);
+GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys);
/**
* @param map the map
*/
void
-GNUNET_CONTAINER_multihashmap_destroy (
+GNUNET_CONTAINER_multihashmap_destroy(
struct GNUNET_CONTAINER_MultiHashMap *map);
* key-value pairs with value NULL
*/
void *
-GNUNET_CONTAINER_multihashmap_get (
+GNUNET_CONTAINER_multihashmap_get(
const struct GNUNET_CONTAINER_MultiHashMap *map,
const struct GNUNET_HashCode *key);
* is not in the map
*/
int
-GNUNET_CONTAINER_multihashmap_remove (struct GNUNET_CONTAINER_MultiHashMap *map,
- const struct GNUNET_HashCode *key,
- const void *value);
+GNUNET_CONTAINER_multihashmap_remove(struct GNUNET_CONTAINER_MultiHashMap *map,
+ const struct GNUNET_HashCode *key,
+ const void *value);
/**
* @ingroup hashmap
* @return number of values removed
*/
int
-GNUNET_CONTAINER_multihashmap_remove_all (
+GNUNET_CONTAINER_multihashmap_remove_all(
struct GNUNET_CONTAINER_MultiHashMap *map,
const struct GNUNET_HashCode *key);
* @return number of values removed
*/
unsigned int
-GNUNET_CONTAINER_multihashmap_clear (struct GNUNET_CONTAINER_MultiHashMap *map);
+GNUNET_CONTAINER_multihashmap_clear(struct GNUNET_CONTAINER_MultiHashMap *map);
/**
* #GNUNET_NO if not
*/
int
-GNUNET_CONTAINER_multihashmap_contains (
+GNUNET_CONTAINER_multihashmap_contains(
const struct GNUNET_CONTAINER_MultiHashMap *map,
const struct GNUNET_HashCode *key);
* #GNUNET_NO if not
*/
int
-GNUNET_CONTAINER_multihashmap_contains_value (
+GNUNET_CONTAINER_multihashmap_contains_value(
const struct GNUNET_CONTAINER_MultiHashMap *map,
const struct GNUNET_HashCode *key,
const void *value);
* value already exists
*/
int
-GNUNET_CONTAINER_multihashmap_put (
+GNUNET_CONTAINER_multihashmap_put(
struct GNUNET_CONTAINER_MultiHashMap *map,
const struct GNUNET_HashCode *key,
void *value,
* @return the number of key value pairs
*/
unsigned int
-GNUNET_CONTAINER_multihashmap_size (
+GNUNET_CONTAINER_multihashmap_size(
const struct GNUNET_CONTAINER_MultiHashMap *map);
* #GNUNET_SYSERR if it aborted iteration
*/
int
-GNUNET_CONTAINER_multihashmap_iterate (
+GNUNET_CONTAINER_multihashmap_iterate(
struct GNUNET_CONTAINER_MultiHashMap *map,
GNUNET_CONTAINER_MulitHashMapIteratorCallback it,
void *it_cls);
* @return an iterator over the given multihashmap @a map
*/
struct GNUNET_CONTAINER_MultiHashMapIterator *
-GNUNET_CONTAINER_multihashmap_iterator_create (
+GNUNET_CONTAINER_multihashmap_iterator_create(
const struct GNUNET_CONTAINER_MultiHashMap *map);
* #GNUNET_NO if we are out of elements
*/
int
-GNUNET_CONTAINER_multihashmap_iterator_next (
+GNUNET_CONTAINER_multihashmap_iterator_next(
struct GNUNET_CONTAINER_MultiHashMapIterator *iter,
struct GNUNET_HashCode *key,
const void **value);
* @param iter the iterator to destroy
*/
void
-GNUNET_CONTAINER_multihashmap_iterator_destroy (
+GNUNET_CONTAINER_multihashmap_iterator_destroy(
struct GNUNET_CONTAINER_MultiHashMapIterator *iter);
* #GNUNET_SYSERR if it aborted iteration
*/
int
-GNUNET_CONTAINER_multihashmap_get_multiple (
+GNUNET_CONTAINER_multihashmap_get_multiple(
struct GNUNET_CONTAINER_MultiHashMap *map,
const struct GNUNET_HashCode *key,
GNUNET_CONTAINER_MulitHashMapIteratorCallback it,
* @return the number of key value pairs processed, zero or one.
*/
unsigned int
-GNUNET_CONTAINER_multihashmap_get_random (
+GNUNET_CONTAINER_multihashmap_get_random(
const struct GNUNET_CONTAINER_MultiHashMap *map,
GNUNET_CONTAINER_MulitHashMapIteratorCallback it,
void *it_cls);
* @return NULL on error
*/
struct GNUNET_CONTAINER_MultiPeerMap *
-GNUNET_CONTAINER_multipeermap_create (unsigned int len, int do_not_copy_keys);
+GNUNET_CONTAINER_multipeermap_create(unsigned int len, int do_not_copy_keys);
/**
* @param map the map
*/
void
-GNUNET_CONTAINER_multipeermap_destroy (
+GNUNET_CONTAINER_multipeermap_destroy(
struct GNUNET_CONTAINER_MultiPeerMap *map);
* key-value pairs with value NULL
*/
void *
-GNUNET_CONTAINER_multipeermap_get (
+GNUNET_CONTAINER_multipeermap_get(
const struct GNUNET_CONTAINER_MultiPeerMap *map,
const struct GNUNET_PeerIdentity *key);
* is not in the map
*/
int
-GNUNET_CONTAINER_multipeermap_remove (struct GNUNET_CONTAINER_MultiPeerMap *map,
- const struct GNUNET_PeerIdentity *key,
- const void *value);
+GNUNET_CONTAINER_multipeermap_remove(struct GNUNET_CONTAINER_MultiPeerMap *map,
+ const struct GNUNET_PeerIdentity *key,
+ const void *value);
/**
* @ingroup hashmap
* @return number of values removed
*/
int
-GNUNET_CONTAINER_multipeermap_remove_all (
+GNUNET_CONTAINER_multipeermap_remove_all(
struct GNUNET_CONTAINER_MultiPeerMap *map,
const struct GNUNET_PeerIdentity *key);
* #GNUNET_NO if not
*/
int
-GNUNET_CONTAINER_multipeermap_contains (
+GNUNET_CONTAINER_multipeermap_contains(
const struct GNUNET_CONTAINER_MultiPeerMap *map,
const struct GNUNET_PeerIdentity *key);
* #GNUNET_NO if not
*/
int
-GNUNET_CONTAINER_multipeermap_contains_value (
+GNUNET_CONTAINER_multipeermap_contains_value(
const struct GNUNET_CONTAINER_MultiPeerMap *map,
const struct GNUNET_PeerIdentity *key,
const void *value);
* value already exists
*/
int
-GNUNET_CONTAINER_multipeermap_put (
+GNUNET_CONTAINER_multipeermap_put(
struct GNUNET_CONTAINER_MultiPeerMap *map,
const struct GNUNET_PeerIdentity *key,
void *value,
* @return the number of key value pairs
*/
unsigned int
-GNUNET_CONTAINER_multipeermap_size (
+GNUNET_CONTAINER_multipeermap_size(
const struct GNUNET_CONTAINER_MultiPeerMap *map);
* #GNUNET_SYSERR if it aborted iteration
*/
int
-GNUNET_CONTAINER_multipeermap_iterate (
+GNUNET_CONTAINER_multipeermap_iterate(
struct GNUNET_CONTAINER_MultiPeerMap *map,
GNUNET_CONTAINER_PeerMapIterator it,
void *it_cls);
* @return an iterator over the given multihashmap @a map
*/
struct GNUNET_CONTAINER_MultiPeerMapIterator *
-GNUNET_CONTAINER_multipeermap_iterator_create (
+GNUNET_CONTAINER_multipeermap_iterator_create(
const struct GNUNET_CONTAINER_MultiPeerMap *map);
* #GNUNET_NO if we are out of elements
*/
int
-GNUNET_CONTAINER_multipeermap_iterator_next (
+GNUNET_CONTAINER_multipeermap_iterator_next(
struct GNUNET_CONTAINER_MultiPeerMapIterator *iter,
struct GNUNET_PeerIdentity *key,
const void **value);
* @param iter the iterator to destroy
*/
void
-GNUNET_CONTAINER_multipeermap_iterator_destroy (
+GNUNET_CONTAINER_multipeermap_iterator_destroy(
struct GNUNET_CONTAINER_MultiPeerMapIterator *iter);
* #GNUNET_SYSERR if it aborted iteration
*/
int
-GNUNET_CONTAINER_multipeermap_get_multiple (
+GNUNET_CONTAINER_multipeermap_get_multiple(
struct GNUNET_CONTAINER_MultiPeerMap *map,
const struct GNUNET_PeerIdentity *key,
GNUNET_CONTAINER_PeerMapIterator it,
* @return the number of key value pairs processed, zero or one.
*/
unsigned int
-GNUNET_CONTAINER_multipeermap_get_random (
+GNUNET_CONTAINER_multipeermap_get_random(
const struct GNUNET_CONTAINER_MultiPeerMap *map,
GNUNET_CONTAINER_PeerMapIterator it,
void *it_cls);
* @return NULL on error
*/
struct GNUNET_CONTAINER_MultiShortmap *
-GNUNET_CONTAINER_multishortmap_create (unsigned int len, int do_not_copy_keys);
+GNUNET_CONTAINER_multishortmap_create(unsigned int len, int do_not_copy_keys);
/**
* @param map the map
*/
void
-GNUNET_CONTAINER_multishortmap_destroy (
+GNUNET_CONTAINER_multishortmap_destroy(
struct GNUNET_CONTAINER_MultiShortmap *map);
* key-value pairs with value NULL
*/
void *
-GNUNET_CONTAINER_multishortmap_get (
+GNUNET_CONTAINER_multishortmap_get(
const struct GNUNET_CONTAINER_MultiShortmap *map,
const struct GNUNET_ShortHashCode *key);
* is not in the map
*/
int
-GNUNET_CONTAINER_multishortmap_remove (
+GNUNET_CONTAINER_multishortmap_remove(
struct GNUNET_CONTAINER_MultiShortmap *map,
const struct GNUNET_ShortHashCode *key,
const void *value);
* @return number of values removed
*/
int
-GNUNET_CONTAINER_multishortmap_remove_all (
+GNUNET_CONTAINER_multishortmap_remove_all(
struct GNUNET_CONTAINER_MultiShortmap *map,
const struct GNUNET_ShortHashCode *key);
* #GNUNET_NO if not
*/
int
-GNUNET_CONTAINER_multishortmap_contains (
+GNUNET_CONTAINER_multishortmap_contains(
const struct GNUNET_CONTAINER_MultiShortmap *map,
const struct GNUNET_ShortHashCode *key);
* #GNUNET_NO if not
*/
int
-GNUNET_CONTAINER_multishortmap_contains_value (
+GNUNET_CONTAINER_multishortmap_contains_value(
const struct GNUNET_CONTAINER_MultiShortmap *map,
const struct GNUNET_ShortHashCode *key,
const void *value);
* value already exists
*/
int
-GNUNET_CONTAINER_multishortmap_put (
+GNUNET_CONTAINER_multishortmap_put(
struct GNUNET_CONTAINER_MultiShortmap *map,
const struct GNUNET_ShortHashCode *key,
void *value,
* @return the number of key value pairs
*/
unsigned int
-GNUNET_CONTAINER_multishortmap_size (
+GNUNET_CONTAINER_multishortmap_size(
const struct GNUNET_CONTAINER_MultiShortmap *map);
* #GNUNET_SYSERR if it aborted iteration
*/
int
-GNUNET_CONTAINER_multishortmap_iterate (
+GNUNET_CONTAINER_multishortmap_iterate(
struct GNUNET_CONTAINER_MultiShortmap *map,
GNUNET_CONTAINER_ShortmapIterator it,
void *it_cls);
* @return an iterator over the given multihashmap @a map
*/
struct GNUNET_CONTAINER_MultiShortmapIterator *
-GNUNET_CONTAINER_multishortmap_iterator_create (
+GNUNET_CONTAINER_multishortmap_iterator_create(
const struct GNUNET_CONTAINER_MultiShortmap *map);
* #GNUNET_NO if we are out of elements
*/
int
-GNUNET_CONTAINER_multishortmap_iterator_next (
+GNUNET_CONTAINER_multishortmap_iterator_next(
struct GNUNET_CONTAINER_MultiShortmapIterator *iter,
struct GNUNET_ShortHashCode *key,
const void **value);
* @param iter the iterator to destroy
*/
void
-GNUNET_CONTAINER_multishortmap_iterator_destroy (
+GNUNET_CONTAINER_multishortmap_iterator_destroy(
struct GNUNET_CONTAINER_MultiShortmapIterator *iter);
* #GNUNET_SYSERR if it aborted iteration
*/
int
-GNUNET_CONTAINER_multishortmap_get_multiple (
+GNUNET_CONTAINER_multishortmap_get_multiple(
struct GNUNET_CONTAINER_MultiShortmap *map,
const struct GNUNET_ShortHashCode *key,
GNUNET_CONTAINER_ShortmapIterator it,
* @return the number of key value pairs processed, zero or one.
*/
unsigned int
-GNUNET_CONTAINER_multishortmap_get_random (
+GNUNET_CONTAINER_multishortmap_get_random(
const struct GNUNET_CONTAINER_MultiShortmap *map,
GNUNET_CONTAINER_ShortmapIterator it,
void *it_cls);
* @return NULL on error
*/
struct GNUNET_CONTAINER_MultiUuidmap *
-GNUNET_CONTAINER_multiuuidmap_create (unsigned int len, int do_not_copy_keys);
+GNUNET_CONTAINER_multiuuidmap_create(unsigned int len, int do_not_copy_keys);
/**
* @param map the map
*/
void
-GNUNET_CONTAINER_multiuuidmap_destroy (
+GNUNET_CONTAINER_multiuuidmap_destroy(
struct GNUNET_CONTAINER_MultiUuidmap *map);
* key-value pairs with value NULL
*/
void *
-GNUNET_CONTAINER_multiuuidmap_get (
+GNUNET_CONTAINER_multiuuidmap_get(
const struct GNUNET_CONTAINER_MultiUuidmap *map,
const struct GNUNET_Uuid *key);
* is not in the map
*/
int
-GNUNET_CONTAINER_multiuuidmap_remove (struct GNUNET_CONTAINER_MultiUuidmap *map,
- const struct GNUNET_Uuid *key,
- const void *value);
+GNUNET_CONTAINER_multiuuidmap_remove(struct GNUNET_CONTAINER_MultiUuidmap *map,
+ const struct GNUNET_Uuid *key,
+ const void *value);
/**
* @ingroup hashmap
* @return number of values removed
*/
int
-GNUNET_CONTAINER_multiuuidmap_remove_all (
+GNUNET_CONTAINER_multiuuidmap_remove_all(
struct GNUNET_CONTAINER_MultiUuidmap *map,
const struct GNUNET_Uuid *key);
* #GNUNET_NO if not
*/
int
-GNUNET_CONTAINER_multiuuidmap_contains (
+GNUNET_CONTAINER_multiuuidmap_contains(
const struct GNUNET_CONTAINER_MultiUuidmap *map,
const struct GNUNET_Uuid *key);
* #GNUNET_NO if not
*/
int
-GNUNET_CONTAINER_multiuuidmap_contains_value (
+GNUNET_CONTAINER_multiuuidmap_contains_value(
const struct GNUNET_CONTAINER_MultiUuidmap *map,
const struct GNUNET_Uuid *key,
const void *value);
* value already exists
*/
int
-GNUNET_CONTAINER_multiuuidmap_put (
+GNUNET_CONTAINER_multiuuidmap_put(
struct GNUNET_CONTAINER_MultiUuidmap *map,
const struct GNUNET_Uuid *key,
void *value,
* @return the number of key value pairs
*/
unsigned int
-GNUNET_CONTAINER_multiuuidmap_size (
+GNUNET_CONTAINER_multiuuidmap_size(
const struct GNUNET_CONTAINER_MultiUuidmap *map);
* #GNUNET_SYSERR if it aborted iteration
*/
int
-GNUNET_CONTAINER_multiuuidmap_iterate (
+GNUNET_CONTAINER_multiuuidmap_iterate(
struct GNUNET_CONTAINER_MultiUuidmap *map,
GNUNET_CONTAINER_MultiUuidmapIteratorCallback it,
void *it_cls);
* @return an iterator over the given multihashmap @a map
*/
struct GNUNET_CONTAINER_MultiUuidmapIterator *
-GNUNET_CONTAINER_multiuuidmap_iterator_create (
+GNUNET_CONTAINER_multiuuidmap_iterator_create(
const struct GNUNET_CONTAINER_MultiUuidmap *map);
* #GNUNET_NO if we are out of elements
*/
int
-GNUNET_CONTAINER_multiuuidmap_iterator_next (
+GNUNET_CONTAINER_multiuuidmap_iterator_next(
struct GNUNET_CONTAINER_MultiUuidmapIterator *iter,
struct GNUNET_Uuid *key,
const void **value);
* @param iter the iterator to destroy
*/
void
-GNUNET_CONTAINER_multiuuidmap_iterator_destroy (
+GNUNET_CONTAINER_multiuuidmap_iterator_destroy(
struct GNUNET_CONTAINER_MultiUuidmapIterator *iter);
* #GNUNET_SYSERR if it aborted iteration
*/
int
-GNUNET_CONTAINER_multiuuidmap_get_multiple (
+GNUNET_CONTAINER_multiuuidmap_get_multiple(
struct GNUNET_CONTAINER_MultiUuidmap *map,
const struct GNUNET_Uuid *key,
GNUNET_CONTAINER_MultiUuidmapIteratorCallback it,
* @return the number of key value pairs processed, zero or one.
*/
unsigned int
-GNUNET_CONTAINER_multiuuidmap_get_random (
+GNUNET_CONTAINER_multiuuidmap_get_random(
const struct GNUNET_CONTAINER_MultiUuidmap *map,
GNUNET_CONTAINER_MultiUuidmapIteratorCallback it,
void *it_cls);
* @return NULL on error
*/
struct GNUNET_CONTAINER_MultiHashMap32 *
-GNUNET_CONTAINER_multihashmap32_create (unsigned int len);
+GNUNET_CONTAINER_multihashmap32_create(unsigned int len);
/**
* @param map the map
*/
void
-GNUNET_CONTAINER_multihashmap32_destroy (
+GNUNET_CONTAINER_multihashmap32_destroy(
struct GNUNET_CONTAINER_MultiHashMap32 *map);
* @return the number of key value pairs
*/
unsigned int
-GNUNET_CONTAINER_multihashmap32_size (
+GNUNET_CONTAINER_multihashmap32_size(
const struct GNUNET_CONTAINER_MultiHashMap32 *map);
* key-value pairs with value NULL
*/
void *
-GNUNET_CONTAINER_multihashmap32_get (
+GNUNET_CONTAINER_multihashmap32_get(
const struct GNUNET_CONTAINER_MultiHashMap32 *map,
uint32_t key);
* #GNUNET_SYSERR if it aborted iteration
*/
int
-GNUNET_CONTAINER_multihashmap32_iterate (
+GNUNET_CONTAINER_multihashmap32_iterate(
struct GNUNET_CONTAINER_MultiHashMap32 *map,
GNUNET_CONTAINER_MulitHashMapIterator32Callback it,
void *it_cls);
* is not in the map
*/
int
-GNUNET_CONTAINER_multihashmap32_remove (
+GNUNET_CONTAINER_multihashmap32_remove(
struct GNUNET_CONTAINER_MultiHashMap32 *map,
uint32_t key,
const void *value);
* @return number of values removed
*/
int
-GNUNET_CONTAINER_multihashmap32_remove_all (
+GNUNET_CONTAINER_multihashmap32_remove_all(
struct GNUNET_CONTAINER_MultiHashMap32 *map,
uint32_t key);
* #GNUNET_NO if not
*/
int
-GNUNET_CONTAINER_multihashmap32_contains (
+GNUNET_CONTAINER_multihashmap32_contains(
const struct GNUNET_CONTAINER_MultiHashMap32 *map,
uint32_t key);
* #GNUNET_NO if not
*/
int
-GNUNET_CONTAINER_multihashmap32_contains_value (
+GNUNET_CONTAINER_multihashmap32_contains_value(
const struct GNUNET_CONTAINER_MultiHashMap32 *map,
uint32_t key,
const void *value);
* value already exists
*/
int
-GNUNET_CONTAINER_multihashmap32_put (
+GNUNET_CONTAINER_multihashmap32_put(
struct GNUNET_CONTAINER_MultiHashMap32 *map,
uint32_t key,
void *value,
* #GNUNET_SYSERR if it aborted iteration
*/
int
-GNUNET_CONTAINER_multihashmap32_get_multiple (
+GNUNET_CONTAINER_multihashmap32_get_multiple(
struct GNUNET_CONTAINER_MultiHashMap32 *map,
uint32_t key,
GNUNET_CONTAINER_MulitHashMapIterator32Callback it,
* @return an iterator over the given multihashmap map
*/
struct GNUNET_CONTAINER_MultiHashMap32Iterator *
-GNUNET_CONTAINER_multihashmap32_iterator_create (
+GNUNET_CONTAINER_multihashmap32_iterator_create(
const struct GNUNET_CONTAINER_MultiHashMap32 *map);
* #GNUNET_NO if we are out of elements
*/
int
-GNUNET_CONTAINER_multihashmap32_iterator_next (
+GNUNET_CONTAINER_multihashmap32_iterator_next(
struct GNUNET_CONTAINER_MultiHashMap32Iterator *iter,
uint32_t *key,
const void **value);
* @param iter the iterator to destroy
*/
void
-GNUNET_CONTAINER_multihashmap32_iterator_destroy (
+GNUNET_CONTAINER_multihashmap32_iterator_destroy(
struct GNUNET_CONTAINER_MultiHashMapIterator *iter);
*/
#define GNUNET_CONTAINER_DLL_insert(head, tail, element) \
do \
- { \
- GNUNET_assert (((element)->prev == NULL) && ((head) != (element))); \
- GNUNET_assert (((element)->next == NULL) && ((tail) != (element))); \
- (element)->next = (head); \
- (element)->prev = NULL; \
- if ((tail) == NULL) \
+ { \
+ GNUNET_assert(((element)->prev == NULL) && ((head) != (element))); \
+ GNUNET_assert(((element)->next == NULL) && ((tail) != (element))); \
+ (element)->next = (head); \
+ (element)->prev = NULL; \
+ if ((tail) == NULL) \
(tail) = element; \
- else \
- (head)->prev = element; \
- (head) = (element); \
- } while (0)
+ else \
+ (head) ->prev = element; \
+ (head) = (element); \
+ } while (0)
/**
*/
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element) \
do \
- { \
- GNUNET_assert (((element)->prev == NULL) && ((head) != (element))); \
- GNUNET_assert (((element)->next == NULL) && ((tail) != (element))); \
- (element)->prev = (tail); \
- (element)->next = NULL; \
- if ((head) == NULL) \
+ { \
+ GNUNET_assert(((element)->prev == NULL) && ((head) != (element))); \
+ GNUNET_assert(((element)->next == NULL) && ((tail) != (element))); \
+ (element)->prev = (tail); \
+ (element)->next = NULL; \
+ if ((head) == NULL) \
(head) = element; \
- else \
- (tail)->next = element; \
- (tail) = (element); \
- } while (0)
+ else \
+ (tail) ->next = element; \
+ (tail) = (element); \
+ } while (0)
/**
*/
#define GNUNET_CONTAINER_DLL_insert_after(head, tail, other, element) \
do \
- { \
- GNUNET_assert (((element)->prev == NULL) && ((head) != (element))); \
- GNUNET_assert (((element)->next == NULL) && ((tail) != (element))); \
- (element)->prev = (other); \
- if (NULL == other) \
- { \
- (element)->next = (head); \
- (head) = (element); \
- } \
- else \
- { \
- (element)->next = (other)->next; \
- (other)->next = (element); \
- } \
- if (NULL == (element)->next) \
+ { \
+ GNUNET_assert(((element)->prev == NULL) && ((head) != (element))); \
+ GNUNET_assert(((element)->next == NULL) && ((tail) != (element))); \
+ (element)->prev = (other); \
+ if (NULL == other) \
+ { \
+ (element)->next = (head); \
+ (head) = (element); \
+ } \
+ else \
+ { \
+ (element)->next = (other)->next; \
+ (other)->next = (element); \
+ } \
+ if (NULL == (element)->next) \
(tail) = (element); \
- else \
- (element)->next->prev = (element); \
- } while (0)
+ else \
+ (element) ->next->prev = (element); \
+ } while (0)
/**
*/
#define GNUNET_CONTAINER_DLL_insert_before(head, tail, other, element) \
do \
- { \
- GNUNET_assert (((element)->prev == NULL) && ((head) != (element))); \
- GNUNET_assert (((element)->next == NULL) && ((tail) != (element))); \
- (element)->next = (other); \
- if (NULL == other) \
- { \
- (element)->prev = (tail); \
- (tail) = (element); \
- } \
- else \
- { \
- (element)->prev = (other)->prev; \
- (other)->prev = (element); \
- } \
- if (NULL == (element)->prev) \
+ { \
+ GNUNET_assert(((element)->prev == NULL) && ((head) != (element))); \
+ GNUNET_assert(((element)->next == NULL) && ((tail) != (element))); \
+ (element)->next = (other); \
+ if (NULL == other) \
+ { \
+ (element)->prev = (tail); \
+ (tail) = (element); \
+ } \
+ else \
+ { \
+ (element)->prev = (other)->prev; \
+ (other)->prev = (element); \
+ } \
+ if (NULL == (element)->prev) \
(head) = (element); \
- else \
- (element)->prev->next = (element); \
- } while (0)
+ else \
+ (element) ->prev->next = (element); \
+ } while (0)
/**
*/
#define GNUNET_CONTAINER_DLL_remove(head, tail, element) \
do \
- { \
- GNUNET_assert (((element)->prev != NULL) || ((head) == (element))); \
- GNUNET_assert (((element)->next != NULL) || ((tail) == (element))); \
- if ((element)->prev == NULL) \
+ { \
+ GNUNET_assert(((element)->prev != NULL) || ((head) == (element))); \
+ GNUNET_assert(((element)->next != NULL) || ((tail) == (element))); \
+ if ((element)->prev == NULL) \
(head) = (element)->next; \
- else \
- (element)->prev->next = (element)->next; \
- if ((element)->next == NULL) \
+ else \
+ (element) ->prev->next = (element)->next; \
+ if ((element)->next == NULL) \
(tail) = (element)->prev; \
- else \
- (element)->next->prev = (element)->prev; \
- (element)->next = NULL; \
- (element)->prev = NULL; \
- } while (0)
+ else \
+ (element) ->next->prev = (element)->prev; \
+ (element)->next = NULL; \
+ (element)->prev = NULL; \
+ } while (0)
/* ************ Multi-DLL interface, allows DLL elements to be
*/
#define GNUNET_CONTAINER_MDLL_insert(mdll, head, tail, element) \
do \
- { \
- GNUNET_assert (((element)->prev_##mdll == NULL) && ((head) != (element))); \
- GNUNET_assert (((element)->next_##mdll == NULL) && ((tail) != (element))); \
- (element)->next_##mdll = (head); \
- (element)->prev_##mdll = NULL; \
- if ((tail) == NULL) \
+ { \
+ GNUNET_assert(((element)->prev_ ## mdll == NULL) && ((head) != (element))); \
+ GNUNET_assert(((element)->next_ ## mdll == NULL) && ((tail) != (element))); \
+ (element)->next_ ## mdll = (head); \
+ (element)->prev_ ## mdll = NULL; \
+ if ((tail) == NULL) \
(tail) = element; \
- else \
- (head)->prev_##mdll = element; \
- (head) = (element); \
- } while (0)
+ else \
+ (head) ->prev_ ## mdll = element; \
+ (head) = (element); \
+ } while (0)
/**
*/
#define GNUNET_CONTAINER_MDLL_insert_tail(mdll, head, tail, element) \
do \
- { \
- GNUNET_assert (((element)->prev_##mdll == NULL) && ((head) != (element))); \
- GNUNET_assert (((element)->next_##mdll == NULL) && ((tail) != (element))); \
- (element)->prev_##mdll = (tail); \
- (element)->next_##mdll = NULL; \
- if ((head) == NULL) \
+ { \
+ GNUNET_assert(((element)->prev_ ## mdll == NULL) && ((head) != (element))); \
+ GNUNET_assert(((element)->next_ ## mdll == NULL) && ((tail) != (element))); \
+ (element)->prev_ ## mdll = (tail); \
+ (element)->next_ ## mdll = NULL; \
+ if ((head) == NULL) \
(head) = element; \
- else \
- (tail)->next_##mdll = element; \
- (tail) = (element); \
- } while (0)
+ else \
+ (tail) ->next_ ## mdll = element; \
+ (tail) = (element); \
+ } while (0)
/**
*/
#define GNUNET_CONTAINER_MDLL_insert_after(mdll, head, tail, other, element) \
do \
- { \
- GNUNET_assert (((element)->prev_##mdll == NULL) && ((head) != (element))); \
- GNUNET_assert (((element)->next_##mdll == NULL) && ((tail) != (element))); \
- (element)->prev_##mdll = (other); \
- if (NULL == other) \
- { \
- (element)->next_##mdll = (head); \
- (head) = (element); \
- } \
- else \
- { \
- (element)->next_##mdll = (other)->next_##mdll; \
- (other)->next_##mdll = (element); \
- } \
- if (NULL == (element)->next_##mdll) \
+ { \
+ GNUNET_assert(((element)->prev_ ## mdll == NULL) && ((head) != (element))); \
+ GNUNET_assert(((element)->next_ ## mdll == NULL) && ((tail) != (element))); \
+ (element)->prev_ ## mdll = (other); \
+ if (NULL == other) \
+ { \
+ (element)->next_ ## mdll = (head); \
+ (head) = (element); \
+ } \
+ else \
+ { \
+ (element)->next_ ## mdll = (other)->next_ ## mdll; \
+ (other)->next_ ## mdll = (element); \
+ } \
+ if (NULL == (element)->next_ ## mdll) \
(tail) = (element); \
- else \
- (element)->next_##mdll->prev_##mdll = (element); \
- } while (0)
+ else \
+ (element) ->next_ ## mdll->prev_ ## mdll = (element); \
+ } while (0)
/**
*/
#define GNUNET_CONTAINER_MDLL_insert_before(mdll, head, tail, other, element) \
do \
- { \
- GNUNET_assert (((element)->prev_##mdll == NULL) && ((head) != (element))); \
- GNUNET_assert (((element)->next_##mdll == NULL) && ((tail) != (element))); \
- (element)->next_##mdll = (other); \
- if (NULL == other) \
- { \
- (element)->prev = (tail); \
- (tail) = (element); \
- } \
- else \
- { \
- (element)->prev_##mdll = (other)->prev_##mdll; \
- (other)->prev_##mdll = (element); \
- } \
- if (NULL == (element)->prev_##mdll) \
+ { \
+ GNUNET_assert(((element)->prev_ ## mdll == NULL) && ((head) != (element))); \
+ GNUNET_assert(((element)->next_ ## mdll == NULL) && ((tail) != (element))); \
+ (element)->next_ ## mdll = (other); \
+ if (NULL == other) \
+ { \
+ (element)->prev = (tail); \
+ (tail) = (element); \
+ } \
+ else \
+ { \
+ (element)->prev_ ## mdll = (other)->prev_ ## mdll; \
+ (other)->prev_ ## mdll = (element); \
+ } \
+ if (NULL == (element)->prev_ ## mdll) \
(head) = (element); \
- else \
- (element)->prev_##mdll->next_##mdll = (element); \
- } while (0)
+ else \
+ (element) ->prev_ ## mdll->next_ ## mdll = (element); \
+ } while (0)
/**
*/
#define GNUNET_CONTAINER_MDLL_remove(mdll, head, tail, element) \
do \
- { \
- GNUNET_assert (((element)->prev_##mdll != NULL) || ((head) == (element))); \
- GNUNET_assert (((element)->next_##mdll != NULL) || ((tail) == (element))); \
- if ((element)->prev_##mdll == NULL) \
- (head) = (element)->next_##mdll; \
- else \
- (element)->prev_##mdll->next_##mdll = (element)->next_##mdll; \
- if ((element)->next_##mdll == NULL) \
- (tail) = (element)->prev_##mdll; \
- else \
- (element)->next_##mdll->prev_##mdll = (element)->prev_##mdll; \
- (element)->next_##mdll = NULL; \
- (element)->prev_##mdll = NULL; \
- } while (0)
+ { \
+ GNUNET_assert(((element)->prev_ ## mdll != NULL) || ((head) == (element))); \
+ GNUNET_assert(((element)->next_ ## mdll != NULL) || ((tail) == (element))); \
+ if ((element)->prev_ ## mdll == NULL) \
+ (head) = (element)->next_ ## mdll; \
+ else \
+ (element) ->prev_ ## mdll->next_ ## mdll = (element)->next_ ## mdll; \
+ if ((element)->next_ ## mdll == NULL) \
+ (tail) = (element)->prev_ ## mdll; \
+ else \
+ (element) ->next_ ## mdll->prev_ ## mdll = (element)->prev_ ## mdll; \
+ (element)->next_ ## mdll = NULL; \
+ (element)->prev_ ## mdll = NULL; \
+ } while (0)
/**
tail, \
element) \
do \
- { \
- if ((NULL == head) || (0 < comparator (comparator_cls, element, head))) \
- { \
- /* insert at head, element < head */ \
- GNUNET_CONTAINER_DLL_insert (head, tail, element); \
- } \
- else \
- { \
- TYPE *pos; \
+ { \
+ if ((NULL == head) || (0 < comparator(comparator_cls, element, head))) \
+ { \
+ /* insert at head, element < head */ \
+ GNUNET_CONTAINER_DLL_insert(head, tail, element); \
+ } \
+ else \
+ { \
+ TYPE *pos; \
\
- for (pos = head; NULL != pos; pos = pos->next) \
- if (0 < comparator (comparator_cls, element, pos)) \
+ for (pos = head; NULL != pos; pos = pos->next) \
+ if (0 < comparator(comparator_cls, element, pos)) \
break; /* element < pos */ \
- if (NULL == pos) /* => element > tail */ \
- { \
- GNUNET_CONTAINER_DLL_insert_tail (head, tail, element); \
- } \
- else /* prev < element < pos */ \
- { \
- GNUNET_CONTAINER_DLL_insert_after (head, tail, pos->prev, element); \
- } \
- } \
- } while (0)
+ if (NULL == pos) /* => element > tail */ \
+ { \
+ GNUNET_CONTAINER_DLL_insert_tail(head, tail, element); \
+ } \
+ else /* prev < element < pos */ \
+ { \
+ GNUNET_CONTAINER_DLL_insert_after(head, tail, pos->prev, element); \
+ } \
+ } \
+ } while (0)
/* ******************** Heap *************** */
* @ingroup heap
* Heap type, either max or min.
*/
-enum GNUNET_CONTAINER_HeapOrder
-{
+enum GNUNET_CONTAINER_HeapOrder {
/**
* @ingroup heap
* Heap with the maximum cost at the root.
* @return handle to the heap
*/
struct GNUNET_CONTAINER_Heap *
-GNUNET_CONTAINER_heap_create (enum GNUNET_CONTAINER_HeapOrder order);
+GNUNET_CONTAINER_heap_create(enum GNUNET_CONTAINER_HeapOrder order);
/**
* @param heap heap to destroy
*/
void
-GNUNET_CONTAINER_heap_destroy (struct GNUNET_CONTAINER_Heap *heap);
+GNUNET_CONTAINER_heap_destroy(struct GNUNET_CONTAINER_Heap *heap);
/**
* @return Element at the root, or NULL if heap is empty.
*/
void *
-GNUNET_CONTAINER_heap_peek (const struct GNUNET_CONTAINER_Heap *heap);
+GNUNET_CONTAINER_heap_peek(const struct GNUNET_CONTAINER_Heap *heap);
/**
* #GNUNET_NO if the heap is empty.
*/
int
-GNUNET_CONTAINER_heap_peek2 (const struct GNUNET_CONTAINER_Heap *heap,
- void **element,
- GNUNET_CONTAINER_HeapCostType *cost);
+GNUNET_CONTAINER_heap_peek2(const struct GNUNET_CONTAINER_Heap *heap,
+ void **element,
+ GNUNET_CONTAINER_HeapCostType *cost);
/**
* @return number of elements stored
*/
unsigned int
-GNUNET_CONTAINER_heap_get_size (const struct GNUNET_CONTAINER_Heap *heap);
+GNUNET_CONTAINER_heap_get_size(const struct GNUNET_CONTAINER_Heap *heap);
/**
* @return cost of the node
*/
GNUNET_CONTAINER_HeapCostType
-GNUNET_CONTAINER_heap_node_get_cost (
+GNUNET_CONTAINER_heap_node_get_cost(
const struct GNUNET_CONTAINER_HeapNode *node);
* @param iterator_cls closure for @a iterator
*/
void
-GNUNET_CONTAINER_heap_iterate (const struct GNUNET_CONTAINER_Heap *heap,
- GNUNET_CONTAINER_HeapIterator iterator,
- void *iterator_cls);
+GNUNET_CONTAINER_heap_iterate(const struct GNUNET_CONTAINER_Heap *heap,
+ GNUNET_CONTAINER_HeapIterator iterator,
+ void *iterator_cls);
/**
* @ingroup heap
* NULL if the tree is empty.
*/
void *
-GNUNET_CONTAINER_heap_walk_get_next (struct GNUNET_CONTAINER_Heap *heap);
+GNUNET_CONTAINER_heap_walk_get_next(struct GNUNET_CONTAINER_Heap *heap);
/**
* @return node for the new element
*/
struct GNUNET_CONTAINER_HeapNode *
-GNUNET_CONTAINER_heap_insert (struct GNUNET_CONTAINER_Heap *heap,
- void *element,
- GNUNET_CONTAINER_HeapCostType cost);
+GNUNET_CONTAINER_heap_insert(struct GNUNET_CONTAINER_Heap *heap,
+ void *element,
+ GNUNET_CONTAINER_HeapCostType cost);
/**
* @return element data stored at the root node
*/
void *
-GNUNET_CONTAINER_heap_remove_root (struct GNUNET_CONTAINER_Heap *heap);
+GNUNET_CONTAINER_heap_remove_root(struct GNUNET_CONTAINER_Heap *heap);
/**
* @return element data stored at the node, NULL if heap is empty
*/
void *
-GNUNET_CONTAINER_heap_remove_node (struct GNUNET_CONTAINER_HeapNode *node);
+GNUNET_CONTAINER_heap_remove_node(struct GNUNET_CONTAINER_HeapNode *node);
/**
* @param new_cost new cost for the node
*/
void
-GNUNET_CONTAINER_heap_update_cost (struct GNUNET_CONTAINER_HeapNode *node,
- GNUNET_CONTAINER_HeapCostType new_cost);
+GNUNET_CONTAINER_heap_update_cost(struct GNUNET_CONTAINER_HeapNode *node,
+ GNUNET_CONTAINER_HeapCostType new_cost);
#if 0 /* keep Emacsens' auto-indent happy */
projects / oweals / gnunet.git / blobdiff