git@vger.kernel.org list mirror (unofficial, one of many)
 help / color / mirror / code / Atom feed
fe15e74b78a54cf3c8d83a3048c750533f5d2627 blob 4771 bytes (raw)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
 
#ifndef STRMAP_H
#define STRMAP_H

#include "hashmap.h"

struct strmap {
	struct hashmap map;
	unsigned int strdup_strings:1;
};

struct strmap_entry {
	struct hashmap_entry ent;
	const char *key;
	void *value;
};

/*
 * 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.
 * (OCD = Obsessive Compulsive Disorder, a joke that those who use this function
 * are obsessing over minor details.)
 */
void strmap_ocd_init(struct strmap *map,
		     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 whether the strmap is empty.
 */
static inline int strmap_empty(struct strmap *map)
{
	return hashmap_get_size(&map->map) == 0;
}

/*
 * Return how many entries the strmap has.
 */
static inline unsigned int strmap_get_size(struct strmap *map)
{
	return hashmap_get_size(&map->map);
}

/*
 * iterate through @map using @iter, @var is a pointer to a type strmap_entry
 */
#define strmap_for_each_entry(mystrmap, iter, var)	\
	for (var = hashmap_iter_first_entry_offset(&(mystrmap)->map, iter, \
						   OFFSETOF_VAR(var, ent)); \
		var; \
		var = hashmap_iter_next_entry_offset(iter, \
						     OFFSETOF_VAR(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; it also requires an extra parameter to
 *       be specified so it knows what value to return if the underlying strmap
 *       has not key matching the given string.
 *    3) No strmap_put() equivalent; strintmap_set() and strintmap_incr()
 *       instead.
 */

struct strintmap {
	struct strmap map;
};

#define strintmap_for_each_entry(mystrmap, iter, var)	\
	strmap_for_each_entry(&(mystrmap)->map, iter, var)

static inline void strintmap_init(struct strintmap *map)
{
	strmap_init(&map->map);
}

static inline void strintmap_ocd_init(struct strintmap *map,
				      int strdup_strings)
{
	strmap_ocd_init(&map->map, strdup_strings);
}

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);
}

static inline int strintmap_get(struct strintmap *map, const char *str,
				int default_value)
{
	struct strmap_entry *result = strmap_get_entry(&map->map, str);
	if (!result)
		return 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);
}

void strintmap_incr(struct strintmap *map, const char *str, intptr_t amt);

#endif /* STRMAP_H */
debug log:

solving fe15e74b78 ...
found fe15e74b78 in https://public-inbox.org/git/cc8d702f98f94fd9202d227d19be43a912467e84.1602549650.git.gitgitgadget@gmail.com/
found 5bb7650d65 in https://public-inbox.org/git/2ebce0c5d82b87fa9c9ef5dcefc0ac2701654f3b.1602549650.git.gitgitgadget@gmail.com/
found e49d020970 in https://public-inbox.org/git/61b5bf11103a7bd12de8fd066e128c469da3a0a4.1602549650.git.gitgitgadget@gmail.com/
found 493d19cbc0 in https://public-inbox.org/git/5c7507f55b09e24c0bfe87cc3df06213cfd1235b.1602549650.git.gitgitgadget@gmail.com/

applying [1/4] https://public-inbox.org/git/5c7507f55b09e24c0bfe87cc3df06213cfd1235b.1602549650.git.gitgitgadget@gmail.com/
diff --git a/strmap.h b/strmap.h
new file mode 100644
index 0000000000..493d19cbc0


applying [2/4] https://public-inbox.org/git/61b5bf11103a7bd12de8fd066e128c469da3a0a4.1602549650.git.gitgitgadget@gmail.com/
diff --git a/strmap.h b/strmap.h
index 493d19cbc0..e49d020970 100644


applying [3/4] https://public-inbox.org/git/2ebce0c5d82b87fa9c9ef5dcefc0ac2701654f3b.1602549650.git.gitgitgadget@gmail.com/
diff --git a/strmap.h b/strmap.h
index e49d020970..5bb7650d65 100644


applying [4/4] https://public-inbox.org/git/cc8d702f98f94fd9202d227d19be43a912467e84.1602549650.git.gitgitgadget@gmail.com/
diff --git a/strmap.h b/strmap.h
index 5bb7650d65..fe15e74b78 100644

Checking patch strmap.h...
Applied patch strmap.h cleanly.
Checking patch strmap.h...
Applied patch strmap.h cleanly.
Checking patch strmap.h...
Applied patch strmap.h cleanly.
Checking patch strmap.h...
Applied patch strmap.h cleanly.

index at:
100644 fe15e74b78a54cf3c8d83a3048c750533f5d2627	strmap.h

git@vger.kernel.org list mirror (unofficial, one of many)

This inbox may be cloned and mirrored by anyone:

	git clone --mirror https://public-inbox.org/git
	git clone --mirror http://ou63pmih66umazou.onion/git
	git clone --mirror http://czquwvybam4bgbro.onion/git
	git clone --mirror http://hjrcffqmbrq6wope.onion/git

	# If you have public-inbox 1.1+ installed, you may
	# initialize and index your mirror using the following commands:
	public-inbox-init -V1 git git/ https://public-inbox.org/git \
		git@vger.kernel.org
	public-inbox-index git

Example config snippet for mirrors.
Newsgroups are available over NNTP:
	nntp://news.public-inbox.org/inbox.comp.version-control.git
	nntp://7fh6tueqddpjyxjmgtdiueylzoqt6pt7hec3pukyptlmohoowvhde4yd.onion/inbox.comp.version-control.git
	nntp://ie5yzdi7fg72h7s4sdcztq5evakq23rdt33mfyfcddc5u3ndnw24ogqd.onion/inbox.comp.version-control.git
	nntp://4uok3hntl7oi7b4uf4rtfwefqeexfzil2w6kgk2jn5z2f764irre7byd.onion/inbox.comp.version-control.git
	nntp://news.gmane.io/gmane.comp.version-control.git
 note: .onion URLs require Tor: https://www.torproject.org/

code repositories for project(s) associated with this inbox:

	https://80x24.org/mirrors/git.git

AGPL code for this site: git clone https://public-inbox.org/public-inbox.git