strmap.h

   1 #ifndef STRMAP_H
   2 #define STRMAP_H
   3
   4 #include "hashmap.h"
   5
   6 struct mem_pool;
   7 struct strmap {
   8         struct hashmap map;
   9         struct mem_pool *pool;
  10         unsigned int strdup_strings:1;
  11 };
  12
  13 struct strmap_entry {
  14         struct hashmap_entry ent;
  15         const char *key;
  16         void *value;
  17         /* strmap_entry may be allocated extra space to store the key at end */
  18 };
  19
  20 int cmp_strmap_entry(const void *hashmap_cmp_fn_data,
  21                      const struct hashmap_entry *entry1,
  22                      const struct hashmap_entry *entry2,
  23                      const void *keydata);
  24
  25 #define STRMAP_INIT { \
  26                         .map = HASHMAP_INIT(cmp_strmap_entry, NULL),  \
  27                         .strdup_strings = 1,                          \
  28                     }
  29 #define STRINTMAP_INIT { \
  30                         .map = STRMAP_INIT,   \
  31                         .default_value = 0,   \
  32                        }
  33 #define STRSET_INIT { .map = STRMAP_INIT }
  34
  35 /*
  36  * Initialize the members of the strmap.  Any keys added to the strmap will
  37  * be strdup'ed with their memory managed by the strmap.
  38  */
  39 void strmap_init(struct strmap *map);
  40
  41 /*
  42  * Same as strmap_init, but for those who want to control the memory management
  43  * carefully instead of using the default of strdup_strings=1 and pool=NULL.
  44  */
  45 void strmap_init_with_options(struct strmap *map,
  46                               struct mem_pool *pool,
  47                               int strdup_strings);
  48
  49 /*
  50  * Remove all entries from the map, releasing any allocated resources.
  51  */
  52 void strmap_clear(struct strmap *map, int free_values);
  53
  54 /*
  55  * Similar to strmap_clear() but leaves map->map->table allocated and
  56  * pre-sized so that subsequent uses won't need as many rehashings.
  57  */
  58 void strmap_partial_clear(struct strmap *map, int free_values);
  59
  60 /*
  61  * Insert "str" into the map, pointing to "data".
  62  *
  63  * If an entry for "str" already exists, its data pointer is overwritten, and
  64  * the original data pointer returned. Otherwise, returns NULL.
  65  */
  66 void *strmap_put(struct strmap *map, const char *str, void *data);
  67
  68 /*
  69  * Return the strmap_entry mapped by "str", or NULL if there is not such
  70  * an item in map.
  71  */
  72 struct strmap_entry *strmap_get_entry(struct strmap *map, const char *str);
  73
  74 /*
  75  * Return the data pointer mapped by "str", or NULL if the entry does not
  76  * exist.
  77  */
  78 void *strmap_get(struct strmap *map, const char *str);
  79
  80 /*
  81  * Return non-zero iff "str" is present in the map. This differs from
  82  * strmap_get() in that it can distinguish entries with a NULL data pointer.
  83  */
  84 int strmap_contains(struct strmap *map, const char *str);
  85
  86 /*
  87  * Remove the given entry from the strmap.  If the string isn't in the
  88  * strmap, the map is not altered.
  89  */
  90 void strmap_remove(struct strmap *map, const char *str, int free_value);
  91
  92 /*
  93  * Return how many entries the strmap has.
  94  */
  95 static inline unsigned int strmap_get_size(struct strmap *map)
  96 {
  97         return hashmap_get_size(&map->map);
  98 }
  99
 100 /*
 101  * Return whether the strmap is empty.
 102  */
 103 static inline int strmap_empty(struct strmap *map)
 104 {
 105         return strmap_get_size(map) == 0;
 106 }
 107
 108 /*
 109  * iterate through @map using @iter, @var is a pointer to a type strmap_entry
 110  */
 111 #define strmap_for_each_entry(mystrmap, iter, var)      \
 112         hashmap_for_each_entry(&(mystrmap)->map, iter, var, ent)
 113
 114
 115 /*
 116  * strintmap:
 117  *    A map of string -> int, typecasting the void* of strmap to an int.
 118  *
 119  * Primary differences:
 120  *    1) Since the void* value is just an int in disguise, there is no value
 121  *       to free.  (Thus one fewer argument to strintmap_clear)
 122  *    2) strintmap_get() returns an int, or returns the default_value if the
 123  *       key is not found in the strintmap.
 124  *    3) No strmap_put() equivalent; strintmap_set() and strintmap_incr()
 125  *       instead.
 126  */
 127
 128 struct strintmap {
 129         struct strmap map;
 130         int default_value;
 131 };
 132
 133 #define strintmap_for_each_entry(mystrmap, iter, var)   \
 134         strmap_for_each_entry(&(mystrmap)->map, iter, var)
 135
 136 static inline void strintmap_init(struct strintmap *map, int default_value)
 137 {
 138         strmap_init(&map->map);
 139         map->default_value = default_value;
 140 }
 141
 142 static inline void strintmap_init_with_options(struct strintmap *map,
 143                                                int default_value,
 144                                                struct mem_pool *pool,
 145                                                int strdup_strings)
 146 {
 147         strmap_init_with_options(&map->map, pool, strdup_strings);
 148         map->default_value = default_value;
 149 }
 150
 151 static inline void strintmap_clear(struct strintmap *map)
 152 {
 153         strmap_clear(&map->map, 0);
 154 }
 155
 156 static inline void strintmap_partial_clear(struct strintmap *map)
 157 {
 158         strmap_partial_clear(&map->map, 0);
 159 }
 160
 161 static inline int strintmap_contains(struct strintmap *map, const char *str)
 162 {
 163         return strmap_contains(&map->map, str);
 164 }
 165
 166 static inline void strintmap_remove(struct strintmap *map, const char *str)
 167 {
 168         strmap_remove(&map->map, str, 0);
 169 }
 170
 171 static inline int strintmap_empty(struct strintmap *map)
 172 {
 173         return strmap_empty(&map->map);
 174 }
 175
 176 static inline unsigned int strintmap_get_size(struct strintmap *map)
 177 {
 178         return strmap_get_size(&map->map);
 179 }
 180
 181 /*
 182  * Returns the value for str in the map.  If str isn't found in the map,
 183  * the map's default_value is returned.
 184  */
 185 static inline int strintmap_get(struct strintmap *map, const char *str)
 186 {
 187         struct strmap_entry *result = strmap_get_entry(&map->map, str);
 188         if (!result)
 189                 return map->default_value;
 190         return (intptr_t)result->value;
 191 }
 192
 193 static inline void strintmap_set(struct strintmap *map, const char *str,
 194                                  intptr_t v)
 195 {
 196         strmap_put(&map->map, str, (void *)v);
 197 }
 198
 199 /*
 200  * Increment the value for str by amt.  If str isn't in the map, add it and
 201  * set its value to default_value + amt.
 202  */
 203 void strintmap_incr(struct strintmap *map, const char *str, intptr_t amt);
 204
 205 /*
 206  * strset:
 207  *    A set of strings.
 208  *
 209  * Primary differences with strmap:
 210  *    1) The value is always NULL, and ignored.  As there is no value to free,
 211  *       there is one fewer argument to strset_clear
 212  *    2) No strset_get() because there is no value.
 213  *    3) No strset_put(); use strset_add() instead.
 214  */
 215
 216 struct strset {
 217         struct strmap map;
 218 };
 219
 220 #define strset_for_each_entry(mystrset, iter, var)      \
 221         strmap_for_each_entry(&(mystrset)->map, iter, var)
 222
 223 static inline void strset_init(struct strset *set)
 224 {
 225         strmap_init(&set->map);
 226 }
 227
 228 static inline void strset_init_with_options(struct strset *set,
 229                                             struct mem_pool *pool,
 230                                             int strdup_strings)
 231 {
 232         strmap_init_with_options(&set->map, pool, strdup_strings);
 233 }
 234
 235 static inline void strset_clear(struct strset *set)
 236 {
 237         strmap_clear(&set->map, 0);
 238 }
 239
 240 static inline void strset_partial_clear(struct strset *set)
 241 {
 242         strmap_partial_clear(&set->map, 0);
 243 }
 244
 245 static inline int strset_contains(struct strset *set, const char *str)
 246 {
 247         return strmap_contains(&set->map, str);
 248 }
 249
 250 static inline void strset_remove(struct strset *set, const char *str)
 251 {
 252         strmap_remove(&set->map, str, 0);
 253 }
 254
 255 static inline int strset_empty(struct strset *set)
 256 {
 257         return strmap_empty(&set->map);
 258 }
 259
 260 static inline unsigned int strset_get_size(struct strset *set)
 261 {
 262         return strmap_get_size(&set->map);
 263 }
 264
 265 /* Returns 1 if str is added to the set; returns 0 if str was already in set */
 266 int strset_add(struct strset *set, const char *str);
 267
 268 #endif /* STRMAP_H */