]>
Commit | Line | Data |
---|---|---|
6a364ced KB |
1 | #ifndef HASHMAP_H |
2 | #define HASHMAP_H | |
3 | ||
4 | /* | |
5 | * Generic implementation of hash-based key-value mappings. | |
1ecbf31d SB |
6 | * |
7 | * An example that maps long to a string: | |
8 | * For the sake of the example this allows to lookup exact values, too | |
9 | * (i.e. it is operated as a set, the value is part of the key) | |
10 | * ------------------------------------- | |
11 | * | |
12 | * struct hashmap map; | |
13 | * struct long2string { | |
14 | * struct hashmap_entry ent; // must be the first member! | |
15 | * long key; | |
16 | * char value[FLEX_ARRAY]; // be careful with allocating on stack! | |
17 | * }; | |
18 | * | |
19 | * #define COMPARE_VALUE 1 | |
20 | * | |
21 | * static int long2string_cmp(const struct long2string *e1, | |
22 | * const struct long2string *e2, | |
23 | * const void *keydata, const void *userdata) | |
24 | * { | |
25 | * char *string = keydata; | |
26 | * unsigned *flags = (unsigned*)userdata; | |
27 | * | |
28 | * if (flags & COMPARE_VALUE) | |
29 | * return !(e1->key == e2->key) || (keydata ? | |
30 | * strcmp(e1->value, keydata) : strcmp(e1->value, e2->value)); | |
31 | * else | |
32 | * return !(e1->key == e2->key); | |
33 | * } | |
34 | * | |
35 | * int main(int argc, char **argv) | |
36 | * { | |
37 | * long key; | |
38 | * char *value, *action; | |
39 | * | |
40 | * unsigned flags = ALLOW_DUPLICATE_KEYS; | |
41 | * | |
42 | * hashmap_init(&map, (hashmap_cmp_fn) long2string_cmp, &flags, 0); | |
43 | * | |
44 | * while (scanf("%s %l %s", action, key, value)) { | |
45 | * | |
46 | * if (!strcmp("add", action)) { | |
47 | * struct long2string *e; | |
48 | * e = malloc(sizeof(struct long2string) + strlen(value)); | |
49 | * hashmap_entry_init(e, memhash(&key, sizeof(long))); | |
50 | * e->key = key; | |
51 | * memcpy(e->value, value, strlen(value)); | |
52 | * hashmap_add(&map, e); | |
53 | * } | |
54 | * | |
55 | * if (!strcmp("print_all_by_key", action)) { | |
56 | * flags &= ~COMPARE_VALUE; | |
57 | * | |
58 | * struct long2string k; | |
59 | * hashmap_entry_init(&k, memhash(&key, sizeof(long))); | |
60 | * k.key = key; | |
61 | * | |
62 | * struct long2string *e = hashmap_get(&map, &k, NULL); | |
63 | * if (e) { | |
64 | * printf("first: %l %s\n", e->key, e->value); | |
65 | * while (e = hashmap_get_next(&map, e)) | |
66 | * printf("found more: %l %s\n", e->key, e->value); | |
67 | * } | |
68 | * } | |
69 | * | |
70 | * if (!strcmp("has_exact_match", action)) { | |
71 | * flags |= COMPARE_VALUE; | |
72 | * | |
73 | * struct long2string *e; | |
74 | * e = malloc(sizeof(struct long2string) + strlen(value)); | |
75 | * hashmap_entry_init(e, memhash(&key, sizeof(long))); | |
76 | * e->key = key; | |
77 | * memcpy(e->value, value, strlen(value)); | |
78 | * | |
79 | * printf("%s found\n", hashmap_get(&map, e, NULL) ? "" : "not"); | |
80 | * } | |
81 | * | |
82 | * if (!strcmp("has_exact_match_no_heap_alloc", action)) { | |
83 | * flags |= COMPARE_VALUE; | |
84 | * | |
85 | * struct long2string e; | |
86 | * hashmap_entry_init(e, memhash(&key, sizeof(long))); | |
87 | * e.key = key; | |
88 | * | |
89 | * printf("%s found\n", hashmap_get(&map, e, value) ? "" : "not"); | |
90 | * } | |
91 | * | |
92 | * if (!strcmp("end", action)) { | |
93 | * hashmap_free(&map, 1); | |
94 | * break; | |
95 | * } | |
96 | * } | |
97 | * } | |
6a364ced KB |
98 | */ |
99 | ||
1ecbf31d SB |
100 | /* |
101 | * Ready-to-use hash functions for strings, using the FNV-1 algorithm (see | |
102 | * http://www.isthe.com/chongo/tech/comp/fnv). | |
103 | * `strhash` and `strihash` take 0-terminated strings, while `memhash` and | |
104 | * `memihash` operate on arbitrary-length memory. | |
105 | * `strihash` and `memihash` are case insensitive versions. | |
106 | * `memihash_cont` is a variant of `memihash` that allows a computation to be | |
107 | * continued with another chunk of data. | |
108 | */ | |
6a364ced KB |
109 | extern unsigned int strhash(const char *buf); |
110 | extern unsigned int strihash(const char *buf); | |
111 | extern unsigned int memhash(const void *buf, size_t len); | |
112 | extern unsigned int memihash(const void *buf, size_t len); | |
f75619bd | 113 | extern unsigned int memihash_cont(unsigned int hash_seed, const void *buf, size_t len); |
6a364ced | 114 | |
1ecbf31d SB |
115 | /* |
116 | * Converts a cryptographic hash (e.g. SHA-1) into an int-sized hash code | |
117 | * for use in hash tables. Cryptographic hashes are supposed to have | |
118 | * uniform distribution, so in contrast to `memhash()`, this just copies | |
119 | * the first `sizeof(int)` bytes without shuffling any bits. Note that | |
120 | * the results will be different on big-endian and little-endian | |
121 | * platforms, so they should not be stored or transferred over the net. | |
122 | */ | |
039dc71a KB |
123 | static inline unsigned int sha1hash(const unsigned char *sha1) |
124 | { | |
125 | /* | |
126 | * Equivalent to 'return *(unsigned int *)sha1;', but safe on | |
127 | * platforms that don't support unaligned reads. | |
128 | */ | |
129 | unsigned int hash; | |
130 | memcpy(&hash, sha1, sizeof(hash)); | |
131 | return hash; | |
132 | } | |
133 | ||
1ecbf31d SB |
134 | /* |
135 | * struct hashmap_entry is an opaque structure representing an entry in the | |
136 | * hash table, which must be used as first member of user data structures. | |
137 | * Ideally it should be followed by an int-sized member to prevent unused | |
138 | * memory on 64-bit systems due to alignment. | |
139 | */ | |
6a364ced | 140 | struct hashmap_entry { |
1ecbf31d SB |
141 | /* |
142 | * next points to the next entry in case of collisions (i.e. if | |
143 | * multiple entries map to the same bucket) | |
144 | */ | |
6a364ced | 145 | struct hashmap_entry *next; |
1ecbf31d SB |
146 | |
147 | /* entry's hash code */ | |
6a364ced KB |
148 | unsigned int hash; |
149 | }; | |
150 | ||
1ecbf31d SB |
151 | /* |
152 | * User-supplied function to test two hashmap entries for equality. Shall | |
153 | * return 0 if the entries are equal. | |
154 | * | |
155 | * This function is always called with non-NULL `entry` and `entry_or_key` | |
156 | * parameters that have the same hash code. | |
157 | * | |
158 | * When looking up an entry, the `key` and `keydata` parameters to hashmap_get | |
159 | * and hashmap_remove are always passed as second `entry_or_key` and third | |
160 | * argument `keydata`, respectively. Otherwise, `keydata` is NULL. | |
161 | * | |
162 | * When it is too expensive to allocate a user entry (either because it is | |
163 | * large or varialbe sized, such that it is not on the stack), then the | |
164 | * relevant data to check for equality should be passed via `keydata`. | |
165 | * In this case `key` can be a stripped down version of the user key data | |
166 | * or even just a hashmap_entry having the correct hash. | |
167 | * | |
168 | * The `hashmap_cmp_fn_data` entry is the pointer given in the init function. | |
169 | */ | |
7663cdc8 SB |
170 | typedef int (*hashmap_cmp_fn)(const void *hashmap_cmp_fn_data, |
171 | const void *entry, const void *entry_or_key, | |
172 | const void *keydata); | |
6a364ced | 173 | |
1ecbf31d SB |
174 | /* |
175 | * struct hashmap is the hash table structure. Members can be used as follows, | |
176 | * but should not be modified directly. | |
177 | */ | |
6a364ced KB |
178 | struct hashmap { |
179 | struct hashmap_entry **table; | |
1ecbf31d SB |
180 | |
181 | /* Stores the comparison function specified in `hashmap_init()`. */ | |
6a364ced | 182 | hashmap_cmp_fn cmpfn; |
7663cdc8 | 183 | const void *cmpfn_data; |
6a364ced | 184 | |
1ecbf31d SB |
185 | /* total number of entries (0 means the hashmap is empty) */ |
186 | unsigned int size; | |
187 | ||
188 | /* | |
189 | * tablesize is the allocated size of the hash table. A non-0 value | |
190 | * indicates that the hashmap is initialized. It may also be useful | |
191 | * for statistical purposes (i.e. `size / tablesize` is the current | |
192 | * load factor). | |
193 | */ | |
194 | unsigned int tablesize; | |
195 | ||
196 | unsigned int grow_at; | |
197 | unsigned int shrink_at; | |
198 | ||
199 | /* See `hashmap_disallow_rehash`. */ | |
200 | unsigned disallow_rehash : 1; | |
6a364ced KB |
201 | }; |
202 | ||
203 | /* hashmap functions */ | |
204 | ||
1ecbf31d SB |
205 | /* |
206 | * Initializes a hashmap structure. | |
207 | * | |
208 | * `map` is the hashmap to initialize. | |
209 | * | |
210 | * The `equals_function` can be specified to compare two entries for equality. | |
211 | * If NULL, entries are considered equal if their hash codes are equal. | |
212 | * | |
213 | * The `equals_function_data` parameter can be used to provide additional data | |
214 | * (a callback cookie) that will be passed to `equals_function` each time it | |
215 | * is called. This allows a single `equals_function` to implement multiple | |
216 | * comparison functions. | |
217 | * | |
218 | * If the total number of entries is known in advance, the `initial_size` | |
219 | * parameter may be used to preallocate a sufficiently large table and thus | |
220 | * prevent expensive resizing. If 0, the table is dynamically resized. | |
221 | */ | |
7663cdc8 SB |
222 | extern void hashmap_init(struct hashmap *map, |
223 | hashmap_cmp_fn equals_function, | |
224 | const void *equals_function_data, | |
225 | size_t initial_size); | |
1ecbf31d SB |
226 | |
227 | /* | |
228 | * Frees a hashmap structure and allocated memory. | |
229 | * | |
230 | * If `free_entries` is true, each hashmap_entry in the map is freed as well | |
231 | * using stdlibs free(). | |
232 | */ | |
6a364ced KB |
233 | extern void hashmap_free(struct hashmap *map, int free_entries); |
234 | ||
235 | /* hashmap_entry functions */ | |
236 | ||
1ecbf31d SB |
237 | /* |
238 | * Initializes a hashmap_entry structure. | |
239 | * | |
240 | * `entry` points to the entry to initialize. | |
241 | * `hash` is the hash code of the entry. | |
242 | * | |
243 | * The hashmap_entry structure does not hold references to external resources, | |
244 | * and it is safe to just discard it once you are done with it (i.e. if | |
245 | * your structure was allocated with xmalloc(), you can just free(3) it, | |
246 | * and if it is on stack, you can just let it go out of scope). | |
247 | */ | |
b6aad994 | 248 | static inline void hashmap_entry_init(void *entry, unsigned int hash) |
6a364ced KB |
249 | { |
250 | struct hashmap_entry *e = entry; | |
251 | e->hash = hash; | |
252 | e->next = NULL; | |
253 | } | |
1ecbf31d SB |
254 | |
255 | /* | |
256 | * Returns the hashmap entry for the specified key, or NULL if not found. | |
257 | * | |
258 | * `map` is the hashmap structure. | |
259 | * | |
260 | * `key` is a user data structure that starts with hashmap_entry that has at | |
261 | * least been initialized with the proper hash code (via `hashmap_entry_init`). | |
262 | * | |
263 | * `keydata` is a data structure that holds just enough information to check | |
264 | * for equality to a given entry. | |
265 | * | |
266 | * If the key data is variable-sized (e.g. a FLEX_ARRAY string) or quite large, | |
267 | * it is undesirable to create a full-fledged entry structure on the heap and | |
268 | * copy all the key data into the structure. | |
269 | * | |
270 | * In this case, the `keydata` parameter can be used to pass | |
271 | * variable-sized key data directly to the comparison function, and the `key` | |
272 | * parameter can be a stripped-down, fixed size entry structure allocated on the | |
273 | * stack. | |
274 | * | |
275 | * If an entry with matching hash code is found, `key` and `keydata` are passed | |
276 | * to `hashmap_cmp_fn` to decide whether the entry matches the key. | |
277 | */ | |
6a364ced | 278 | extern void *hashmap_get(const struct hashmap *map, const void *key, |
1ecbf31d | 279 | const void *keydata); |
6a364ced | 280 | |
1ecbf31d SB |
281 | /* |
282 | * Returns the hashmap entry for the specified hash code and key data, | |
283 | * or NULL if not found. | |
284 | * | |
285 | * `map` is the hashmap structure. | |
286 | * `hash` is the hash code of the entry to look up. | |
287 | * | |
288 | * If an entry with matching hash code is found, `keydata` is passed to | |
289 | * `hashmap_cmp_fn` to decide whether the entry matches the key. The | |
290 | * `entry_or_key` parameter of `hashmap_cmp_fn` points to a hashmap_entry | |
291 | * structure that should not be used in the comparison. | |
292 | */ | |
ab73a9d1 | 293 | static inline void *hashmap_get_from_hash(const struct hashmap *map, |
1ecbf31d SB |
294 | unsigned int hash, |
295 | const void *keydata) | |
ab73a9d1 KB |
296 | { |
297 | struct hashmap_entry key; | |
298 | hashmap_entry_init(&key, hash); | |
299 | return hashmap_get(map, &key, keydata); | |
300 | } | |
301 | ||
1ecbf31d SB |
302 | /* |
303 | * Returns the next equal hashmap entry, or NULL if not found. This can be | |
304 | * used to iterate over duplicate entries (see `hashmap_add`). | |
305 | * | |
306 | * `map` is the hashmap structure. | |
307 | * `entry` is the hashmap_entry to start the search from, obtained via a previous | |
308 | * call to `hashmap_get` or `hashmap_get_next`. | |
309 | */ | |
310 | extern void *hashmap_get_next(const struct hashmap *map, const void *entry); | |
311 | ||
312 | /* | |
313 | * Adds a hashmap entry. This allows to add duplicate entries (i.e. | |
314 | * separate values with the same key according to hashmap_cmp_fn). | |
315 | * | |
316 | * `map` is the hashmap structure. | |
317 | * `entry` is the entry to add. | |
318 | */ | |
319 | extern void hashmap_add(struct hashmap *map, void *entry); | |
320 | ||
321 | /* | |
322 | * Adds or replaces a hashmap entry. If the hashmap contains duplicate | |
323 | * entries equal to the specified entry, only one of them will be replaced. | |
324 | * | |
325 | * `map` is the hashmap structure. | |
326 | * `entry` is the entry to add or replace. | |
327 | * Returns the replaced entry, or NULL if not found (i.e. the entry was added). | |
328 | */ | |
329 | extern void *hashmap_put(struct hashmap *map, void *entry); | |
330 | ||
331 | /* | |
332 | * Removes a hashmap entry matching the specified key. If the hashmap contains | |
333 | * duplicate entries equal to the specified key, only one of them will be | |
334 | * removed. Returns the removed entry, or NULL if not found. | |
335 | * | |
336 | * Argument explanation is the same as in `hashmap_get`. | |
337 | */ | |
338 | extern void *hashmap_remove(struct hashmap *map, const void *key, | |
339 | const void *keydata); | |
340 | ||
341 | /* | |
342 | * Returns the `bucket` an entry is stored in. | |
343 | * Useful for multithreaded read access. | |
344 | */ | |
0607e100 JH |
345 | int hashmap_bucket(const struct hashmap *map, unsigned int hash); |
346 | ||
347 | /* | |
348 | * Disallow/allow rehashing of the hashmap. | |
1ecbf31d SB |
349 | * This is useful if the caller knows that the hashmap needs multi-threaded |
350 | * access. The caller is still required to guard/lock searches and inserts | |
351 | * in a manner appropriate to their usage. This simply prevents the table | |
352 | * from being unexpectedly re-mapped. | |
0607e100 | 353 | * |
1ecbf31d SB |
354 | * It is up to the caller to ensure that the hashmap is initialized to a |
355 | * reasonable size to prevent poor performance. | |
0607e100 | 356 | * |
1ecbf31d SB |
357 | * A call to allow rehashing does not force a rehash; that might happen |
358 | * with the next insert or delete. | |
0607e100 JH |
359 | */ |
360 | static inline void hashmap_disallow_rehash(struct hashmap *map, unsigned value) | |
361 | { | |
362 | map->disallow_rehash = value; | |
363 | } | |
364 | ||
1ecbf31d SB |
365 | /* |
366 | * Used to iterate over all entries of a hashmap. Note that it is | |
367 | * not safe to add or remove entries to the hashmap while | |
368 | * iterating. | |
369 | */ | |
370 | struct hashmap_iter { | |
371 | struct hashmap *map; | |
372 | struct hashmap_entry *next; | |
373 | unsigned int tablepos; | |
374 | }; | |
6a364ced | 375 | |
1ecbf31d | 376 | /* Initializes a `hashmap_iter` structure. */ |
6a364ced | 377 | extern void hashmap_iter_init(struct hashmap *map, struct hashmap_iter *iter); |
1ecbf31d SB |
378 | |
379 | /* Returns the next hashmap_entry, or NULL if there are no more entries. */ | |
6a364ced | 380 | extern void *hashmap_iter_next(struct hashmap_iter *iter); |
1ecbf31d SB |
381 | |
382 | /* Initializes the iterator and returns the first entry, if any. */ | |
6a364ced KB |
383 | static inline void *hashmap_iter_first(struct hashmap *map, |
384 | struct hashmap_iter *iter) | |
385 | { | |
386 | hashmap_iter_init(map, iter); | |
387 | return hashmap_iter_next(iter); | |
388 | } | |
389 | ||
1ecbf31d | 390 | /* String interning */ |
7b64d42d | 391 | |
1ecbf31d SB |
392 | /* |
393 | * Returns the unique, interned version of the specified string or data, | |
394 | * similar to the `String.intern` API in Java and .NET, respectively. | |
395 | * Interned strings remain valid for the entire lifetime of the process. | |
396 | * | |
397 | * Can be used as `[x]strdup()` or `xmemdupz` replacement, except that interned | |
398 | * strings / data must not be modified or freed. | |
399 | * | |
400 | * Interned strings are best used for short strings with high probability of | |
401 | * duplicates. | |
402 | * | |
403 | * Uses a hashmap to store the pool of interned strings. | |
404 | */ | |
7b64d42d KB |
405 | extern const void *memintern(const void *data, size_t len); |
406 | static inline const char *strintern(const char *string) | |
407 | { | |
408 | return memintern(string, strlen(string)); | |
409 | } | |
410 | ||
6a364ced | 411 | #endif |