strmap.c

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