/src/git/strmap.h

Source (jump to first uncovered line)
#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)
{
  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)
{
  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 */

Coverage Report

Created: 2024-09-08 06:23

Line	Count	Source (jump to first uncovered line)
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	0	#define STRMAP_INIT { \
26	0	.map = HASHMAP_INIT(cmp_strmap_entry, NULL), \
27	0	.strdup_strings = 1, \
28	0	}
29		#define STRINTMAP_INIT { \
30		.map = STRMAP_INIT, \
31		.default_value = 0, \
32		}
33	0	#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);