Browse Source
A specialization of hashmap that uses a string as key has been introduced. Hopefully it will see wider use over time. * en/strmap: shortlog: use strset from strmap.h Use new HASHMAP_INIT macro to simplify hashmap initialization strmap: take advantage of FLEXPTR_ALLOC_STR when relevant strmap: enable allocations to come from a mem_pool strmap: add a strset sub-type strmap: split create_entry() out of strmap_put() strmap: add functions facilitating use as a string->int map strmap: enable faster clearing and reusing of strmaps strmap: add more utility functions strmap: new utility functions hashmap: provide deallocation function names hashmap: introduce a new hashmap_partial_clear() hashmap: allow re-use after hashmap_free() hashmap: adjust spacing to fix argument alignment hashmap: add usage documentation explaining hashmap_free[_entries]()maint
Junio C Hamano
4 years ago
27 changed files with 621 additions and 170 deletions
@ -0,0 +1,178 @@
@@ -0,0 +1,178 @@
|
||||
#include "git-compat-util.h" |
||||
#include "strmap.h" |
||||
#include "mem-pool.h" |
||||
|
||||
int cmp_strmap_entry(const void *hashmap_cmp_fn_data, |
||||
const struct hashmap_entry *entry1, |
||||
const struct hashmap_entry *entry2, |
||||
const void *keydata) |
||||
{ |
||||
const struct strmap_entry *e1, *e2; |
||||
|
||||
e1 = container_of(entry1, const struct strmap_entry, ent); |
||||
e2 = container_of(entry2, const struct strmap_entry, ent); |
||||
return strcmp(e1->key, e2->key); |
||||
} |
||||
|
||||
static struct strmap_entry *find_strmap_entry(struct strmap *map, |
||||
const char *str) |
||||
{ |
||||
struct strmap_entry entry; |
||||
hashmap_entry_init(&entry.ent, strhash(str)); |
||||
entry.key = str; |
||||
return hashmap_get_entry(&map->map, &entry, ent, NULL); |
||||
} |
||||
|
||||
void strmap_init(struct strmap *map) |
||||
{ |
||||
strmap_init_with_options(map, NULL, 1); |
||||
} |
||||
|
||||
void strmap_init_with_options(struct strmap *map, |
||||
struct mem_pool *pool, |
||||
int strdup_strings) |
||||
{ |
||||
hashmap_init(&map->map, cmp_strmap_entry, NULL, 0); |
||||
map->pool = pool; |
||||
map->strdup_strings = strdup_strings; |
||||
} |
||||
|
||||
static void strmap_free_entries_(struct strmap *map, int free_values) |
||||
{ |
||||
struct hashmap_iter iter; |
||||
struct strmap_entry *e; |
||||
|
||||
if (!map) |
||||
return; |
||||
|
||||
if (!free_values && map->pool) |
||||
/* Memory other than util is owned by and freed with the pool */ |
||||
return; |
||||
|
||||
/* |
||||
* We need to iterate over the hashmap entries and free |
||||
* e->key and e->value ourselves; hashmap has no API to |
||||
* take care of that for us. Since we're already iterating over |
||||
* the hashmap, though, might as well free e too and avoid the need |
||||
* to make some call into the hashmap API to do that. |
||||
*/ |
||||
hashmap_for_each_entry(&map->map, &iter, e, ent) { |
||||
if (free_values) |
||||
free(e->value); |
||||
if (!map->pool) |
||||
free(e); |
||||
} |
||||
} |
||||
|
||||
void strmap_clear(struct strmap *map, int free_values) |
||||
{ |
||||
strmap_free_entries_(map, free_values); |
||||
hashmap_clear(&map->map); |
||||
} |
||||
|
||||
void strmap_partial_clear(struct strmap *map, int free_values) |
||||
{ |
||||
strmap_free_entries_(map, free_values); |
||||
hashmap_partial_clear(&map->map); |
||||
} |
||||
|
||||
static struct strmap_entry *create_entry(struct strmap *map, |
||||
const char *str, |
||||
void *data) |
||||
{ |
||||
struct strmap_entry *entry; |
||||
|
||||
if (map->strdup_strings) { |
||||
if (!map->pool) { |
||||
FLEXPTR_ALLOC_STR(entry, key, str); |
||||
} else { |
||||
size_t len = st_add(strlen(str), 1); /* include NUL */ |
||||
entry = mem_pool_alloc(map->pool, |
||||
st_add(sizeof(*entry), len)); |
||||
memcpy(entry + 1, str, len); |
||||
entry->key = (void *)(entry + 1); |
||||
} |
||||
} else if (!map->pool) { |
||||
entry = xmalloc(sizeof(*entry)); |
||||
} else { |
||||
entry = mem_pool_alloc(map->pool, sizeof(*entry)); |
||||
} |
||||
hashmap_entry_init(&entry->ent, strhash(str)); |
||||
if (!map->strdup_strings) |
||||
entry->key = str; |
||||
entry->value = data; |
||||
return entry; |
||||
} |
||||
|
||||
void *strmap_put(struct strmap *map, const char *str, void *data) |
||||
{ |
||||
struct strmap_entry *entry = find_strmap_entry(map, str); |
||||
|
||||
if (entry) { |
||||
void *old = entry->value; |
||||
entry->value = data; |
||||
return old; |
||||
} |
||||
|
||||
entry = create_entry(map, str, data); |
||||
hashmap_add(&map->map, &entry->ent); |
||||
return NULL; |
||||
} |
||||
|
||||
struct strmap_entry *strmap_get_entry(struct strmap *map, const char *str) |
||||
{ |
||||
return find_strmap_entry(map, str); |
||||
} |
||||
|
||||
void *strmap_get(struct strmap *map, const char *str) |
||||
{ |
||||
struct strmap_entry *entry = find_strmap_entry(map, str); |
||||
return entry ? entry->value : NULL; |
||||
} |
||||
|
||||
int strmap_contains(struct strmap *map, const char *str) |
||||
{ |
||||
return find_strmap_entry(map, str) != NULL; |
||||
} |
||||
|
||||
void strmap_remove(struct strmap *map, const char *str, int free_value) |
||||
{ |
||||
struct strmap_entry entry, *ret; |
||||
hashmap_entry_init(&entry.ent, strhash(str)); |
||||
entry.key = str; |
||||
ret = hashmap_remove_entry(&map->map, &entry, ent, NULL); |
||||
if (!ret) |
||||
return; |
||||
if (free_value) |
||||
free(ret->value); |
||||
if (!map->pool) |
||||
free(ret); |
||||
} |
||||
|
||||
void strintmap_incr(struct strintmap *map, const char *str, intptr_t amt) |
||||
{ |
||||
struct strmap_entry *entry = find_strmap_entry(&map->map, str); |
||||
if (entry) { |
||||
intptr_t *whence = (intptr_t*)&entry->value; |
||||
*whence += amt; |
||||
} |
||||
else |
||||
strintmap_set(map, str, map->default_value + amt); |
||||
} |
||||
|
||||
int strset_add(struct strset *set, const char *str) |
||||
{ |
||||
/* |
||||
* Cannot use strmap_put() because it'll return NULL in both cases: |
||||
* - cannot find str: NULL means "not found" |
||||
* - does find str: NULL is the value associated with str |
||||
*/ |
||||
struct strmap_entry *entry = find_strmap_entry(&set->map, str); |
||||
|
||||
if (entry) |
||||
return 0; |
||||
|
||||
entry = create_entry(&set->map, str, NULL); |
||||
hashmap_add(&set->map.map, &entry->ent); |
||||
return 1; |
||||
} |
||||
@ -0,0 +1,268 @@
@@ -0,0 +1,268 @@
|
||||
#ifndef STRMAP_H |
||||
#define STRMAP_H |
||||
|
||||
#include "hashmap.h" |
||||
|
||||
struct mem_pool; |
||||
struct strmap { |
||||
struct hashmap map; |
||||
struct mem_pool *pool; |
||||
unsigned int strdup_strings:1; |
||||
}; |
||||
|
||||
struct strmap_entry { |
||||
struct hashmap_entry ent; |
||||
const char *key; |
||||
void *value; |
||||
/* strmap_entry may be allocated extra space to store the key at end */ |
||||
}; |
||||
|
||||
int cmp_strmap_entry(const void *hashmap_cmp_fn_data, |
||||
const struct hashmap_entry *entry1, |
||||
const struct hashmap_entry *entry2, |
||||
const void *keydata); |
||||
|
||||
#define STRMAP_INIT { \ |
||||
.map = HASHMAP_INIT(cmp_strmap_entry, NULL), \ |
||||
.strdup_strings = 1, \ |
||||
} |
||||
#define STRINTMAP_INIT { \ |
||||
.map = STRMAP_INIT, \ |
||||
.default_value = 0, \ |
||||
} |
||||
#define STRSET_INIT { .map = STRMAP_INIT } |
||||
|
||||
/* |
||||
* Initialize the members of the strmap. Any keys added to the strmap will |
||||
* be strdup'ed with their memory managed by the strmap. |
||||
*/ |
||||
void strmap_init(struct strmap *map); |
||||
|
||||
/* |
||||
* Same as strmap_init, but for those who want to control the memory management |
||||
* carefully instead of using the default of strdup_strings=1 and pool=NULL. |
||||
*/ |
||||
void strmap_init_with_options(struct strmap *map, |
||||
struct mem_pool *pool, |
||||
int strdup_strings); |
||||
|
||||
/* |
||||
* Remove all entries from the map, releasing any allocated resources. |
||||
*/ |
||||
void strmap_clear(struct strmap *map, int free_values); |
||||
|
||||
/* |
||||
* Similar to strmap_clear() but leaves map->map->table allocated and |
||||
* pre-sized so that subsequent uses won't need as many rehashings. |
||||
*/ |
||||
void strmap_partial_clear(struct strmap *map, int free_values); |
||||
|
||||
/* |
||||
* Insert "str" into the map, pointing to "data". |
||||
* |
||||
* If an entry for "str" already exists, its data pointer is overwritten, and |
||||
* the original data pointer returned. Otherwise, returns NULL. |
||||
*/ |
||||
void *strmap_put(struct strmap *map, const char *str, void *data); |
||||
|
||||
/* |
||||
* Return the strmap_entry mapped by "str", or NULL if there is not such |
||||
* an item in map. |
||||
*/ |
||||
struct strmap_entry *strmap_get_entry(struct strmap *map, const char *str); |
||||
|
||||
/* |
||||
* Return the data pointer mapped by "str", or NULL if the entry does not |
||||
* exist. |
||||
*/ |
||||
void *strmap_get(struct strmap *map, const char *str); |
||||
|
||||
/* |
||||
* Return non-zero iff "str" is present in the map. This differs from |
||||
* strmap_get() in that it can distinguish entries with a NULL data pointer. |
||||
*/ |
||||
int strmap_contains(struct strmap *map, const char *str); |
||||
|
||||
/* |
||||
* Remove the given entry from the strmap. If the string isn't in the |
||||
* strmap, the map is not altered. |
||||
*/ |
||||
void strmap_remove(struct strmap *map, const char *str, int free_value); |
||||
|
||||
/* |
||||
* Return how many entries the strmap has. |
||||
*/ |
||||
static inline unsigned int strmap_get_size(struct strmap *map) |
||||
{ |
||||
return hashmap_get_size(&map->map); |
||||
} |
||||
|
||||
/* |
||||
* Return whether the strmap is empty. |
||||
*/ |
||||
static inline int strmap_empty(struct strmap *map) |
||||
{ |
||||
return strmap_get_size(map) == 0; |
||||
} |
||||
|
||||
/* |
||||
* iterate through @map using @iter, @var is a pointer to a type strmap_entry |
||||
*/ |
||||
#define strmap_for_each_entry(mystrmap, iter, var) \ |
||||
hashmap_for_each_entry(&(mystrmap)->map, iter, var, ent) |
||||
|
||||
|
||||
/* |
||||
* strintmap: |
||||
* A map of string -> int, typecasting the void* of strmap to an int. |
||||
* |
||||
* Primary differences: |
||||
* 1) Since the void* value is just an int in disguise, there is no value |
||||
* to free. (Thus one fewer argument to strintmap_clear) |
||||
* 2) strintmap_get() returns an int, or returns the default_value if the |
||||
* key is not found in the strintmap. |
||||
* 3) No strmap_put() equivalent; strintmap_set() and strintmap_incr() |
||||
* instead. |
||||
*/ |
||||
|
||||
struct strintmap { |
||||
struct strmap map; |
||||
int default_value; |
||||
}; |
||||
|
||||
#define strintmap_for_each_entry(mystrmap, iter, var) \ |
||||
strmap_for_each_entry(&(mystrmap)->map, iter, var) |
||||
|
||||
static inline void strintmap_init(struct strintmap *map, int default_value) |
||||
{ |
||||
strmap_init(&map->map); |
||||
map->default_value = default_value; |
||||
} |
||||
|
||||
static inline void strintmap_init_with_options(struct strintmap *map, |
||||
int default_value, |
||||
struct mem_pool *pool, |
||||
int strdup_strings) |
||||
{ |
||||
strmap_init_with_options(&map->map, pool, strdup_strings); |
||||
map->default_value = default_value; |
||||
} |
||||
|
||||
static inline void strintmap_clear(struct strintmap *map) |
||||
{ |
||||
strmap_clear(&map->map, 0); |
||||
} |
||||
|
||||
static inline void strintmap_partial_clear(struct strintmap *map) |
||||
{ |
||||
strmap_partial_clear(&map->map, 0); |
||||
} |
||||
|
||||
static inline int strintmap_contains(struct strintmap *map, const char *str) |
||||
{ |
||||
return strmap_contains(&map->map, str); |
||||
} |
||||
|
||||
static inline void strintmap_remove(struct strintmap *map, const char *str) |
||||
{ |
||||
return strmap_remove(&map->map, str, 0); |
||||
} |
||||
|
||||
static inline int strintmap_empty(struct strintmap *map) |
||||
{ |
||||
return strmap_empty(&map->map); |
||||
} |
||||
|
||||
static inline unsigned int strintmap_get_size(struct strintmap *map) |
||||
{ |
||||
return strmap_get_size(&map->map); |
||||
} |
||||
|
||||
/* |
||||
* Returns the value for str in the map. If str isn't found in the map, |
||||
* the map's default_value is returned. |
||||
*/ |
||||
static inline int strintmap_get(struct strintmap *map, const char *str) |
||||
{ |
||||
struct strmap_entry *result = strmap_get_entry(&map->map, str); |
||||
if (!result) |
||||
return map->default_value; |
||||
return (intptr_t)result->value; |
||||
} |
||||
|
||||
static inline void strintmap_set(struct strintmap *map, const char *str, |
||||
intptr_t v) |
||||
{ |
||||
strmap_put(&map->map, str, (void *)v); |
||||
} |
||||
|
||||
/* |
||||
* Increment the value for str by amt. If str isn't in the map, add it and |
||||
* set its value to default_value + amt. |
||||
*/ |
||||
void strintmap_incr(struct strintmap *map, const char *str, intptr_t amt); |
||||
|
||||
/* |
||||
* strset: |
||||
* A set of strings. |
||||
* |
||||
* Primary differences with strmap: |
||||
* 1) The value is always NULL, and ignored. As there is no value to free, |
||||
* there is one fewer argument to strset_clear |
||||
* 2) No strset_get() because there is no value. |
||||
* 3) No strset_put(); use strset_add() instead. |
||||
*/ |
||||
|
||||
struct strset { |
||||
struct strmap map; |
||||
}; |
||||
|
||||
#define strset_for_each_entry(mystrset, iter, var) \ |
||||
strmap_for_each_entry(&(mystrset)->map, iter, var) |
||||
|
||||
static inline void strset_init(struct strset *set) |
||||
{ |
||||
strmap_init(&set->map); |
||||
} |
||||
|
||||
static inline void strset_init_with_options(struct strset *set, |
||||
struct mem_pool *pool, |
||||
int strdup_strings) |
||||
{ |
||||
strmap_init_with_options(&set->map, pool, strdup_strings); |
||||
} |
||||
|
||||
static inline void strset_clear(struct strset *set) |
||||
{ |
||||
strmap_clear(&set->map, 0); |
||||
} |
||||
|
||||
static inline void strset_partial_clear(struct strset *set) |
||||
{ |
||||
strmap_partial_clear(&set->map, 0); |
||||
} |
||||
|
||||
static inline int strset_contains(struct strset *set, const char *str) |
||||
{ |
||||
return strmap_contains(&set->map, str); |
||||
} |
||||
|
||||
static inline void strset_remove(struct strset *set, const char *str) |
||||
{ |
||||
return strmap_remove(&set->map, str, 0); |
||||
} |
||||
|
||||
static inline int strset_empty(struct strset *set) |
||||
{ |
||||
return strmap_empty(&set->map); |
||||
} |
||||
|
||||
static inline unsigned int strset_get_size(struct strset *set) |
||||
{ |
||||
return strmap_get_size(&set->map); |
||||
} |
||||
|
||||
/* Returns 1 if str is added to the set; returns 0 if str was already in set */ |
||||
int strset_add(struct strset *set, const char *str); |
||||
|
||||
#endif /* STRMAP_H */ |
||||
Loading…
Reference in new issue