123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548 |
- #ifndef HASHMAP_H
- #define HASHMAP_H
- #include "hash.h"
- /*
- * Generic implementation of hash-based key-value mappings.
- *
- * An example that maps long to a string:
- * For the sake of the example this allows to lookup exact values, too
- * (i.e. it is operated as a set, the value is part of the key)
- * -------------------------------------
- *
- * struct hashmap map;
- * struct long2string {
- * struct hashmap_entry ent;
- * long key;
- * char value[FLEX_ARRAY]; // be careful with allocating on stack!
- * };
- *
- * #define COMPARE_VALUE 1
- *
- * static int long2string_cmp(const void *hashmap_cmp_fn_data,
- * const struct hashmap_entry *eptr,
- * const struct hashmap_entry *entry_or_key,
- * const void *keydata)
- * {
- * const char *string = keydata;
- * unsigned flags = *(unsigned *)hashmap_cmp_fn_data;
- * const struct long2string *e1, *e2;
- *
- * e1 = container_of(eptr, const struct long2string, ent);
- * e2 = container_of(entry_or_key, const struct long2string, ent);
- *
- * if (flags & COMPARE_VALUE)
- * return e1->key != e2->key ||
- * strcmp(e1->value, string ? string : e2->value);
- * else
- * return e1->key != e2->key;
- * }
- *
- * int main(int argc, char **argv)
- * {
- * long key;
- * char value[255], action[32];
- * unsigned flags = 0;
- *
- * hashmap_init(&map, long2string_cmp, &flags, 0);
- *
- * while (scanf("%s %ld %s", action, &key, value)) {
- *
- * if (!strcmp("add", action)) {
- * struct long2string *e;
- * FLEX_ALLOC_STR(e, value, value);
- * hashmap_entry_init(&e->ent, memhash(&key, sizeof(long)));
- * e->key = key;
- * hashmap_add(&map, &e->ent);
- * }
- *
- * if (!strcmp("print_all_by_key", action)) {
- * struct long2string k, *e;
- * hashmap_entry_init(&k.ent, memhash(&key, sizeof(long)));
- * k.key = key;
- *
- * flags &= ~COMPARE_VALUE;
- * e = hashmap_get_entry(&map, &k, ent, NULL);
- * if (e) {
- * printf("first: %ld %s\n", e->key, e->value);
- * while ((e = hashmap_get_next_entry(&map, e,
- * struct long2string, ent))) {
- * printf("found more: %ld %s\n", e->key, e->value);
- * }
- * }
- * }
- *
- * if (!strcmp("has_exact_match", action)) {
- * struct long2string *e;
- * FLEX_ALLOC_STR(e, value, value);
- * hashmap_entry_init(&e->ent, memhash(&key, sizeof(long)));
- * e->key = key;
- *
- * flags |= COMPARE_VALUE;
- * printf("%sfound\n",
- * hashmap_get(&map, &e->ent, NULL) ? "" : "not ");
- * free(e);
- * }
- *
- * if (!strcmp("has_exact_match_no_heap_alloc", action)) {
- * struct long2string k;
- * hashmap_entry_init(&k.ent, memhash(&key, sizeof(long)));
- * k.key = key;
- *
- * flags |= COMPARE_VALUE;
- * printf("%sfound\n",
- * hashmap_get(&map, &k.ent, value) ? "" : "not ");
- * }
- *
- * if (!strcmp("end", action)) {
- * hashmap_free_entries(&map, struct long2string, ent);
- * break;
- * }
- * }
- *
- * return 0;
- * }
- */
- /*
- * Ready-to-use hash functions for strings, using the FNV-1 algorithm (see
- * http://www.isthe.com/chongo/tech/comp/fnv).
- * `strhash` and `strihash` take 0-terminated strings, while `memhash` and
- * `memihash` operate on arbitrary-length memory.
- * `strihash` and `memihash` are case insensitive versions.
- * `memihash_cont` is a variant of `memihash` that allows a computation to be
- * continued with another chunk of data.
- */
- unsigned int strhash(const char *buf);
- unsigned int strihash(const char *buf);
- unsigned int memhash(const void *buf, size_t len);
- unsigned int memihash(const void *buf, size_t len);
- unsigned int memihash_cont(unsigned int hash_seed, const void *buf, size_t len);
- /*
- * Converts a cryptographic hash (e.g. SHA-1) into an int-sized hash code
- * for use in hash tables. Cryptographic hashes are supposed to have
- * uniform distribution, so in contrast to `memhash()`, this just copies
- * the first `sizeof(int)` bytes without shuffling any bits. Note that
- * the results will be different on big-endian and little-endian
- * platforms, so they should not be stored or transferred over the net.
- */
- static inline unsigned int oidhash(const struct object_id *oid)
- {
- /*
- * Equivalent to 'return *(unsigned int *)oid->hash;', but safe on
- * platforms that don't support unaligned reads.
- */
- unsigned int hash;
- memcpy(&hash, oid->hash, sizeof(hash));
- return hash;
- }
- /*
- * struct hashmap_entry is an opaque structure representing an entry in the
- * hash table.
- * Ideally it should be followed by an int-sized member to prevent unused
- * memory on 64-bit systems due to alignment.
- */
- struct hashmap_entry {
- /*
- * next points to the next entry in case of collisions (i.e. if
- * multiple entries map to the same bucket)
- */
- struct hashmap_entry *next;
- /* entry's hash code */
- unsigned int hash;
- };
- /*
- * User-supplied function to test two hashmap entries for equality. Shall
- * return 0 if the entries are equal.
- *
- * This function is always called with non-NULL `entry` and `entry_or_key`
- * parameters that have the same hash code.
- *
- * When looking up an entry, the `key` and `keydata` parameters to hashmap_get
- * and hashmap_remove are always passed as second `entry_or_key` and third
- * argument `keydata`, respectively. Otherwise, `keydata` is NULL.
- *
- * When it is too expensive to allocate a user entry (either because it is
- * large or variable sized, such that it is not on the stack), then the
- * relevant data to check for equality should be passed via `keydata`.
- * In this case `key` can be a stripped down version of the user key data
- * or even just a hashmap_entry having the correct hash.
- *
- * The `hashmap_cmp_fn_data` entry is the pointer given in the init function.
- */
- typedef int (*hashmap_cmp_fn)(const void *hashmap_cmp_fn_data,
- const struct hashmap_entry *entry,
- const struct hashmap_entry *entry_or_key,
- const void *keydata);
- /*
- * struct hashmap is the hash table structure. Members can be used as follows,
- * but should not be modified directly.
- */
- struct hashmap {
- struct hashmap_entry **table;
- /* Stores the comparison function specified in `hashmap_init()`. */
- hashmap_cmp_fn cmpfn;
- const void *cmpfn_data;
- /* total number of entries (0 means the hashmap is empty) */
- unsigned int private_size; /* use hashmap_get_size() */
- /*
- * tablesize is the allocated size of the hash table. A non-0 value
- * indicates that the hashmap is initialized. It may also be useful
- * for statistical purposes (i.e. `size / tablesize` is the current
- * load factor).
- */
- unsigned int tablesize;
- unsigned int grow_at;
- unsigned int shrink_at;
- unsigned int do_count_items : 1;
- };
- /* hashmap functions */
- /*
- * Initializes a hashmap structure.
- *
- * `map` is the hashmap to initialize.
- *
- * The `equals_function` can be specified to compare two entries for equality.
- * If NULL, entries are considered equal if their hash codes are equal.
- *
- * The `equals_function_data` parameter can be used to provide additional data
- * (a callback cookie) that will be passed to `equals_function` each time it
- * is called. This allows a single `equals_function` to implement multiple
- * comparison functions.
- *
- * If the total number of entries is known in advance, the `initial_size`
- * parameter may be used to preallocate a sufficiently large table and thus
- * prevent expensive resizing. If 0, the table is dynamically resized.
- */
- void hashmap_init(struct hashmap *map,
- hashmap_cmp_fn equals_function,
- const void *equals_function_data,
- size_t initial_size);
- /* internal function for freeing hashmap */
- void hashmap_free_(struct hashmap *map, ssize_t offset);
- /*
- * Frees a hashmap structure and allocated memory, leaves entries undisturbed
- */
- #define hashmap_free(map) hashmap_free_(map, -1)
- /*
- * Frees @map and all entries. @type is the struct type of the entry
- * where @member is the hashmap_entry struct used to associate with @map
- */
- #define hashmap_free_entries(map, type, member) \
- hashmap_free_(map, offsetof(type, member));
- /* hashmap_entry functions */
- /*
- * Initializes a hashmap_entry structure.
- *
- * `entry` points to the entry to initialize.
- * `hash` is the hash code of the entry.
- *
- * The hashmap_entry structure does not hold references to external resources,
- * and it is safe to just discard it once you are done with it (i.e. if
- * your structure was allocated with xmalloc(), you can just free(3) it,
- * and if it is on stack, you can just let it go out of scope).
- */
- static inline void hashmap_entry_init(struct hashmap_entry *e,
- unsigned int hash)
- {
- e->hash = hash;
- e->next = NULL;
- }
- /*
- * Return the number of items in the map.
- */
- static inline unsigned int hashmap_get_size(struct hashmap *map)
- {
- if (map->do_count_items)
- return map->private_size;
- BUG("hashmap_get_size: size not set");
- return 0;
- }
- /*
- * Returns the hashmap entry for the specified key, or NULL if not found.
- *
- * `map` is the hashmap structure.
- *
- * `key` is a user data structure that starts with hashmap_entry that has at
- * least been initialized with the proper hash code (via `hashmap_entry_init`).
- *
- * `keydata` is a data structure that holds just enough information to check
- * for equality to a given entry.
- *
- * If the key data is variable-sized (e.g. a FLEX_ARRAY string) or quite large,
- * it is undesirable to create a full-fledged entry structure on the heap and
- * copy all the key data into the structure.
- *
- * In this case, the `keydata` parameter can be used to pass
- * variable-sized key data directly to the comparison function, and the `key`
- * parameter can be a stripped-down, fixed size entry structure allocated on the
- * stack.
- *
- * If an entry with matching hash code is found, `key` and `keydata` are passed
- * to `hashmap_cmp_fn` to decide whether the entry matches the key.
- */
- struct hashmap_entry *hashmap_get(const struct hashmap *map,
- const struct hashmap_entry *key,
- const void *keydata);
- /*
- * Returns the hashmap entry for the specified hash code and key data,
- * or NULL if not found.
- *
- * `map` is the hashmap structure.
- * `hash` is the hash code of the entry to look up.
- *
- * If an entry with matching hash code is found, `keydata` is passed to
- * `hashmap_cmp_fn` to decide whether the entry matches the key. The
- * `entry_or_key` parameter of `hashmap_cmp_fn` points to a hashmap_entry
- * structure that should not be used in the comparison.
- */
- static inline struct hashmap_entry *hashmap_get_from_hash(
- const struct hashmap *map,
- unsigned int hash,
- const void *keydata)
- {
- struct hashmap_entry key;
- hashmap_entry_init(&key, hash);
- return hashmap_get(map, &key, keydata);
- }
- /*
- * Returns the next equal hashmap entry, or NULL if not found. This can be
- * used to iterate over duplicate entries (see `hashmap_add`).
- *
- * `map` is the hashmap structure.
- * `entry` is the hashmap_entry to start the search from, obtained via a previous
- * call to `hashmap_get` or `hashmap_get_next`.
- */
- struct hashmap_entry *hashmap_get_next(const struct hashmap *map,
- const struct hashmap_entry *entry);
- /*
- * Adds a hashmap entry. This allows to add duplicate entries (i.e.
- * separate values with the same key according to hashmap_cmp_fn).
- *
- * `map` is the hashmap structure.
- * `entry` is the entry to add.
- */
- void hashmap_add(struct hashmap *map, struct hashmap_entry *entry);
- /*
- * Adds or replaces a hashmap entry. If the hashmap contains duplicate
- * entries equal to the specified entry, only one of them will be replaced.
- *
- * `map` is the hashmap structure.
- * `entry` is the entry to add or replace.
- * Returns the replaced entry, or NULL if not found (i.e. the entry was added).
- */
- struct hashmap_entry *hashmap_put(struct hashmap *map,
- struct hashmap_entry *entry);
- /*
- * Adds or replaces a hashmap entry contained within @keyvar,
- * where @keyvar is a pointer to a struct containing a
- * "struct hashmap_entry" @member.
- *
- * Returns the replaced pointer which is of the same type as @keyvar,
- * or NULL if not found.
- */
- #define hashmap_put_entry(map, keyvar, member) \
- container_of_or_null_offset(hashmap_put(map, &(keyvar)->member), \
- OFFSETOF_VAR(keyvar, member))
- /*
- * Removes a hashmap entry matching the specified key. If the hashmap contains
- * duplicate entries equal to the specified key, only one of them will be
- * removed. Returns the removed entry, or NULL if not found.
- *
- * Argument explanation is the same as in `hashmap_get`.
- */
- struct hashmap_entry *hashmap_remove(struct hashmap *map,
- const struct hashmap_entry *key,
- const void *keydata);
- /*
- * Removes a hashmap entry contained within @keyvar,
- * where @keyvar is a pointer to a struct containing a
- * "struct hashmap_entry" @member.
- *
- * See `hashmap_get` for an explanation of @keydata
- *
- * Returns the replaced pointer which is of the same type as @keyvar,
- * or NULL if not found.
- */
- #define hashmap_remove_entry(map, keyvar, member, keydata) \
- container_of_or_null_offset( \
- hashmap_remove(map, &(keyvar)->member, keydata), \
- OFFSETOF_VAR(keyvar, member))
- /*
- * Returns the `bucket` an entry is stored in.
- * Useful for multithreaded read access.
- */
- int hashmap_bucket(const struct hashmap *map, unsigned int hash);
- /*
- * Used to iterate over all entries of a hashmap. Note that it is
- * not safe to add or remove entries to the hashmap while
- * iterating.
- */
- struct hashmap_iter {
- struct hashmap *map;
- struct hashmap_entry *next;
- unsigned int tablepos;
- };
- /* Initializes a `hashmap_iter` structure. */
- void hashmap_iter_init(struct hashmap *map, struct hashmap_iter *iter);
- /* Returns the next hashmap_entry, or NULL if there are no more entries. */
- struct hashmap_entry *hashmap_iter_next(struct hashmap_iter *iter);
- /* Initializes the iterator and returns the first entry, if any. */
- static inline struct hashmap_entry *hashmap_iter_first(struct hashmap *map,
- struct hashmap_iter *iter)
- {
- hashmap_iter_init(map, iter);
- return hashmap_iter_next(iter);
- }
- /*
- * returns the first entry in @map using @iter, where the entry is of
- * @type (e.g. "struct foo") and @member is the name of the
- * "struct hashmap_entry" in @type
- */
- #define hashmap_iter_first_entry(map, iter, type, member) \
- container_of_or_null(hashmap_iter_first(map, iter), type, member)
- /* internal macro for hashmap_for_each_entry */
- #define hashmap_iter_next_entry_offset(iter, offset) \
- container_of_or_null_offset(hashmap_iter_next(iter), offset)
- /* internal macro for hashmap_for_each_entry */
- #define hashmap_iter_first_entry_offset(map, iter, offset) \
- container_of_or_null_offset(hashmap_iter_first(map, iter), offset)
- /*
- * iterate through @map using @iter, @var is a pointer to a type
- * containing a @member which is a "struct hashmap_entry"
- */
- #define hashmap_for_each_entry(map, iter, var, member) \
- for (var = NULL, /* for systems without typeof */ \
- var = hashmap_iter_first_entry_offset(map, iter, \
- OFFSETOF_VAR(var, member)); \
- var; \
- var = hashmap_iter_next_entry_offset(iter, \
- OFFSETOF_VAR(var, member)))
- /*
- * returns a pointer of type matching @keyvar, or NULL if nothing found.
- * @keyvar is a pointer to a struct containing a
- * "struct hashmap_entry" @member.
- */
- #define hashmap_get_entry(map, keyvar, member, keydata) \
- container_of_or_null_offset( \
- hashmap_get(map, &(keyvar)->member, keydata), \
- OFFSETOF_VAR(keyvar, member))
- #define hashmap_get_entry_from_hash(map, hash, keydata, type, member) \
- container_of_or_null(hashmap_get_from_hash(map, hash, keydata), \
- type, member)
- /*
- * returns the next equal pointer to @var, or NULL if not found.
- * @var is a pointer of any type containing "struct hashmap_entry"
- * @member is the name of the "struct hashmap_entry" field
- */
- #define hashmap_get_next_entry(map, var, member) \
- container_of_or_null_offset(hashmap_get_next(map, &(var)->member), \
- OFFSETOF_VAR(var, member))
- /*
- * iterate @map starting from @var, where @var is a pointer of @type
- * and @member is the name of the "struct hashmap_entry" field in @type
- */
- #define hashmap_for_each_entry_from(map, var, member) \
- for (; \
- var; \
- var = hashmap_get_next_entry(map, var, member))
- /*
- * Disable item counting and automatic rehashing when adding/removing items.
- *
- * Normally, the hashmap keeps track of the number of items in the map
- * and uses it to dynamically resize it. This (both the counting and
- * the resizing) can cause problems when the map is being used by
- * threaded callers (because the hashmap code does not know about the
- * locking strategy used by the threaded callers and therefore, does
- * not know how to protect the "private_size" counter).
- */
- static inline void hashmap_disable_item_counting(struct hashmap *map)
- {
- map->do_count_items = 0;
- }
- /*
- * Re-enable item counting when adding/removing items.
- * If counting is currently disabled, it will force count them.
- * It WILL NOT automatically rehash them.
- */
- static inline void hashmap_enable_item_counting(struct hashmap *map)
- {
- unsigned int n = 0;
- struct hashmap_iter iter;
- if (map->do_count_items)
- return;
- hashmap_iter_init(map, &iter);
- while (hashmap_iter_next(&iter))
- n++;
- map->do_count_items = 1;
- map->private_size = n;
- }
- /* String interning */
- /*
- * Returns the unique, interned version of the specified string or data,
- * similar to the `String.intern` API in Java and .NET, respectively.
- * Interned strings remain valid for the entire lifetime of the process.
- *
- * Can be used as `[x]strdup()` or `xmemdupz` replacement, except that interned
- * strings / data must not be modified or freed.
- *
- * Interned strings are best used for short strings with high probability of
- * duplicates.
- *
- * Uses a hashmap to store the pool of interned strings.
- */
- const void *memintern(const void *data, size_t len);
- static inline const char *strintern(const char *string)
- {
- return memintern(string, strlen(string));
- }
- #endif
|