/src/systemd/src/basic/set.h

Source (jump to first uncovered line)
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once

#include "extract-word.h"
#include "hashmap.h"
#include "macro.h"

#define set_free_and_replace(a, b)              \
        free_and_replace_full(a, b, set_free)

Set* _set_new(const struct hash_ops *hash_ops HASHMAP_DEBUG_PARAMS);
#define set_new(ops) _set_new(ops HASHMAP_DEBUG_SRC_ARGS)

static inline Set* set_free(Set *s) {
        return (Set*) _hashmap_free(HASHMAP_BASE(s), NULL, NULL);
}

static inline Set* set_free_free(Set *s) {
        return (Set*) _hashmap_free(HASHMAP_BASE(s), free, NULL);
}

/* no set_free_free_free */

#define set_copy(s) ((Set*) _hashmap_copy(HASHMAP_BASE(s)  HASHMAP_DEBUG_SRC_ARGS))

int _set_ensure_allocated(Set **s, const struct hash_ops *hash_ops HASHMAP_DEBUG_PARAMS);
#define set_ensure_allocated(h, ops) _set_ensure_allocated(h, ops HASHMAP_DEBUG_SRC_ARGS)

int set_put(Set *s, const void *key);
/* no set_update */
/* no set_replace */
static inline void *set_get(const Set *s, const void *key) {
        return _hashmap_get(HASHMAP_BASE((Set *) s), key);
}
/* no set_get2 */

static inline bool set_contains(const Set *s, const void *key) {
        return _hashmap_contains(HASHMAP_BASE((Set *) s), key);
}

static inline void *set_remove(Set *s, const void *key) {
        return _hashmap_remove(HASHMAP_BASE(s), key);
}

/* no set_remove2 */
/* no set_remove_value */
int set_remove_and_put(Set *s, const void *old_key, const void *new_key);
/* no set_remove_and_replace */
int set_merge(Set *s, Set *other);

static inline int set_reserve(Set *h, unsigned entries_add) {
        return _hashmap_reserve(HASHMAP_BASE(h), entries_add);
}

static inline int set_move(Set *s, Set *other) {
        return _hashmap_move(HASHMAP_BASE(s), HASHMAP_BASE(other));
}

static inline int set_move_one(Set *s, Set *other, const void *key) {
        return _hashmap_move_one(HASHMAP_BASE(s), HASHMAP_BASE(other), key);
}

static inline unsigned set_size(const Set *s) {
        return _hashmap_size(HASHMAP_BASE((Set *) s));
}

static inline bool set_isempty(const Set *s) {
        return set_size(s) == 0;
}

static inline unsigned set_buckets(const Set *s) {
        return _hashmap_buckets(HASHMAP_BASE((Set *) s));
}

static inline bool set_iterate(const Set *s, Iterator *i, void **value) {
        return _hashmap_iterate(HASHMAP_BASE((Set*) s), i, value, NULL);
}

static inline void set_clear(Set *s) {
        _hashmap_clear(HASHMAP_BASE(s), NULL, NULL);
}

static inline void set_clear_free(Set *s) {
        _hashmap_clear(HASHMAP_BASE(s), free, NULL);
}

/* no set_clear_free_free */

static inline void *set_steal_first(Set *s) {
        return _hashmap_first_key_and_value(HASHMAP_BASE(s), true, NULL);
}

#define set_clear_with_destructor(s, f)                 \
        ({                                              \
                Set *_s = (s);                          \
                void *_item;                            \
                while ((_item = set_steal_first(_s)))   \
                        f(_item);                       \
                _s;                                     \
        })
#define set_free_with_destructor(s, f)                  \
        set_free(set_clear_with_destructor(s, f))

/* no set_steal_first_key */
/* no set_first_key */

static inline void *set_first(const Set *s) {
        return _hashmap_first_key_and_value(HASHMAP_BASE((Set *) s), false, NULL);
}

/* no set_next */

static inline char **set_get_strv(Set *s) {
        return _hashmap_get_strv(HASHMAP_BASE(s));
}

int _set_ensure_put(Set **s, const struct hash_ops *hash_ops, const void *key  HASHMAP_DEBUG_PARAMS);
#define set_ensure_put(s, hash_ops, key) _set_ensure_put(s, hash_ops, key  HASHMAP_DEBUG_SRC_ARGS)

int _set_ensure_consume(Set **s, const struct hash_ops *hash_ops, void *key  HASHMAP_DEBUG_PARAMS);
#define set_ensure_consume(s, hash_ops, key) _set_ensure_consume(s, hash_ops, key  HASHMAP_DEBUG_SRC_ARGS)

int set_consume(Set *s, void *value);

int _set_put_strndup_full(Set **s, const struct hash_ops *hash_ops, const char *p, size_t n  HASHMAP_DEBUG_PARAMS);
#define set_put_strndup_full(s, hash_ops, p, n) _set_put_strndup_full(s, hash_ops, p, n  HASHMAP_DEBUG_SRC_ARGS)
#define set_put_strdup_full(s, hash_ops, p) set_put_strndup_full(s, hash_ops, p, SIZE_MAX)
#define set_put_strndup(s, p, n) set_put_strndup_full(s, &string_hash_ops_free, p, n)
#define set_put_strdup(s, p) set_put_strndup(s, p, SIZE_MAX)

int _set_put_strdupv_full(Set **s, const struct hash_ops *hash_ops, char **l  HASHMAP_DEBUG_PARAMS);
#define set_put_strdupv_full(s, hash_ops, l) _set_put_strdupv_full(s, hash_ops, l  HASHMAP_DEBUG_SRC_ARGS)
#define set_put_strdupv(s, l) set_put_strdupv_full(s, &string_hash_ops_free, l)

int set_put_strsplit(Set *s, const char *v, const char *separators, ExtractFlags flags);

#define _SET_FOREACH(e, s, i) \
        for (Iterator i = ITERATOR_FIRST; set_iterate((s), &i, (void**)&(e)); )
#define SET_FOREACH(e, s) \
        _SET_FOREACH(e, s, UNIQ_T(i, UNIQ))

#define SET_FOREACH_MOVE(e, d, s)                                       \
        for (; ({ e = set_first(s); assert_se(!e || set_move_one(d, s, e) >= 0); e; }); )

DEFINE_TRIVIAL_CLEANUP_FUNC(Set*, set_free);
DEFINE_TRIVIAL_CLEANUP_FUNC(Set*, set_free_free);

#define _cleanup_set_free_ _cleanup_(set_freep)
#define _cleanup_set_free_free_ _cleanup_(set_free_freep)

int set_strjoin(Set *s, const char *separator, bool wrap_with_separator, char **ret);

bool set_equal(Set *a, Set *b);

bool set_fnmatch(Set *include_patterns, Set *exclude_patterns, const char *needle);

Line	Count	Source (jump to first uncovered line)
1		/* SPDX-License-Identifier: LGPL-2.1-or-later */
2		#pragma once
3
4		#include "extract-word.h"
5		#include "hashmap.h"
6		#include "macro.h"
7
8		#define set_free_and_replace(a, b) \
9		free_and_replace_full(a, b, set_free)
10
11		Set* _set_new(const struct hash_ops *hash_ops HASHMAP_DEBUG_PARAMS);
12		#define set_new(ops) _set_new(ops HASHMAP_DEBUG_SRC_ARGS)
13
14	0	static inline Set* set_free(Set *s) {
15	0	return (Set*) _hashmap_free(HASHMAP_BASE(s), NULL, NULL);
16	0	} Unexecuted instantiation: fuzz-link-parser.c:set_free Unexecuted instantiation: link-config.c:set_free Unexecuted instantiation: link-config-gperf.c:set_free
17
18	0	static inline Set* set_free_free(Set *s) {
19	0	return (Set*) _hashmap_free(HASHMAP_BASE(s), free, NULL);
20	0	} Unexecuted instantiation: fuzz-link-parser.c:set_free_free Unexecuted instantiation: link-config.c:set_free_free Unexecuted instantiation: link-config-gperf.c:set_free_free
21
22		/* no set_free_free_free */
23
24		#define set_copy(s) ((Set*) _hashmap_copy(HASHMAP_BASE(s) HASHMAP_DEBUG_SRC_ARGS))
25
26		int _set_ensure_allocated(Set *s, const struct hash_ops hash_ops HASHMAP_DEBUG_PARAMS);
27		#define set_ensure_allocated(h, ops) _set_ensure_allocated(h, ops HASHMAP_DEBUG_SRC_ARGS)
28
29		int set_put(Set s, const void key);
30		/* no set_update */
31		/* no set_replace */
32	0	static inline void set_get(const Set s, const void *key) {
33	0	return _hashmap_get(HASHMAP_BASE((Set *) s), key);
34	0	} Unexecuted instantiation: fuzz-link-parser.c:set_get Unexecuted instantiation: link-config.c:set_get Unexecuted instantiation: link-config-gperf.c:set_get
35		/* no set_get2 */
36
37	0	static inline bool set_contains(const Set s, const void key) {
38	0	return _hashmap_contains(HASHMAP_BASE((Set *) s), key);
39	0	} Unexecuted instantiation: fuzz-link-parser.c:set_contains Unexecuted instantiation: link-config.c:set_contains Unexecuted instantiation: link-config-gperf.c:set_contains
40
41	0	static inline void set_remove(Set s, const void *key) {
42	0	return _hashmap_remove(HASHMAP_BASE(s), key);
43	0	} Unexecuted instantiation: fuzz-link-parser.c:set_remove Unexecuted instantiation: link-config.c:set_remove Unexecuted instantiation: link-config-gperf.c:set_remove
44
45		/* no set_remove2 */
46		/* no set_remove_value */
47		int set_remove_and_put(Set s, const void old_key, const void *new_key);
48		/* no set_remove_and_replace */
49		int set_merge(Set s, Set other);
50
51	0	static inline int set_reserve(Set *h, unsigned entries_add) {
52	0	return _hashmap_reserve(HASHMAP_BASE(h), entries_add);
53	0	} Unexecuted instantiation: fuzz-link-parser.c:set_reserve Unexecuted instantiation: link-config.c:set_reserve Unexecuted instantiation: link-config-gperf.c:set_reserve
54
55	0	static inline int set_move(Set s, Set other) {
56	0	return _hashmap_move(HASHMAP_BASE(s), HASHMAP_BASE(other));
57	0	} Unexecuted instantiation: fuzz-link-parser.c:set_move Unexecuted instantiation: link-config.c:set_move Unexecuted instantiation: link-config-gperf.c:set_move
58
59	0	static inline int set_move_one(Set s, Set other, const void *key) {
60	0	return _hashmap_move_one(HASHMAP_BASE(s), HASHMAP_BASE(other), key);
61	0	} Unexecuted instantiation: fuzz-link-parser.c:set_move_one Unexecuted instantiation: link-config.c:set_move_one Unexecuted instantiation: link-config-gperf.c:set_move_one
62
63	0	static inline unsigned set_size(const Set *s) {
64	0	return _hashmap_size(HASHMAP_BASE((Set *) s));
65	0	} Unexecuted instantiation: fuzz-link-parser.c:set_size Unexecuted instantiation: link-config.c:set_size Unexecuted instantiation: link-config-gperf.c:set_size
66
67	0	static inline bool set_isempty(const Set *s) {
68	0	return set_size(s) == 0;
69	0	} Unexecuted instantiation: fuzz-link-parser.c:set_isempty Unexecuted instantiation: link-config.c:set_isempty Unexecuted instantiation: link-config-gperf.c:set_isempty
70
71	0	static inline unsigned set_buckets(const Set *s) {
72	0	return _hashmap_buckets(HASHMAP_BASE((Set *) s));
73	0	} Unexecuted instantiation: fuzz-link-parser.c:set_buckets Unexecuted instantiation: link-config.c:set_buckets Unexecuted instantiation: link-config-gperf.c:set_buckets
74
75	0	static inline bool set_iterate(const Set s, Iterator i, void **value) {
76	0	return _hashmap_iterate(HASHMAP_BASE((Set*) s), i, value, NULL);
77	0	} Unexecuted instantiation: fuzz-link-parser.c:set_iterate Unexecuted instantiation: link-config.c:set_iterate Unexecuted instantiation: link-config-gperf.c:set_iterate
78
79	0	static inline void set_clear(Set *s) {
80	0	_hashmap_clear(HASHMAP_BASE(s), NULL, NULL);
81	0	} Unexecuted instantiation: fuzz-link-parser.c:set_clear Unexecuted instantiation: link-config.c:set_clear Unexecuted instantiation: link-config-gperf.c:set_clear
82
83	0	static inline void set_clear_free(Set *s) {
84	0	_hashmap_clear(HASHMAP_BASE(s), free, NULL);
85	0	} Unexecuted instantiation: fuzz-link-parser.c:set_clear_free Unexecuted instantiation: link-config.c:set_clear_free Unexecuted instantiation: link-config-gperf.c:set_clear_free
86
87		/* no set_clear_free_free */
88
89	0	static inline void set_steal_first(Set s) {
90	0	return _hashmap_first_key_and_value(HASHMAP_BASE(s), true, NULL);
91	0	} Unexecuted instantiation: fuzz-link-parser.c:set_steal_first Unexecuted instantiation: link-config.c:set_steal_first Unexecuted instantiation: link-config-gperf.c:set_steal_first
92
93		#define set_clear_with_destructor(s, f) \
94		({ \
95		Set *_s = (s); \
96		void *_item; \
97		while ((_item = set_steal_first(_s))) \
98		f(_item); \
99		_s; \
100		})
101		#define set_free_with_destructor(s, f) \
102		set_free(set_clear_with_destructor(s, f))
103
104		/* no set_steal_first_key */
105		/* no set_first_key */
106
107	0	static inline void set_first(const Set s) {
108	0	return _hashmap_first_key_and_value(HASHMAP_BASE((Set *) s), false, NULL);
109	0	} Unexecuted instantiation: fuzz-link-parser.c:set_first Unexecuted instantiation: link-config.c:set_first Unexecuted instantiation: link-config-gperf.c:set_first
110
111		/* no set_next */
112
113	0	static inline char *set_get_strv(Set s) {
114	0	return _hashmap_get_strv(HASHMAP_BASE(s));
115	0	} Unexecuted instantiation: fuzz-link-parser.c:set_get_strv Unexecuted instantiation: link-config.c:set_get_strv Unexecuted instantiation: link-config-gperf.c:set_get_strv
116
117		int _set_ensure_put(Set *s, const struct hash_ops hash_ops, const void *key HASHMAP_DEBUG_PARAMS);
118		#define set_ensure_put(s, hash_ops, key) _set_ensure_put(s, hash_ops, key HASHMAP_DEBUG_SRC_ARGS)
119
120		int _set_ensure_consume(Set *s, const struct hash_ops hash_ops, void *key HASHMAP_DEBUG_PARAMS);
121		#define set_ensure_consume(s, hash_ops, key) _set_ensure_consume(s, hash_ops, key HASHMAP_DEBUG_SRC_ARGS)
122
123		int set_consume(Set s, void value);
124
125		int _set_put_strndup_full(Set *s, const struct hash_ops hash_ops, const char *p, size_t n HASHMAP_DEBUG_PARAMS);
126		#define set_put_strndup_full(s, hash_ops, p, n) _set_put_strndup_full(s, hash_ops, p, n HASHMAP_DEBUG_SRC_ARGS)
127		#define set_put_strdup_full(s, hash_ops, p) set_put_strndup_full(s, hash_ops, p, SIZE_MAX)
128		#define set_put_strndup(s, p, n) set_put_strndup_full(s, &string_hash_ops_free, p, n)
129		#define set_put_strdup(s, p) set_put_strndup(s, p, SIZE_MAX)
130
131		int _set_put_strdupv_full(Set *s, const struct hash_ops hash_ops, char **l HASHMAP_DEBUG_PARAMS);
132		#define set_put_strdupv_full(s, hash_ops, l) _set_put_strdupv_full(s, hash_ops, l HASHMAP_DEBUG_SRC_ARGS)
133		#define set_put_strdupv(s, l) set_put_strdupv_full(s, &string_hash_ops_free, l)
134
135		int set_put_strsplit(Set s, const char v, const char *separators, ExtractFlags flags);
136
137		#define _SET_FOREACH(e, s, i) \
138		for (Iterator i = ITERATOR_FIRST; set_iterate((s), &i, (void**)&(e)); )
139		#define SET_FOREACH(e, s) \
140		_SET_FOREACH(e, s, UNIQ_T(i, UNIQ))
141
142		#define SET_FOREACH_MOVE(e, d, s) \
143		for (; ({ e = set_first(s); assert_se(!e \|\| set_move_one(d, s, e) >= 0); e; }); )
144
145		DEFINE_TRIVIAL_CLEANUP_FUNC(Set*, set_free);
146		DEFINE_TRIVIAL_CLEANUP_FUNC(Set*, set_free_free);
147
148		#define _cleanup_set_free_ _cleanup_(set_freep)
149		#define _cleanup_set_free_free_ _cleanup_(set_free_freep)
150
151		int set_strjoin(Set s, const char separator, bool wrap_with_separator, char **ret);
152
153		bool set_equal(Set a, Set b);
154
155		bool set_fnmatch(Set include_patterns, Set exclude_patterns, const char *needle);

Coverage Report

Created: 2024-01-23 06:37