From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on dcvr.yhbt.net X-Spam-Level: X-Spam-ASN: AS31976 209.132.180.0/23 X-Spam-Status: No, score=-2.9 required=3.0 tests=AWL,BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,RCVD_IN_DNSWL_HI, RCVD_IN_SORBS_SPAM,RP_MATCHES_RCVD shortcircuit=no autolearn=no autolearn_force=no version=3.4.0 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by dcvr.yhbt.net (Postfix) with ESMTP id 29F4D2023D for ; Thu, 29 Jun 2017 01:13:47 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751652AbdF2BNp (ORCPT ); Wed, 28 Jun 2017 21:13:45 -0400 Received: from mail-pg0-f52.google.com ([74.125.83.52]:36286 "EHLO mail-pg0-f52.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751618AbdF2BNl (ORCPT ); Wed, 28 Jun 2017 21:13:41 -0400 Received: by mail-pg0-f52.google.com with SMTP id u62so39692245pgb.3 for ; Wed, 28 Jun 2017 18:13:41 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=z6GLzGSsD0qTE6BobPYnJYnKcGK4utLEX5o3XQxKx0Q=; b=CttLYAvndu35qCAbSOMQ1IjxB2Hiwg5D+OTxepxj4z1VztjAWRDmAUNSFHYFzxvGmq gLTndmhwCvoT0O32wZ9QbMUag29egtuEmKOQLijcj4ucRy4wf4I0SLTMgcCvTXxTEUA+ uxOVi9wXhskIh7emsR8h7U8kBme4PPZxH7XLUJZmyu/9sPyKXpbO5Z+eKwXOmE59mL/t nHDlLr8Q/qYOwQcNbgnh4d5pbCT5LYpt+Bx4TFRXdPhXYJIKCTW8zK3MN0WSWxPCgIzR 3/fxDEhnxbngMpnaFY6BvDN+Cq4X4uUjTKYyYduj1RzBTdV2nGEZCaZbSj+W1ILVWuek 9/UQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=z6GLzGSsD0qTE6BobPYnJYnKcGK4utLEX5o3XQxKx0Q=; b=tqGdqGtDqwvUMrn9kFxqtPEKve7/S6Mef+4V9rIxv4rBrlahmHoEv9Y+Di74hShivt i7jWqJAGh2NviuktgS//XMmdnbM6ABO3RtJG/Y7uguvNL7wmh/PlexDziXvjwOjROfkJ scQO21Zi6eakzQZoAFMNpgQwGdnzufmtCcBQe9HeMguiCzVsnvokGTe+ec1ZaeBQvUzj SWUJL/xQXHwVrf9kZRyHW/4geWht8UoUMT2+Ofh10lNqvwUcrf5guOJd5iphgCKHtyYh vMPN0Ps9XD044ytypOnYorxs3SNhyK6UyCI6S1JGOWZ8zUuzVf4s4r+sfYOzCR2ueSgD LJlw== X-Gm-Message-State: AKS2vOwnog3TYkR+uymVJHFOJGMhW44nWq7LlJGYH1A/99iUoLVO4VTD AeQnNYoizgflxCdo X-Received: by 10.84.128.102 with SMTP id 93mr14858664pla.21.1498698819609; Wed, 28 Jun 2017 18:13:39 -0700 (PDT) Received: from localhost ([2620:0:100e:422:18c6:2a3:5614:1523]) by smtp.gmail.com with ESMTPSA id j29sm5571638pfj.68.2017.06.28.18.13.38 (version=TLS1_2 cipher=AES128-SHA bits=128/128); Wed, 28 Jun 2017 18:13:38 -0700 (PDT) From: Stefan Beller To: gitster@pobox.com Cc: git@vger.kernel.org, Stefan Beller Subject: [PATCH 2/2] hashmap: migrate documentation from Documentation/technical into header Date: Wed, 28 Jun 2017 18:13:34 -0700 Message-Id: <20170629011334.11173-3-sbeller@google.com> X-Mailer: git-send-email 2.13.0.31.g9b732c453e In-Reply-To: <20170629011334.11173-1-sbeller@google.com> References: <20170629011334.11173-1-sbeller@google.com> Sender: git-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org While at it, clarify the use of `key`, `keydata`, `entry_or_key` as well as documenting the new data pointer for the compare function. Signed-off-by: Stefan Beller --- Documentation/technical/api-hashmap.txt | 309 -------------------------------- hashmap.h | 249 +++++++++++++++++++++++-- 2 files changed, 231 insertions(+), 327 deletions(-) delete mode 100644 Documentation/technical/api-hashmap.txt diff --git a/Documentation/technical/api-hashmap.txt b/Documentation/technical/api-hashmap.txt deleted file mode 100644 index ccc634bbd7..0000000000 --- a/Documentation/technical/api-hashmap.txt +++ /dev/null @@ -1,309 +0,0 @@ -hashmap API -=========== - -The hashmap API is a generic implementation of hash-based key-value mappings. - -Data Structures ---------------- - -`struct hashmap`:: - - The hash table structure. Members can be used as follows, but should - not be modified directly: -+ -The `size` member keeps track of the total number of entries (0 means the -hashmap is empty). -+ -`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). -+ -`cmpfn` stores the comparison function specified in `hashmap_init()`. In -advanced scenarios, it may be useful to change this, e.g. to switch between -case-sensitive and case-insensitive lookup. -+ -When `disallow_rehash` is set, automatic rehashes are prevented during inserts -and deletes. - -`struct hashmap_entry`:: - - An opaque structure representing an entry in the hash table, which must - be used as first member of user data structures. Ideally it should be - followed by an int-sized member to prevent unused memory on 64-bit - systems due to alignment. -+ -The `hash` member is the entry's hash code and the `next` member points to the -next entry in case of collisions (i.e. if multiple entries map to the same -bucket). - -`struct hashmap_iter`:: - - An iterator structure, to be used with hashmap_iter_* functions. - -Types ------ - -`int (*hashmap_cmp_fn)(const void *entry, const void *entry_or_key, const void *keydata)`:: - - 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` / `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 and third argument, respectively. Otherwise, `keydata` is NULL. - -Functions ---------- - -`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)`:: - - 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 sha1hash(const unsigned char *sha1)`:: - - 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. - -`void hashmap_init(struct hashmap *map, hashmap_cmp_fn equals_function, size_t initial_size)`:: - - 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. -+ -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_free(struct hashmap *map, int free_entries)`:: - - Frees a hashmap structure and allocated memory. -+ -`map` is the hashmap to free. -+ -If `free_entries` is true, each hashmap_entry in the map is freed as well -(using stdlib's free()). - -`void hashmap_entry_init(void *entry, unsigned int hash)`:: - - 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). - -`void *hashmap_get(const struct hashmap *map, const void *key, const void *keydata)`:: - - Returns the hashmap entry for the specified key, or NULL if not found. -+ -`map` is the hashmap structure. -+ -`key` is a hashmap_entry structure (or user data structure that starts with -hashmap_entry) that has at least been initialized with the proper hash code -(via `hashmap_entry_init`). -+ -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. - -`void *hashmap_get_from_hash(const struct hashmap *map, unsigned int hash, 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 points to a bogus hashmap_entry structure that -should not be used in the comparison. - -`void *hashmap_get_next(const struct hashmap *map, const void *entry)`:: - - 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`. - -`void hashmap_add(struct hashmap *map, void *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_put(struct hashmap *map, void *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). - -`void *hashmap_remove(struct hashmap *map, const void *key, const void *keydata)`:: - - 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. -+ -`map` is the hashmap structure. -+ -`key` is a hashmap_entry structure (or user data structure that starts with -hashmap_entry) that has at least been initialized with the proper hash code -(via `hashmap_entry_init`). -+ -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. -+ -Returns the removed entry, or NULL if not found. - -`void hashmap_disallow_rehash(struct hashmap *map, unsigned value)`:: - - Disallow/allow automatic rehashing of the hashmap during inserts - and deletes. -+ -This is useful if the caller knows that the hashmap will be accessed -by multiple threads. -+ -The caller is still responsible for any necessary locking; this simply -prevents unexpected rehashing. The caller is also responsible for properly -sizing the initial hashmap to ensure good performance. -+ -A call to allow rehashing does not force a rehash; that might happen -with the next insert or delete. - -`void hashmap_iter_init(struct hashmap *map, struct hashmap_iter *iter)`:: -`void *hashmap_iter_next(struct hashmap_iter *iter)`:: -`void *hashmap_iter_first(struct hashmap *map, struct hashmap_iter *iter)`:: - - 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. -+ -`hashmap_iter_init` initializes a `hashmap_iter` structure. -+ -`hashmap_iter_next` returns the next hashmap_entry, or NULL if there are no -more entries. -+ -`hashmap_iter_first` is a combination of both (i.e. initializes the iterator -and returns the first entry, if any). - -`const char *strintern(const char *string)`:: -`const void *memintern(const void *data, size_t len)`:: - - 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. - -Usage example -------------- - -Here's a simple usage example that maps long keys to double values. ------------- -struct hashmap map; - -struct long2double { - struct hashmap_entry ent; /* must be the first member! */ - long key; - double value; -}; - -static int long2double_cmp(const struct long2double *e1, const struct long2double *e2, const void *unused) -{ - return !(e1->key == e2->key); -} - -void long2double_init(void) -{ - hashmap_init(&map, (hashmap_cmp_fn) long2double_cmp, 0); -} - -void long2double_free(void) -{ - hashmap_free(&map, 1); -} - -static struct long2double *find_entry(long key) -{ - struct long2double k; - hashmap_entry_init(&k, memhash(&key, sizeof(long))); - k.key = key; - return hashmap_get(&map, &k, NULL); -} - -double get_value(long key) -{ - struct long2double *e = find_entry(key); - return e ? e->value : 0; -} - -void set_value(long key, double value) -{ - struct long2double *e = find_entry(key); - if (!e) { - e = malloc(sizeof(struct long2double)); - hashmap_entry_init(e, memhash(&key, sizeof(long))); - e->key = key; - hashmap_add(&map, e); - } - e->value = value; -} ------------- - -Using variable-sized keys -------------------------- - -The `hashmap_entry_get` and `hashmap_entry_remove` functions expect an ordinary -`hashmap_entry` structure as key to find the correct 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. - -See test-hashmap.c for an example using arbitrary-length strings as keys. diff --git a/hashmap.h b/hashmap.h index 1c26bbad5b..cd8c6f8ad3 100644 --- a/hashmap.h +++ b/hashmap.h @@ -3,11 +3,18 @@ /* * Generic implementation of hash-based key-value mappings. - * See Documentation/technical/api-hashmap.txt. + * */ -/* FNV-1 functions */ - +/* + * 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. + */ extern unsigned int strhash(const char *buf); extern unsigned int strihash(const char *buf); extern unsigned int memhash(const void *buf, size_t len); @@ -16,6 +23,15 @@ extern unsigned int memihash_cont(unsigned int hash_seed, const void *buf, size_ static inline unsigned int sha1hash(const unsigned char *sha1) { + /* + * 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. + */ + /* * Equivalent to 'return *(unsigned int *)sha1;', but safe on * platforms that don't support unaligned reads. @@ -25,62 +41,228 @@ static inline unsigned int sha1hash(const unsigned char *sha1) return hash; } -/* data structures */ - +/* + * struct hashmap_entry is an opaque structure representing an entry in the + * hash table, which must be used as first member of user data structures. + * 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. + * + * There are two modes for this function to be used: + * (a) When looking for an exact match of a given `entry`, then `keydata` + * ought to be NULL, and this function should cast `entry` and + * `entry_or_key` to the user entries and check for equality. + * (b) When it is too expensive to allocate such a user entry (either because + * it is large or varialbe sized, such that it is not on the stack), + * Then the relevant data to check for equality should be passed via + * ` keydata`. + * + * Resulting from these modes, this function should compare `keydata` to `entry` + * when `keydata` is not NULL. `entry_or_key` may be a bogus hashmap_entry (see + * hashmap_get_from_hash). + * + * When `keydata` is NULL,`entry_or_key` is guaranteed to be a valid user supplied + * entry, such that the comparision should be made between `entry` and + * `entry_or_key`, both cast to the user type. + * + * The `data` entry is the pointer given in the init function and is always + * given. + */ typedef int (*hashmap_cmp_fn)(const void *entry, const void *entry_or_key, - const void *keydata, const void *cbdata); + const void *keydata, const void *data); +/* + * 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 *data; - unsigned int size, tablesize, grow_at, shrink_at; - unsigned disallow_rehash : 1; -}; -struct hashmap_iter { - struct hashmap *map; - struct hashmap_entry *next; - unsigned int tablepos; + /* total number of entries (0 means the hashmap is empty) */ + unsigned int 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; + + /* Prevent automatic rehashes during inserts and deletes when set. */ + unsigned disallow_rehash : 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. + * + * When the compare function needs specific user supplied `data`, it should + * be given in `data`. It will be passed to the compare function in each call. + * + * 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. + */ extern void hashmap_init(struct hashmap *map, hashmap_cmp_fn equals_function, const void *data, size_t initial_size); + +/* + * Frees a hashmap structure and allocated memory. + * + * If `free_entries` is true, each hashmap_entry in the map is freed as well. + */ extern void hashmap_free(struct hashmap *map, int free_entries); /* 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(void *entry, unsigned int hash) { struct hashmap_entry *e = entry; e->hash = hash; e->next = NULL; } + +/* + * 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. + * + * One of `key` or `keydata` shall be NULL. + * + * 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. + */ extern void *hashmap_get(const struct hashmap *map, const void *key, - const void *keydata); + const void *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`. + */ extern void *hashmap_get_next(const struct hashmap *map, const void *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. + */ extern void hashmap_add(struct hashmap *map, void *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). + */ extern void *hashmap_put(struct hashmap *map, void *entry); + +/* + * 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. + * + * `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. + * + * One of `key` or `keydata` shall be NULL. + * + * 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. + * + * Returns the removed entry, or NULL if not found. + */ extern void *hashmap_remove(struct hashmap *map, const void *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 points to a bogus hashmap_entry structure that + * should not be used in the comparison. + */ static inline void *hashmap_get_from_hash(const struct hashmap *map, - unsigned int hash, const void *keydata) + unsigned int hash, + const void *keydata) { struct hashmap_entry key; hashmap_entry_init(&key, hash); return hashmap_get(map, &key, keydata); } +/* + * Returns the `bucket` an entry is stored in. + * Useful for multithreaded read access. + */ int hashmap_bucket(const struct hashmap *map, unsigned int hash); /* @@ -91,7 +273,7 @@ int hashmap_bucket(const struct hashmap *map, unsigned int hash); * manner appropriate to their usage. This simply * prevents the table from being unexpectedly re-mapped. * - * If is up to the caller to ensure that the hashmap is + * It is up to the caller to ensure that the hashmap is * initialized to a reasonable size to prevent poor * performance. * @@ -104,10 +286,28 @@ static inline void hashmap_disallow_rehash(struct hashmap *map, unsigned value) map->disallow_rehash = value; } -/* hashmap_iter functions */ +/* + * hashmap_iter functions + * + * 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. */ extern void hashmap_iter_init(struct hashmap *map, struct hashmap_iter *iter); + +/* Returns the next hashmap_entry, or NULL if there are no more entries. */ extern void *hashmap_iter_next(struct hashmap_iter *iter); + +/* Initializes the iterator and returns the first entry, if any). */ static inline void *hashmap_iter_first(struct hashmap *map, struct hashmap_iter *iter) { @@ -115,8 +315,21 @@ static inline void *hashmap_iter_first(struct hashmap *map, return hashmap_iter_next(iter); } -/* string interning */ +/* 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. + */ extern const void *memintern(const void *data, size_t len); static inline const char *strintern(const char *string) { -- 2.13.0.31.g9b732c453e