[systemd-devel] [PATCH 01/26] hashmap: add LinkedHashmap as a distinct type

[Michal Schmidt]

Few Hashmaps/Sets need to remember the insertion order. Most don't care
about the order when iterating. It would be possible to use more compact
hashmap storage in the latter cases.

Add LinkedHashmap as a distinct type from Hashmap, with functions
prefixed with "linked_". For now, the functions are nothing more than
inline wrappers for plain Hashmap functions.
---
 src/shared/hashmap.h | 116 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 116 insertions(+)

diff --git a/src/shared/hashmap.h b/src/shared/hashmap.h
index e25840f..2a4277d 100644
--- a/src/shared/hashmap.h
+++ b/src/shared/hashmap.h
@@ -34,6 +34,7 @@
 #define HASH_KEY_SIZE 16
 
 typedef struct Hashmap Hashmap;
+typedef struct LinkedHashmap LinkedHashmap;
 typedef struct _IteratorStruct _IteratorStruct;
 typedef _IteratorStruct* Iterator;
 
@@ -82,56 +83,171 @@ extern const struct hash_ops devt_hash_ops = {
 #endif
 
 Hashmap *hashmap_new(const struct hash_ops *hash_ops);
+static inline LinkedHashmap *linked_hashmap_new(const struct hash_ops *hash_ops) {
+        return (LinkedHashmap*) hashmap_new(hash_ops);
+}
 void hashmap_free(Hashmap *h);
+static inline void linked_hashmap_free(LinkedHashmap *h) {
+        hashmap_free((Hashmap*) h);
+}
 void hashmap_free_free(Hashmap *h);
+static inline void linked_hashmap_free_free(LinkedHashmap *h) {
+        hashmap_free_free((Hashmap*) h);
+}
 void hashmap_free_free_free(Hashmap *h);
+static inline void linked_hashmap_free_free_free(LinkedHashmap *h) {
+        hashmap_free_free_free((Hashmap*) h);
+}
 Hashmap *hashmap_copy(Hashmap *h);
+static inline LinkedHashmap *linked_hashmap_copy(LinkedHashmap *h) {
+        return (LinkedHashmap*) hashmap_copy((Hashmap*) h);
+}
 int hashmap_ensure_allocated(Hashmap **h, const struct hash_ops *hash_ops);
+static inline int linked_hashmap_ensure_allocated(LinkedHashmap **h, const struct hash_ops *hash_ops) {
+        return hashmap_ensure_allocated((Hashmap**) h, hash_ops);
+}
 
 int hashmap_put(Hashmap *h, const void *key, void *value);
+static inline int linked_hashmap_put(LinkedHashmap *h, const void *key, void *value) {
+        return hashmap_put((Hashmap*) h, key, value);
+}
 int hashmap_update(Hashmap *h, const void *key, void *value);
+static inline int linked_hashmap_update(LinkedHashmap *h, const void *key, void *value) {
+        return hashmap_update((Hashmap*) h, key, value);
+}
 int hashmap_replace(Hashmap *h, const void *key, void *value);
+static inline int linked_hashmap_replace(LinkedHashmap *h, const void *key, void *value) {
+        return hashmap_replace((Hashmap*) h, key, value);
+}
 void *hashmap_get(Hashmap *h, const void *key);
+static inline void *linked_hashmap_get(LinkedHashmap *h, const void *key) {
+        return hashmap_get((Hashmap*) h, key);
+}
 void *hashmap_get2(Hashmap *h, const void *key, void **rkey);
+static inline void *linked_hashmap_get2(LinkedHashmap *h, const void *key, void **rkey) {
+        return hashmap_get2((Hashmap*) h, key, rkey);
+}
 bool hashmap_contains(Hashmap *h, const void *key);
+static inline bool linked_hashmap_contains(LinkedHashmap *h, const void *key) {
+        return hashmap_contains((Hashmap*) h, key);
+}
 void *hashmap_remove(Hashmap *h, const void *key);
+static inline void *linked_hashmap_remove(LinkedHashmap *h, const void *key) {
+        return hashmap_remove((Hashmap*) h, key);
+}
 void *hashmap_remove2(Hashmap *h, const void *key, void **rkey);
+static inline void *linked_hashmap_remove2(LinkedHashmap *h, const void *key, void **rkey) {
+        return hashmap_remove2((Hashmap*) h, key, rkey);
+}
 void *hashmap_remove_value(Hashmap *h, const void *key, void *value);
+static inline void *linked_hashmap_remove_value(LinkedHashmap *h, const void *key, void *value) {
+        return hashmap_remove_value((Hashmap*) h, key, value);
+}
 int hashmap_remove_and_put(Hashmap *h, const void *old_key, const void *new_key, void *value);
+static inline int linked_hashmap_remove_and_put(LinkedHashmap *h, const void *old_key, const void *new_key, void *value) {
+        return hashmap_remove_and_put((Hashmap*) h, old_key, new_key, value);
+}
 int hashmap_remove_and_replace(Hashmap *h, const void *old_key, const void *new_key, void *value);
+static inline int linked_hashmap_remove_and_replace(LinkedHashmap *h, const void *old_key, const void *new_key, void *value) {
+        return hashmap_remove_and_replace((Hashmap*) h, old_key, new_key, value);
+}
 
 int hashmap_merge(Hashmap *h, Hashmap *other);
+static inline int linked_hashmap_merge(LinkedHashmap *h, LinkedHashmap *other) {
+        return hashmap_merge((Hashmap*) h, (Hashmap*) other);
+}
 void hashmap_move(Hashmap *h, Hashmap *other);
+static inline void linked_hashmap_move(LinkedHashmap *h, LinkedHashmap *other) {
+        hashmap_move((Hashmap*) h, (Hashmap*) other);
+}
 int hashmap_move_one(Hashmap *h, Hashmap *other, const void *key);
+static inline int linked_hashmap_move_one(LinkedHashmap *h, LinkedHashmap *other, const void *key) {
+        return hashmap_move_one((Hashmap*) h, (Hashmap*) other, key);
+}
 
 unsigned hashmap_size(Hashmap *h) _pure_;
+static inline unsigned linked_hashmap_size(LinkedHashmap *h) {
+        return hashmap_size((Hashmap*) h);
+}
 bool hashmap_isempty(Hashmap *h) _pure_;
+static inline bool linked_hashmap_isempty(LinkedHashmap *h) {
+        return hashmap_isempty((Hashmap*) h);
+}
 unsigned hashmap_buckets(Hashmap *h) _pure_;
+static inline unsigned linked_hashmap_buckets(LinkedHashmap *h) {
+        return hashmap_buckets((Hashmap*) h);
+}
 
 void *hashmap_iterate(Hashmap *h, Iterator *i, const void **key);
+static inline void *linked_hashmap_iterate(LinkedHashmap *h, Iterator *i, const void **key) {
+        return hashmap_iterate((Hashmap*) h, i, key);
+}
 
 void hashmap_clear(Hashmap *h);
+static inline void linked_hashmap_clear(LinkedHashmap *h) {
+        hashmap_clear((Hashmap*) h);
+}
 void hashmap_clear_free(Hashmap *h);
+static inline void linked_hashmap_clear_free(LinkedHashmap *h) {
+        hashmap_clear_free((Hashmap*) h);
+}
 void hashmap_clear_free_free(Hashmap *h);
+static inline void linked_hashmap_clear_free_free(LinkedHashmap *h) {
+        hashmap_clear_free_free((Hashmap*) h);
+}
 
 void *hashmap_steal_first(Hashmap *h);
+static inline void *linked_hashmap_steal_first(LinkedHashmap *h) {
+        return hashmap_steal_first((Hashmap*) h);
+}
 void *hashmap_steal_first_key(Hashmap *h);
+static inline void *linked_hashmap_steal_first_key(LinkedHashmap *h) {
+        return hashmap_steal_first_key((Hashmap*) h);
+}
 void *hashmap_first(Hashmap *h) _pure_;
+static inline void *linked_hashmap_first(LinkedHashmap *h) {
+        return hashmap_first((Hashmap*) h);
+}
 void *hashmap_first_key(Hashmap *h) _pure_;
+static inline void *linked_hashmap_first_key(LinkedHashmap *h) {
+        return hashmap_first_key((Hashmap*) h);
+}
 
 void *hashmap_next(Hashmap *h, const void *key);
+static inline void *linked_hashmap_next(LinkedHashmap *h, const void *key) {
+        return hashmap_next((Hashmap*) h, key);
+}
 
 char **hashmap_get_strv(Hashmap *h);
+static inline char **linked_hashmap_get_strv(LinkedHashmap *h) {
+        return hashmap_get_strv((Hashmap*) h);
+}
 
 #define HASHMAP_FOREACH(e, h, i) \
         for ((i) = ITERATOR_FIRST, (e) = hashmap_iterate((h), &(i), NULL); (e); (e) = hashmap_iterate((h), &(i), NULL))
 
+#define LINKED_HASHMAP_FOREACH(e, h, i) \
+        for ((i) = ITERATOR_FIRST, (e) = linked_hashmap_iterate((h), &(i), NULL); \
+             (e); \
+             (e) = linked_hashmap_iterate((h), &(i), NULL))
+
 #define HASHMAP_FOREACH_KEY(e, k, h, i) \
         for ((i) = ITERATOR_FIRST, (e) = hashmap_iterate((h), &(i), (const void**) &(k)); (e); (e) = hashmap_iterate((h), &(i), (const void**) &(k)))
 
+#define LINKED_HASHMAP_FOREACH_KEY(e, k, h, i) \
+        for ((i) = ITERATOR_FIRST, (e) = linked_hashmap_iterate((h), &(i), (const void**) &(k)); \
+             (e); \
+             (e) = linked_hashmap_iterate((h), &(i), (const void**) &(k)))
+
 DEFINE_TRIVIAL_CLEANUP_FUNC(Hashmap*, hashmap_free);
 DEFINE_TRIVIAL_CLEANUP_FUNC(Hashmap*, hashmap_free_free);
 DEFINE_TRIVIAL_CLEANUP_FUNC(Hashmap*, hashmap_free_free_free);
+DEFINE_TRIVIAL_CLEANUP_FUNC(LinkedHashmap*, linked_hashmap_free);
+DEFINE_TRIVIAL_CLEANUP_FUNC(LinkedHashmap*, linked_hashmap_free_free);
+DEFINE_TRIVIAL_CLEANUP_FUNC(LinkedHashmap*, linked_hashmap_free_free_free);
 #define _cleanup_hashmap_free_ _cleanup_(hashmap_freep)
 #define _cleanup_hashmap_free_free_ _cleanup_(hashmap_free_freep)
 #define _cleanup_hashmap_free_free_free_ _cleanup_(hashmap_free_free_freep)
+#define _cleanup_linked_hashmap_free_ _cleanup_(linked_hashmap_freep)
+#define _cleanup_linked_hashmap_free_free_ _cleanup_(linked_hashmap_free_freep)
+#define _cleanup_linked_hashmap_free_free_free_ _cleanup_(linked_hashmap_free_free_freep)
-- 
2.1.0