15263807472

/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once

#include "forward.h"
#include "hash-funcs.h"
#include "iterator.h"

/*
 * A hash table implementation. As a minor optimization a NULL hashmap object
 * will be treated as empty hashmap for all read operations. That way it is not
 * necessary to instantiate an object for each Hashmap use.
 *
 * If ENABLE_DEBUG_HASHMAP is defined (by configuring with -Ddebug-extra=hashmap),
 * the implementation will:
 * - store extra data for debugging and statistics (see tools/gdb-sd_dump_hashmaps.py)
 * - perform extra checks for invalid use of iterators
 */

#define HASH_KEY_SIZE 16


/* The base type for all hashmap and set types. Many functions in the implementation take (HashmapBase*)
 * parameters and are run-time polymorphic, though the API is not meant to be polymorphic (do not call
 * underscore-prefixed functions directly). */
typedef struct HashmapBase HashmapBase;

/* Specific hashmap/set types */
typedef struct Hashmap Hashmap;               /* Maps keys to values */
typedef struct OrderedHashmap OrderedHashmap; /* Like Hashmap, but also remembers entry insertion order */
typedef struct Set Set;                       /* Stores just keys */

typedef struct IteratedCache IteratedCache;   /* Caches the iterated order of one of the above */

/* Macros for type checking */
#define PTR_COMPATIBLE_WITH_HASHMAP_BASE(h) \
        (__builtin_types_compatible_p(typeof(h), HashmapBase*) || \
         __builtin_types_compatible_p(typeof(h), Hashmap*) || \
         __builtin_types_compatible_p(typeof(h), OrderedHashmap*) || \
         __builtin_types_compatible_p(typeof(h), Set*))

#define PTR_COMPATIBLE_WITH_PLAIN_HASHMAP(h) \
        (__builtin_types_compatible_p(typeof(h), Hashmap*) || \
         __builtin_types_compatible_p(typeof(h), OrderedHashmap*)) \

#define HASHMAP_BASE(h) \
        __builtin_choose_expr(PTR_COMPATIBLE_WITH_HASHMAP_BASE(h), \
                (HashmapBase*)(h), \
                (void)0)

#define PLAIN_HASHMAP(h) \
        __builtin_choose_expr(PTR_COMPATIBLE_WITH_PLAIN_HASHMAP(h), \
                (Hashmap*)(h), \
                (void)0)

Hashmap* hashmap_new(const struct hash_ops *hash_ops);
OrderedHashmap* ordered_hashmap_new(const struct hash_ops *hash_ops);

#define hashmap_free_and_replace(a, b)                          \
        free_and_replace_full(a, b, hashmap_free)
#define ordered_hashmap_free_and_replace(a, b)                  \
        free_and_replace_full(a, b, ordered_hashmap_free)

HashmapBase* _hashmap_free(HashmapBase *h);
static inline Hashmap* hashmap_free(Hashmap *h) {
        return (void*) _hashmap_free(HASHMAP_BASE(h));
}
static inline OrderedHashmap* ordered_hashmap_free(OrderedHashmap *h) {
        return (void*) _hashmap_free(HASHMAP_BASE(h));
}

IteratedCache* iterated_cache_free(IteratedCache *cache);
int iterated_cache_get(IteratedCache *cache, const void ***res_keys, const void ***res_values, unsigned *res_n_entries);

HashmapBase* _hashmap_copy(HashmapBase *h);
static inline Hashmap* hashmap_copy(Hashmap *h) {
        return (Hashmap*) _hashmap_copy(HASHMAP_BASE(h));
}
static inline OrderedHashmap* ordered_hashmap_copy(OrderedHashmap *h) {
        return (OrderedHashmap*) _hashmap_copy(HASHMAP_BASE(h));
}

int hashmap_ensure_allocated(Hashmap **h, const struct hash_ops *hash_ops);
int hashmap_ensure_put(Hashmap **h, const struct hash_ops *hash_ops, const void *key, void *value);
int ordered_hashmap_ensure_allocated(OrderedHashmap **h, const struct hash_ops *hash_ops);
int hashmap_ensure_replace(Hashmap **h, const struct hash_ops *hash_ops, const void *key, void *value);

int ordered_hashmap_ensure_put(OrderedHashmap **h, const struct hash_ops *hash_ops, const void *key, void *value);
int ordered_hashmap_ensure_replace(OrderedHashmap **h, const struct hash_ops *hash_ops, const void *key, void *value);

IteratedCache* _hashmap_iterated_cache_new(HashmapBase *h);
static inline IteratedCache* hashmap_iterated_cache_new(Hashmap *h) {
        return (IteratedCache*) _hashmap_iterated_cache_new(HASHMAP_BASE(h));
}
static inline IteratedCache* ordered_hashmap_iterated_cache_new(OrderedHashmap *h) {
        return (IteratedCache*) _hashmap_iterated_cache_new(HASHMAP_BASE(h));
}

int hashmap_put(Hashmap *h, const void *key, void *value);
static inline int ordered_hashmap_put(OrderedHashmap *h, const void *key, void *value) {
        return hashmap_put(PLAIN_HASHMAP(h), key, value);
}

int hashmap_put_strdup_full(Hashmap **h, const struct hash_ops *hash_ops, const char *k, const char *v);
static inline int hashmap_put_strdup(Hashmap **h, const char *k, const char *v) {
        return hashmap_put_strdup_full(h, &string_hash_ops_free_free, k, v);
}

int hashmap_update(Hashmap *h, const void *key, void *value);
static inline int ordered_hashmap_update(OrderedHashmap *h, const void *key, void *value) {
        return hashmap_update(PLAIN_HASHMAP(h), key, value);
}

int hashmap_replace(Hashmap *h, const void *key, void *value);
static inline int ordered_hashmap_replace(OrderedHashmap *h, const void *key, void *value) {
        return hashmap_replace(PLAIN_HASHMAP(h), key, value);
}

void* _hashmap_get(HashmapBase *h, const void *key);
static inline void *hashmap_get(Hashmap *h, const void *key) {
        return _hashmap_get(HASHMAP_BASE(h), key);
}
static inline void *ordered_hashmap_get(OrderedHashmap *h, const void *key) {
        return _hashmap_get(HASHMAP_BASE(h), key);
}

void* hashmap_get2(Hashmap *h, const void *key, void **rkey);
static inline void *ordered_hashmap_get2(OrderedHashmap *h, const void *key, void **rkey) {
        return hashmap_get2(PLAIN_HASHMAP(h), key, rkey);
}

bool _hashmap_contains(HashmapBase *h, const void *key);
static inline bool hashmap_contains(Hashmap *h, const void *key) {
        return _hashmap_contains(HASHMAP_BASE(h), key);
}
static inline bool ordered_hashmap_contains(OrderedHashmap *h, const void *key) {
        return _hashmap_contains(HASHMAP_BASE(h), key);
}

void* _hashmap_remove(HashmapBase *h, const void *key);
static inline void *hashmap_remove(Hashmap *h, const void *key) {
        return _hashmap_remove(HASHMAP_BASE(h), key);
}
static inline void *ordered_hashmap_remove(OrderedHashmap *h, const void *key) {
        return _hashmap_remove(HASHMAP_BASE(h), key);
}

void* hashmap_remove2(Hashmap *h, const void *key, void **rkey);
static inline void *ordered_hashmap_remove2(OrderedHashmap *h, const void *key, void **rkey) {
        return hashmap_remove2(PLAIN_HASHMAP(h), key, rkey);
}

void* _hashmap_remove_value(HashmapBase *h, const void *key, void *value);
static inline void *hashmap_remove_value(Hashmap *h, const void *key, void *value) {
        return _hashmap_remove_value(HASHMAP_BASE(h), key, value);
}

static inline void* ordered_hashmap_remove_value(OrderedHashmap *h, const void *key, void *value) {
        return hashmap_remove_value(PLAIN_HASHMAP(h), key, value);
}

int hashmap_remove_and_put(Hashmap *h, const void *old_key, const void *new_key, void *value);
static inline int ordered_hashmap_remove_and_put(OrderedHashmap *h, const void *old_key, const void *new_key, void *value) {
        return hashmap_remove_and_put(PLAIN_HASHMAP(h), old_key, new_key, value);
}

int hashmap_remove_and_replace(Hashmap *h, const void *old_key, const void *new_key, void *value);
static inline int ordered_hashmap_remove_and_replace(OrderedHashmap *h, const void *old_key, const void *new_key, void *value) {
        return hashmap_remove_and_replace(PLAIN_HASHMAP(h), old_key, new_key, value);
}

/* Since merging data from an OrderedHashmap into a Hashmap or vice-versa
 * should just work, allow this by having looser type-checking here. */
int _hashmap_merge(Hashmap *h, Hashmap *other);
#define hashmap_merge(h, other) _hashmap_merge(PLAIN_HASHMAP(h), PLAIN_HASHMAP(other))
#define ordered_hashmap_merge(h, other) hashmap_merge(h, other)

int _hashmap_reserve(HashmapBase *h, unsigned entries_add);
static inline int hashmap_reserve(Hashmap *h, unsigned entries_add) {
        return _hashmap_reserve(HASHMAP_BASE(h), entries_add);
}
static inline int ordered_hashmap_reserve(OrderedHashmap *h, unsigned entries_add) {
        return _hashmap_reserve(HASHMAP_BASE(h), entries_add);
}

int _hashmap_move(HashmapBase *h, HashmapBase *other);
/* Unlike hashmap_merge, hashmap_move does not allow mixing the types. */
static inline int hashmap_move(Hashmap *h, Hashmap *other) {
        return _hashmap_move(HASHMAP_BASE(h), HASHMAP_BASE(other));
}
static inline int ordered_hashmap_move(OrderedHashmap *h, OrderedHashmap *other) {
        return _hashmap_move(HASHMAP_BASE(h), HASHMAP_BASE(other));
}

int _hashmap_move_one(HashmapBase *h, HashmapBase *other, const void *key);
static inline int hashmap_move_one(Hashmap *h, Hashmap *other, const void *key) {
        return _hashmap_move_one(HASHMAP_BASE(h), HASHMAP_BASE(other), key);
}
static inline int ordered_hashmap_move_one(OrderedHashmap *h, OrderedHashmap *other, const void *key) {
        return _hashmap_move_one(HASHMAP_BASE(h), HASHMAP_BASE(other), key);
}

unsigned _hashmap_size(HashmapBase *h) _pure_;
static inline unsigned hashmap_size(Hashmap *h) {
        return _hashmap_size(HASHMAP_BASE(h));
}
static inline unsigned ordered_hashmap_size(OrderedHashmap *h) {
        return _hashmap_size(HASHMAP_BASE(h));
}

static inline bool hashmap_isempty(Hashmap *h) {
        return hashmap_size(h) == 0;
}
static inline bool ordered_hashmap_isempty(OrderedHashmap *h) {
        return ordered_hashmap_size(h) == 0;
}

unsigned _hashmap_buckets(HashmapBase *h) _pure_;
static inline unsigned hashmap_buckets(Hashmap *h) {
        return _hashmap_buckets(HASHMAP_BASE(h));
}
static inline unsigned ordered_hashmap_buckets(OrderedHashmap *h) {
        return _hashmap_buckets(HASHMAP_BASE(h));
}

bool _hashmap_iterate(HashmapBase *h, Iterator *i, void **value, const void **key);
static inline bool hashmap_iterate(Hashmap *h, Iterator *i, void **value, const void **key) {
        return _hashmap_iterate(HASHMAP_BASE(h), i, value, key);
}
static inline bool ordered_hashmap_iterate(OrderedHashmap *h, Iterator *i, void **value, const void **key) {
        return _hashmap_iterate(HASHMAP_BASE(h), i, value, key);
}

void _hashmap_clear(HashmapBase *h);
static inline void hashmap_clear(Hashmap *h) {
        _hashmap_clear(HASHMAP_BASE(h));
}
static inline void ordered_hashmap_clear(OrderedHashmap *h) {
        _hashmap_clear(HASHMAP_BASE(h));
}

/*
 * Note about all *_first*() functions
 *
 * For plain Hashmaps and Sets the order of entries is undefined.
 * The functions find whatever entry is first in the implementation
 * internal order.
 *
 * Only for OrderedHashmaps the order is well defined and finding
 * the first entry is O(1).
 */

void *_hashmap_first_key_and_value(HashmapBase *h, bool remove, void **ret_key);
static inline void *hashmap_steal_first_key_and_value(Hashmap *h, void **ret) {
        return _hashmap_first_key_and_value(HASHMAP_BASE(h), true, ret);
}
static inline void *ordered_hashmap_steal_first_key_and_value(OrderedHashmap *h, void **ret) {
        return _hashmap_first_key_and_value(HASHMAP_BASE(h), true, ret);
}
static inline void *hashmap_first_key_and_value(Hashmap *h, void **ret) {
        return _hashmap_first_key_and_value(HASHMAP_BASE(h), false, ret);
}
static inline void *ordered_hashmap_first_key_and_value(OrderedHashmap *h, void **ret) {
        return _hashmap_first_key_and_value(HASHMAP_BASE(h), false, ret);
}

static inline void *hashmap_steal_first(Hashmap *h) {
        return _hashmap_first_key_and_value(HASHMAP_BASE(h), true, NULL);
}
static inline void *ordered_hashmap_steal_first(OrderedHashmap *h) {
        return _hashmap_first_key_and_value(HASHMAP_BASE(h), true, NULL);
}
static inline void *hashmap_first(Hashmap *h) {
        return _hashmap_first_key_and_value(HASHMAP_BASE(h), false, NULL);
}
static inline void *ordered_hashmap_first(OrderedHashmap *h) {
        return _hashmap_first_key_and_value(HASHMAP_BASE(h), false, NULL);
}

static inline void *_hashmap_first_key(HashmapBase *h, bool remove) {
        void *key = NULL;

        (void) _hashmap_first_key_and_value(HASHMAP_BASE(h), remove, &key);
        return key;
}
static inline void *hashmap_steal_first_key(Hashmap *h) {
        return _hashmap_first_key(HASHMAP_BASE(h), true);
}
static inline void *ordered_hashmap_steal_first_key(OrderedHashmap *h) {
        return _hashmap_first_key(HASHMAP_BASE(h), true);
}
static inline void *hashmap_first_key(Hashmap *h) {
        return _hashmap_first_key(HASHMAP_BASE(h), false);
}
static inline void *ordered_hashmap_first_key(OrderedHashmap *h) {
        return _hashmap_first_key(HASHMAP_BASE(h), false);
}

/* no hashmap_next */
void* ordered_hashmap_next(OrderedHashmap *h, const void *key);

char** _hashmap_get_strv(HashmapBase *h);
static inline char** hashmap_get_strv(Hashmap *h) {
        return _hashmap_get_strv(HASHMAP_BASE(h));
}
static inline char** ordered_hashmap_get_strv(OrderedHashmap *h) {
        return _hashmap_get_strv(HASHMAP_BASE(h));
}

int _hashmap_dump_sorted(HashmapBase *h, void ***ret, size_t *ret_n);
static inline int hashmap_dump_sorted(Hashmap *h, void ***ret, size_t *ret_n) {
        return _hashmap_dump_sorted(HASHMAP_BASE(h), ret, ret_n);
}
static inline int ordered_hashmap_dump_sorted(OrderedHashmap *h, void ***ret, size_t *ret_n) {
        return _hashmap_dump_sorted(HASHMAP_BASE(h), ret, ret_n);
}
static inline int set_dump_sorted(Set *h, void ***ret, size_t *ret_n) {
        return _hashmap_dump_sorted(HASHMAP_BASE(h), ret, ret_n);
}

int _hashmap_dump_keys_sorted(HashmapBase *h, void ***ret, size_t *ret_n);
static inline int hashmap_dump_keys_sorted(Hashmap *h, void ***ret, size_t *ret_n) {
        return _hashmap_dump_keys_sorted(HASHMAP_BASE(h), ret, ret_n);
}
static inline int ordered_hashmap_dump_keys_sorted(OrderedHashmap *h, void ***ret, size_t *ret_n) {
        return _hashmap_dump_keys_sorted(HASHMAP_BASE(h), ret, ret_n);
}

/*
 * Hashmaps are iterated in unpredictable order.
 * OrderedHashmaps are an exception to this. They are iterated in the order
 * the entries were inserted.
 * It is safe to remove the current entry.
 */
#define _HASHMAP_BASE_FOREACH(e, h, i) \
        for (Iterator i = ITERATOR_FIRST; _hashmap_iterate((h), &i, (void**)&(e), NULL); )
#define HASHMAP_BASE_FOREACH(e, h) \
        _HASHMAP_BASE_FOREACH(e, h, UNIQ_T(i, UNIQ))

#define _HASHMAP_FOREACH(e, h, i) \
        for (Iterator i = ITERATOR_FIRST; hashmap_iterate((h), &i, (void**)&(e), NULL); )
#define HASHMAP_FOREACH(e, h) \
        _HASHMAP_FOREACH(e, h, UNIQ_T(i, UNIQ))

#define _ORDERED_HASHMAP_FOREACH(e, h, i) \
        for (Iterator i = ITERATOR_FIRST; ordered_hashmap_iterate((h), &i, (void**)&(e), NULL); )
#define ORDERED_HASHMAP_FOREACH(e, h) \
        _ORDERED_HASHMAP_FOREACH(e, h, UNIQ_T(i, UNIQ))

#define _HASHMAP_BASE_FOREACH_KEY(e, k, h, i) \
        for (Iterator i = ITERATOR_FIRST; _hashmap_iterate((h), &i, (void**)&(e), (const void**) &(k)); )
#define HASHMAP_BASE_FOREACH_KEY(e, k, h) \
        _HASHMAP_BASE_FOREACH_KEY(e, k, h, UNIQ_T(i, UNIQ))

#define _HASHMAP_FOREACH_KEY(e, k, h, i) \
        for (Iterator i = ITERATOR_FIRST; hashmap_iterate((h), &i, (void**)&(e), (const void**) &(k)); )
#define HASHMAP_FOREACH_KEY(e, k, h) \
        _HASHMAP_FOREACH_KEY(e, k, h, UNIQ_T(i, UNIQ))

#define _ORDERED_HASHMAP_FOREACH_KEY(e, k, h, i) \
        for (Iterator i = ITERATOR_FIRST; ordered_hashmap_iterate((h), &i, (void**)&(e), (const void**) &(k)); )
#define ORDERED_HASHMAP_FOREACH_KEY(e, k, h) \
        _ORDERED_HASHMAP_FOREACH_KEY(e, k, h, UNIQ_T(i, UNIQ))

DEFINE_TRIVIAL_CLEANUP_FUNC(Hashmap*, hashmap_free);
DEFINE_TRIVIAL_CLEANUP_FUNC(OrderedHashmap*, ordered_hashmap_free);

#define _cleanup_hashmap_free_ _cleanup_(hashmap_freep)
#define _cleanup_ordered_hashmap_free_ _cleanup_(ordered_hashmap_freep)

DEFINE_TRIVIAL_CLEANUP_FUNC(IteratedCache*, iterated_cache_free);

#define _cleanup_iterated_cache_free_ _cleanup_(iterated_cache_freep)

void hashmap_trim_pools(void);

1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
2	#pragma once
3
4	#include "forward.h"
5	#include "hash-funcs.h"
6	#include "iterator.h"
7
8	/*
9	* A hash table implementation. As a minor optimization a NULL hashmap object
10	* will be treated as empty hashmap for all read operations. That way it is not
11	* necessary to instantiate an object for each Hashmap use.
12	*
13	* If ENABLE_DEBUG_HASHMAP is defined (by configuring with -Ddebug-extra=hashmap),
14	* the implementation will:
15	* - store extra data for debugging and statistics (see tools/gdb-sd_dump_hashmaps.py)
16	* - perform extra checks for invalid use of iterators
17	*/
18
19	#define HASH_KEY_SIZE 16
20
21
22	/* The base type for all hashmap and set types. Many functions in the implementation take (HashmapBase*)
23	* parameters and are run-time polymorphic, though the API is not meant to be polymorphic (do not call
24	* underscore-prefixed functions directly). */
25	typedef struct HashmapBase HashmapBase;
26
27	/* Specific hashmap/set types */
28	typedef struct Hashmap Hashmap; /* Maps keys to values */
29	typedef struct OrderedHashmap OrderedHashmap; /* Like Hashmap, but also remembers entry insertion order */
30	typedef struct Set Set; /* Stores just keys */
31
32	typedef struct IteratedCache IteratedCache; /* Caches the iterated order of one of the above */
33
34	/* Macros for type checking */
35	#define PTR_COMPATIBLE_WITH_HASHMAP_BASE(h) \
36	(__builtin_types_compatible_p(typeof(h), HashmapBase*) \|\| \
37	__builtin_types_compatible_p(typeof(h), Hashmap*) \|\| \
38	__builtin_types_compatible_p(typeof(h), OrderedHashmap*) \|\| \
39	__builtin_types_compatible_p(typeof(h), Set*))
40
41	#define PTR_COMPATIBLE_WITH_PLAIN_HASHMAP(h) \
42	(__builtin_types_compatible_p(typeof(h), Hashmap*) \|\| \
43	__builtin_types_compatible_p(typeof(h), OrderedHashmap*)) \
44
45	#define HASHMAP_BASE(h) \
46	__builtin_choose_expr(PTR_COMPATIBLE_WITH_HASHMAP_BASE(h), \
47	(HashmapBase*)(h), \
48	(void)0)
49
50	#define PLAIN_HASHMAP(h) \
51	__builtin_choose_expr(PTR_COMPATIBLE_WITH_PLAIN_HASHMAP(h), \
52	(Hashmap*)(h), \
53	(void)0)
54
55	Hashmap* hashmap_new(const struct hash_ops *hash_ops);
56	OrderedHashmap* ordered_hashmap_new(const struct hash_ops *hash_ops);
57
58	#define hashmap_free_and_replace(a, b) \
59	free_and_replace_full(a, b, hashmap_free)
60	#define ordered_hashmap_free_and_replace(a, b) \
61	free_and_replace_full(a, b, ordered_hashmap_free)
62
63	HashmapBase* _hashmap_free(HashmapBase *h);
64	static inline Hashmap* hashmap_free(Hashmap *h) {	4,238,511✔
65	return (void*) _hashmap_free(HASHMAP_BASE(h));	3,611,137✔
66	}
67	static inline OrderedHashmap* ordered_hashmap_free(OrderedHashmap *h) {	4,423,519✔
68	return (void*) _hashmap_free(HASHMAP_BASE(h));	3,197,991✔
69	}
70
71	IteratedCache* iterated_cache_free(IteratedCache *cache);
72	int iterated_cache_get(IteratedCache cache, const void res_keys, const void res_values, unsigned res_n_entries);
73
74	HashmapBase* _hashmap_copy(HashmapBase *h);
75	static inline Hashmap* hashmap_copy(Hashmap *h) {	1✔
76	return (Hashmap*) _hashmap_copy(HASHMAP_BASE(h));	1✔
77	}
78	static inline OrderedHashmap* ordered_hashmap_copy(OrderedHashmap *h) {	1✔
79	return (OrderedHashmap*) _hashmap_copy(HASHMAP_BASE(h));	1✔
80	}
81
82	int hashmap_ensure_allocated(Hashmap *h, const struct hash_ops hash_ops);
83	int hashmap_ensure_put(Hashmap *h, const struct hash_ops hash_ops, const void key, void value);
84	int ordered_hashmap_ensure_allocated(OrderedHashmap *h, const struct hash_ops hash_ops);
85	int hashmap_ensure_replace(Hashmap *h, const struct hash_ops hash_ops, const void key, void value);
86
87	int ordered_hashmap_ensure_put(OrderedHashmap *h, const struct hash_ops hash_ops, const void key, void value);
88	int ordered_hashmap_ensure_replace(OrderedHashmap *h, const struct hash_ops hash_ops, const void key, void value);
89
90	IteratedCache* _hashmap_iterated_cache_new(HashmapBase *h);
91	static inline IteratedCache* hashmap_iterated_cache_new(Hashmap *h) {	1✔
92	return (IteratedCache*) _hashmap_iterated_cache_new(HASHMAP_BASE(h));	1✔
93	}
94	static inline IteratedCache* ordered_hashmap_iterated_cache_new(OrderedHashmap *h) {	6,304✔
95	return (IteratedCache*) _hashmap_iterated_cache_new(HASHMAP_BASE(h));	6,304✔
96	}
97
98	int hashmap_put(Hashmap h, const void key, void *value);
99	static inline int ordered_hashmap_put(OrderedHashmap h, const void key, void *value) {	7,975,262✔
100	return hashmap_put(PLAIN_HASHMAP(h), key, value);	7,975,237✔
101	}
102
103	int hashmap_put_strdup_full(Hashmap *h, const struct hash_ops hash_ops, const char k, const char v);
104	static inline int hashmap_put_strdup(Hashmap *h, const char k, const char *v) {	17✔
105	return hashmap_put_strdup_full(h, &string_hash_ops_free_free, k, v);	17✔
106	}
107
108	int hashmap_update(Hashmap h, const void key, void *value);
109	static inline int ordered_hashmap_update(OrderedHashmap h, const void key, void *value) {	4✔
110	return hashmap_update(PLAIN_HASHMAP(h), key, value);	4✔
111	}
112
113	int hashmap_replace(Hashmap h, const void key, void *value);
114	static inline int ordered_hashmap_replace(OrderedHashmap h, const void key, void *value) {	12,449,407✔
115	return hashmap_replace(PLAIN_HASHMAP(h), key, value);	12,449,407✔
116	}
117
118	void* _hashmap_get(HashmapBase h, const void key);
119	static inline void hashmap_get(Hashmap h, const void *key) {	29,723,483✔
120	return _hashmap_get(HASHMAP_BASE(h), key);	29,145,231✔
121	}
122	static inline void ordered_hashmap_get(OrderedHashmap h, const void *key) {	29,587,647✔
123	return _hashmap_get(HASHMAP_BASE(h), key);	29,587,647✔
124	}
125
126	void* hashmap_get2(Hashmap h, const void key, void **rkey);
127	static inline void ordered_hashmap_get2(OrderedHashmap h, const void key, void *rkey) {	12,441,394✔
128	return hashmap_get2(PLAIN_HASHMAP(h), key, rkey);	12,441,394✔
129	}
130
131	bool _hashmap_contains(HashmapBase h, const void key);
132	static inline bool hashmap_contains(Hashmap h, const void key) {	1,237,259✔
133	return _hashmap_contains(HASHMAP_BASE(h), key);	1,252,462✔
134	}
135	static inline bool ordered_hashmap_contains(OrderedHashmap h, const void key) {	18,712✔
136	return _hashmap_contains(HASHMAP_BASE(h), key);	18,712✔
137	}
138
139	void* _hashmap_remove(HashmapBase h, const void key);
140	static inline void hashmap_remove(Hashmap h, const void *key) {	7,015,124✔
141	return _hashmap_remove(HASHMAP_BASE(h), key);	7,011,375✔
142	}
143	static inline void ordered_hashmap_remove(OrderedHashmap h, const void *key) {	64,842✔
144	return _hashmap_remove(HASHMAP_BASE(h), key);	64,842✔
145	}
146
147	void* hashmap_remove2(Hashmap h, const void key, void **rkey);
148	static inline void ordered_hashmap_remove2(OrderedHashmap h, const void key, void *rkey) {	577,222✔
149	return hashmap_remove2(PLAIN_HASHMAP(h), key, rkey);	577,222✔
150	}
151
152	void* _hashmap_remove_value(HashmapBase h, const void key, void *value);
153	static inline void hashmap_remove_value(Hashmap h, const void key, void value) {	356,413✔
154	return _hashmap_remove_value(HASHMAP_BASE(h), key, value);	356,323✔
155	}
156
157	static inline void* ordered_hashmap_remove_value(OrderedHashmap h, const void key, void *value) {	84,147✔
158	return hashmap_remove_value(PLAIN_HASHMAP(h), key, value);	84,147✔
159	}
160
161	int hashmap_remove_and_put(Hashmap h, const void old_key, const void new_key, void value);
162	static inline int ordered_hashmap_remove_and_put(OrderedHashmap h, const void old_key, const void new_key, void value) {	4✔
163	return hashmap_remove_and_put(PLAIN_HASHMAP(h), old_key, new_key, value);	4✔
164	}
165
166	int hashmap_remove_and_replace(Hashmap h, const void old_key, const void new_key, void value);
167	static inline int ordered_hashmap_remove_and_replace(OrderedHashmap h, const void old_key, const void new_key, void value) {	24✔
168	return hashmap_remove_and_replace(PLAIN_HASHMAP(h), old_key, new_key, value);	24✔
169	}
170
171	/* Since merging data from an OrderedHashmap into a Hashmap or vice-versa
172	* should just work, allow this by having looser type-checking here. */
173	int _hashmap_merge(Hashmap h, Hashmap other);
174	#define hashmap_merge(h, other) _hashmap_merge(PLAIN_HASHMAP(h), PLAIN_HASHMAP(other))
175	#define ordered_hashmap_merge(h, other) hashmap_merge(h, other)
176
177	int _hashmap_reserve(HashmapBase *h, unsigned entries_add);
178	static inline int hashmap_reserve(Hashmap *h, unsigned entries_add) {	16✔
179	return _hashmap_reserve(HASHMAP_BASE(h), entries_add);	16✔
180	}
181	static inline int ordered_hashmap_reserve(OrderedHashmap *h, unsigned entries_add) {	1,573✔
182	return _hashmap_reserve(HASHMAP_BASE(h), entries_add);	1,573✔
183	}
184
185	int _hashmap_move(HashmapBase h, HashmapBase other);
186	/* Unlike hashmap_merge, hashmap_move does not allow mixing the types. */
187	static inline int hashmap_move(Hashmap h, Hashmap other) {	2,498✔
188	return _hashmap_move(HASHMAP_BASE(h), HASHMAP_BASE(other));	2,498✔
189	}
190	static inline int ordered_hashmap_move(OrderedHashmap h, OrderedHashmap other) {	2✔
191	return _hashmap_move(HASHMAP_BASE(h), HASHMAP_BASE(other));	2✔
192	}
193
194	int _hashmap_move_one(HashmapBase h, HashmapBase other, const void *key);
195	static inline int hashmap_move_one(Hashmap h, Hashmap other, const void *key) {	5✔
196	return _hashmap_move_one(HASHMAP_BASE(h), HASHMAP_BASE(other), key);	5✔
197	}
198	static inline int ordered_hashmap_move_one(OrderedHashmap h, OrderedHashmap other, const void *key) {	582✔
199	return _hashmap_move_one(HASHMAP_BASE(h), HASHMAP_BASE(other), key);	582✔
200	}
201
202	unsigned _hashmap_size(HashmapBase *h) _pure_;
203	static inline unsigned hashmap_size(Hashmap *h) {	1,519,846✔
204	return _hashmap_size(HASHMAP_BASE(h));	1,178,105✔
205	}
206	static inline unsigned ordered_hashmap_size(OrderedHashmap *h) {	9,143,061✔
207	return _hashmap_size(HASHMAP_BASE(h));	9,049,194✔
208	}
209
210	static inline bool hashmap_isempty(Hashmap *h) {	990,476✔
211	return hashmap_size(h) == 0;	921,769✔
212	}
213	static inline bool ordered_hashmap_isempty(OrderedHashmap *h) {	1,300,066✔
214	return ordered_hashmap_size(h) == 0;	1,300,014✔
215	}
216
217	unsigned _hashmap_buckets(HashmapBase *h) _pure_;
218	static inline unsigned hashmap_buckets(Hashmap *h) {	2,776✔
219	return _hashmap_buckets(HASHMAP_BASE(h));	2,776✔
220	}
221	static inline unsigned ordered_hashmap_buckets(OrderedHashmap *h) {	8✔
222	return _hashmap_buckets(HASHMAP_BASE(h));	8✔
223	}
224
225	bool _hashmap_iterate(HashmapBase h, Iterator i, void value, const void key);
226	static inline bool hashmap_iterate(Hashmap h, Iterator i, void value, const void key) {	24,567,955✔
227	return _hashmap_iterate(HASHMAP_BASE(h), i, value, key);	24,619,900✔
228	}
229	static inline bool ordered_hashmap_iterate(OrderedHashmap h, Iterator i, void value, const void key) {	8,946,404✔
230	return _hashmap_iterate(HASHMAP_BASE(h), i, value, key);	8,946,404✔
231	}
232
233	void _hashmap_clear(HashmapBase *h);
234	static inline void hashmap_clear(Hashmap *h) {	112,735✔
235	_hashmap_clear(HASHMAP_BASE(h));	112,735✔
236	}	93,371✔
237	static inline void ordered_hashmap_clear(OrderedHashmap *h) {	17,782✔
238	_hashmap_clear(HASHMAP_BASE(h));	17,782✔
239	}	24✔
240
241	/*
242	* Note about all _first() functions
243	*
244	* For plain Hashmaps and Sets the order of entries is undefined.
245	* The functions find whatever entry is first in the implementation
246	* internal order.
247	*
248	* Only for OrderedHashmaps the order is well defined and finding
249	* the first entry is O(1).
250	*/
251
252	void _hashmap_first_key_and_value(HashmapBase h, bool remove, void **ret_key);
253	static inline void hashmap_steal_first_key_and_value(Hashmap h, void **ret) {	43,477✔
254	return _hashmap_first_key_and_value(HASHMAP_BASE(h), true, ret);	43,477✔
255	}
UNCOV 256	static inline void ordered_hashmap_steal_first_key_and_value(OrderedHashmap h, void **ret) {	×
UNCOV 257	return _hashmap_first_key_and_value(HASHMAP_BASE(h), true, ret);	×
258	}
259	static inline void hashmap_first_key_and_value(Hashmap h, void **ret) {
260	return _hashmap_first_key_and_value(HASHMAP_BASE(h), false, ret);
261	}
262	static inline void ordered_hashmap_first_key_and_value(OrderedHashmap h, void **ret) {
263	return _hashmap_first_key_and_value(HASHMAP_BASE(h), false, ret);
264	}
265
266	static inline void hashmap_steal_first(Hashmap h) {	396,003✔
267	return _hashmap_first_key_and_value(HASHMAP_BASE(h), true, NULL);	396,003✔
268	}
269	static inline void ordered_hashmap_steal_first(OrderedHashmap h) {	7,628,011✔
270	return _hashmap_first_key_and_value(HASHMAP_BASE(h), true, NULL);	7,628,011✔
271	}
272	static inline void hashmap_first(Hashmap h) {	51,978✔
273	return _hashmap_first_key_and_value(HASHMAP_BASE(h), false, NULL);	51,978✔
274	}
275	static inline void ordered_hashmap_first(OrderedHashmap h) {	228,376✔
276	return _hashmap_first_key_and_value(HASHMAP_BASE(h), false, NULL);	228,376✔
277	}
278
279	static inline void _hashmap_first_key(HashmapBase h, bool remove) {	919,501✔
280	void *key = NULL;	919,501✔
281
282	(void) _hashmap_first_key_and_value(HASHMAP_BASE(h), remove, &key);	919,501✔
283	return key;	919,501✔
284	}
285	static inline void hashmap_steal_first_key(Hashmap h) {	904,900✔
286	return _hashmap_first_key(HASHMAP_BASE(h), true);	904,900✔
287	}
288	static inline void ordered_hashmap_steal_first_key(OrderedHashmap h) {	2✔
289	return _hashmap_first_key(HASHMAP_BASE(h), true);	2✔
290	}
291	static inline void hashmap_first_key(Hashmap h) {	14,215✔
292	return _hashmap_first_key(HASHMAP_BASE(h), false);	14,215✔
293	}
294	static inline void ordered_hashmap_first_key(OrderedHashmap h) {	384✔
295	return _hashmap_first_key(HASHMAP_BASE(h), false);	384✔
296	}
297
298	/* no hashmap_next */
299	void* ordered_hashmap_next(OrderedHashmap h, const void key);
300
301	char** _hashmap_get_strv(HashmapBase *h);
302	static inline char** hashmap_get_strv(Hashmap *h) {	1✔
303	return _hashmap_get_strv(HASHMAP_BASE(h));	1✔
304	}
305	static inline char** ordered_hashmap_get_strv(OrderedHashmap *h) {	1✔
306	return _hashmap_get_strv(HASHMAP_BASE(h));	1✔
307	}
308
309	int _hashmap_dump_sorted(HashmapBase h, void *ret, size_t ret_n);
310	static inline int hashmap_dump_sorted(Hashmap h, void *ret, size_t ret_n) {	107,326✔
311	return _hashmap_dump_sorted(HASHMAP_BASE(h), ret, ret_n);	107,326✔
312	}
313	static inline int ordered_hashmap_dump_sorted(OrderedHashmap h, void *ret, size_t ret_n) {	4✔
314	return _hashmap_dump_sorted(HASHMAP_BASE(h), ret, ret_n);	4✔
315	}
316	static inline int set_dump_sorted(Set h, void *ret, size_t ret_n) {	457✔
317	return _hashmap_dump_sorted(HASHMAP_BASE(h), ret, ret_n);	457✔
318	}
319
320	int _hashmap_dump_keys_sorted(HashmapBase h, void *ret, size_t ret_n);
321	static inline int hashmap_dump_keys_sorted(Hashmap h, void *ret, size_t ret_n) {	86✔
322	return _hashmap_dump_keys_sorted(HASHMAP_BASE(h), ret, ret_n);	86✔
323	}
324	static inline int ordered_hashmap_dump_keys_sorted(OrderedHashmap h, void *ret, size_t ret_n) {	2✔
325	return _hashmap_dump_keys_sorted(HASHMAP_BASE(h), ret, ret_n);	2✔
326	}
327
328	/*
329	* Hashmaps are iterated in unpredictable order.
330	* OrderedHashmaps are an exception to this. They are iterated in the order
331	* the entries were inserted.
332	* It is safe to remove the current entry.
333	*/
334	#define _HASHMAP_BASE_FOREACH(e, h, i) \
335	for (Iterator i = ITERATOR_FIRST; _hashmap_iterate((h), &i, (void**)&(e), NULL); )
336	#define HASHMAP_BASE_FOREACH(e, h) \
337	_HASHMAP_BASE_FOREACH(e, h, UNIQ_T(i, UNIQ))
338
339	#define _HASHMAP_FOREACH(e, h, i) \
340	for (Iterator i = ITERATOR_FIRST; hashmap_iterate((h), &i, (void**)&(e), NULL); )
341	#define HASHMAP_FOREACH(e, h) \
342	_HASHMAP_FOREACH(e, h, UNIQ_T(i, UNIQ))
343
344	#define _ORDERED_HASHMAP_FOREACH(e, h, i) \
345	for (Iterator i = ITERATOR_FIRST; ordered_hashmap_iterate((h), &i, (void**)&(e), NULL); )
346	#define ORDERED_HASHMAP_FOREACH(e, h) \
347	_ORDERED_HASHMAP_FOREACH(e, h, UNIQ_T(i, UNIQ))
348
349	#define _HASHMAP_BASE_FOREACH_KEY(e, k, h, i) \
350	for (Iterator i = ITERATOR_FIRST; _hashmap_iterate((h), &i, (void)&(e), (const void) &(k)); )
351	#define HASHMAP_BASE_FOREACH_KEY(e, k, h) \
352	_HASHMAP_BASE_FOREACH_KEY(e, k, h, UNIQ_T(i, UNIQ))
353
354	#define _HASHMAP_FOREACH_KEY(e, k, h, i) \
355	for (Iterator i = ITERATOR_FIRST; hashmap_iterate((h), &i, (void)&(e), (const void) &(k)); )
356	#define HASHMAP_FOREACH_KEY(e, k, h) \
357	_HASHMAP_FOREACH_KEY(e, k, h, UNIQ_T(i, UNIQ))
358
359	#define _ORDERED_HASHMAP_FOREACH_KEY(e, k, h, i) \
360	for (Iterator i = ITERATOR_FIRST; ordered_hashmap_iterate((h), &i, (void)&(e), (const void) &(k)); )
361	#define ORDERED_HASHMAP_FOREACH_KEY(e, k, h) \
362	_ORDERED_HASHMAP_FOREACH_KEY(e, k, h, UNIQ_T(i, UNIQ))
363
364	DEFINE_TRIVIAL_CLEANUP_FUNC(Hashmap*, hashmap_free);	746,413✔
365	DEFINE_TRIVIAL_CLEANUP_FUNC(OrderedHashmap*, ordered_hashmap_free);	58,237✔
366
367	#define _cleanup_hashmap_free_ _cleanup_(hashmap_freep)
368	#define _cleanup_ordered_hashmap_free_ _cleanup_(ordered_hashmap_freep)
369
370	DEFINE_TRIVIAL_CLEANUP_FUNC(IteratedCache*, iterated_cache_free);
371
372	#define _cleanup_iterated_cache_free_ _cleanup_(iterated_cache_freep)
373
374	void hashmap_trim_pools(void);

systemd / systemd / 15263807472

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous