strmap.c

   1 #include "git-compat-util.h"
   2 #include "strmap.h"
   3 #include "mem-pool.h"
   4
   5 int cmp_strmap_entry(const void *hashmap_cmp_fn_data,
   6                      const struct hashmap_entry *entry1,
   7                      const struct hashmap_entry *entry2,
   8                      const void *keydata)
   9 {
  10         const struct strmap_entry *e1, *e2;
  11
  12         e1 = container_of(entry1, const struct strmap_entry, ent);
  13         e2 = container_of(entry2, const struct strmap_entry, ent);
  14         return strcmp(e1->key, e2->key);
  15 }
  16
  17 static struct strmap_entry *find_strmap_entry(struct strmap *map,
  18                                               const char *str)
  19 {
  20         struct strmap_entry entry;
  21         hashmap_entry_init(&entry.ent, strhash(str));
  22         entry.key = str;
  23         return hashmap_get_entry(&map->map, &entry, ent, NULL);
  24 }
  25
  26 void strmap_init(struct strmap *map)
  27 {
  28         strmap_init_with_options(map, NULL, 1);
  29 }
  30
  31 void strmap_init_with_options(struct strmap *map,
  32                               struct mem_pool *pool,
  33                               int strdup_strings)
  34 {
  35         hashmap_init(&map->map, cmp_strmap_entry, NULL, 0);
  36         map->pool = pool;
  37         map->strdup_strings = strdup_strings;
  38 }
  39
  40 static void strmap_free_entries_(struct strmap *map, int free_values)
  41 {
  42         struct hashmap_iter iter;
  43         struct strmap_entry *e;
  44
  45         if (!map)
  46                 return;
  47
  48         if (!free_values && map->pool)
  49                 /* Memory other than util is owned by and freed with the pool */
  50                 return;
  51
  52         /*
  53          * We need to iterate over the hashmap entries and free
  54          * e->key and e->value ourselves; hashmap has no API to
  55          * take care of that for us.  Since we're already iterating over
  56          * the hashmap, though, might as well free e too and avoid the need
  57          * to make some call into the hashmap API to do that.
  58          */
  59         hashmap_for_each_entry(&map->map, &iter, e, ent) {
  60                 if (free_values)
  61                         free(e->value);
  62                 if (!map->pool)
  63                         free(e);
  64         }
  65 }
  66
  67 void strmap_clear(struct strmap *map, int free_values)
  68 {
  69         strmap_free_entries_(map, free_values);
  70         hashmap_clear(&map->map);
  71 }
  72
  73 void strmap_partial_clear(struct strmap *map, int free_values)
  74 {
  75         strmap_free_entries_(map, free_values);
  76         hashmap_partial_clear(&map->map);
  77 }
  78
  79 static struct strmap_entry *create_entry(struct strmap *map,
  80                                          const char *str,
  81                                          void *data)
  82 {
  83         struct strmap_entry *entry;
  84
  85         if (map->strdup_strings) {
  86                 if (!map->pool) {
  87                         FLEXPTR_ALLOC_STR(entry, key, str);
  88                 } else {
  89                         size_t len = st_add(strlen(str), 1); /* include NUL */
  90                         entry = mem_pool_alloc(map->pool,
  91                                                st_add(sizeof(*entry), len));
  92                         memcpy(entry + 1, str, len);
  93                         entry->key = (void *)(entry + 1);
  94                 }
  95         } else if (!map->pool) {
  96                 entry = xmalloc(sizeof(*entry));
  97         } else {
  98                 entry = mem_pool_alloc(map->pool, sizeof(*entry));
  99         }
 100         hashmap_entry_init(&entry->ent, strhash(str));
 101         if (!map->strdup_strings)
 102                 entry->key = str;
 103         entry->value = data;
 104         return entry;
 105 }
 106
 107 void *strmap_put(struct strmap *map, const char *str, void *data)
 108 {
 109         struct strmap_entry *entry = find_strmap_entry(map, str);
 110
 111         if (entry) {
 112                 void *old = entry->value;
 113                 entry->value = data;
 114                 return old;
 115         }
 116
 117         entry = create_entry(map, str, data);
 118         hashmap_add(&map->map, &entry->ent);
 119         return NULL;
 120 }
 121
 122 struct strmap_entry *strmap_get_entry(struct strmap *map, const char *str)
 123 {
 124         return find_strmap_entry(map, str);
 125 }
 126
 127 void *strmap_get(struct strmap *map, const char *str)
 128 {
 129         struct strmap_entry *entry = find_strmap_entry(map, str);
 130         return entry ? entry->value : NULL;
 131 }
 132
 133 int strmap_contains(struct strmap *map, const char *str)
 134 {
 135         return find_strmap_entry(map, str) != NULL;
 136 }
 137
 138 void strmap_remove(struct strmap *map, const char *str, int free_value)
 139 {
 140         struct strmap_entry entry, *ret;
 141         hashmap_entry_init(&entry.ent, strhash(str));
 142         entry.key = str;
 143         ret = hashmap_remove_entry(&map->map, &entry, ent, NULL);
 144         if (!ret)
 145                 return;
 146         if (free_value)
 147                 free(ret->value);
 148         if (!map->pool)
 149                 free(ret);
 150 }
 151
 152 void strintmap_incr(struct strintmap *map, const char *str, intptr_t amt)
 153 {
 154         struct strmap_entry *entry = find_strmap_entry(&map->map, str);
 155         if (entry) {
 156                 intptr_t *whence = (intptr_t*)&entry->value;
 157                 *whence += amt;
 158         }
 159         else
 160                 strintmap_set(map, str, map->default_value + amt);
 161 }
 162
 163 int strset_add(struct strset *set, const char *str)
 164 {
 165         /*
 166          * Cannot use strmap_put() because it'll return NULL in both cases:
 167          *   - cannot find str: NULL means "not found"
 168          *   - does find str: NULL is the value associated with str
 169          */
 170         struct strmap_entry *entry = find_strmap_entry(&set->map, str);
 171
 172         if (entry)
 173                 return 0;
 174
 175         entry = create_entry(&set->map, str, NULL);
 176         hashmap_add(&set->map.map, &entry->ent);
 177         return 1;
 178 }