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