The fifth batch post 2.14
[git/git.git] / hashmap.h
CommitLineData
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
109extern unsigned int strhash(const char *buf);
110extern unsigned int strihash(const char *buf);
111extern unsigned int memhash(const void *buf, size_t len);
112extern unsigned int memihash(const void *buf, size_t len);
f75619bd 113extern 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
123static 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 140struct 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
170typedef 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
178struct 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
222extern 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
233extern 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 248static 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 278extern 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 293static 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 */
310extern 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 */
319extern 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 */
329extern 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 */
338extern 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
345int 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 */
360static 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 */
370struct 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 377extern 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 380extern void *hashmap_iter_next(struct hashmap_iter *iter);
1ecbf31d
SB
381
382/* Initializes the iterator and returns the first entry, if any. */
6a364ced
KB
383static 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
405extern const void *memintern(const void *data, size_t len);
406static inline const char *strintern(const char *string)
407{
408 return memintern(string, strlen(string));
409}
410
6a364ced 411#endif