1 /* Licensed under LGPLv2+ - see LICENSE file for details */ 2 #ifndef CCAN_HTABLE_TYPE_H 3 #define CCAN_HTABLE_TYPE_H 4 #include <ccan/htable/htable.h> 5 #include "config.h" 6 7 /** 8 * HTABLE_DEFINE_TYPE - create a set of htable ops for a type 9 * @type: a type whose pointers will be values in the hash. 10 * @keyof: a function/macro to extract a key: <keytype> @keyof(const type *elem) 11 * @hashfn: a hash function for a @key: size_t @hashfn(const <keytype> *) 12 * @eqfn: an equality function keys: bool @eqfn(const type *, const <keytype> *) 13 * @prefix: a prefix for all the functions to define (of form <name>_*) 14 * 15 * NULL values may not be placed into the hash table. 16 * 17 * This defines the type hashtable type and an iterator type: 18 * struct <name>; 19 * struct <name>_iter; 20 * 21 * It also defines initialization and freeing functions: 22 * void <name>_init(struct <name> *); 23 * void <name>_clear(struct <name> *); 24 * 25 * Add function only fails if we run out of memory: 26 * bool <name>_add(struct <name> *ht, const <type> *e); 27 * 28 * Delete and delete-by key return true if it was in the set: 29 * bool <name>_del(struct <name> *ht, const <type> *e); 30 * bool <name>_delkey(struct <name> *ht, const <keytype> *k); 31 * 32 * Find function return the matching element, or NULL: 33 * type *<name>_get(const struct @name *ht, const <keytype> *k); 34 * 35 * Iteration over hashtable is also supported: 36 * type *<name>_first(const struct <name> *ht, struct <name>_iter *i); 37 * type *<name>_next(const struct <name> *ht, struct <name>_iter *i); 38 * 39 * It's currently safe to iterate over a changing hashtable, but you might 40 * miss an element. Iteration isn't very efficient, either. 41 * 42 * You can use HTABLE_INITIALIZER like so: 43 * struct <name> ht = { HTABLE_INITIALIZER(ht.raw, <name>_hash, NULL) }; 44 */ 45 #define HTABLE_DEFINE_TYPE(type, keyof, hashfn, eqfn, name) \ 46 struct name { struct htable raw; }; \ 47 struct name##_iter { struct htable_iter i; }; \ 48 static inline size_t name##_hash(const void *elem, void *priv) \ 49 { \ 50 return hashfn(keyof((const type *)elem)); \ 51 } \ 52 static inline void name##_init(struct name *ht) \ 53 { \ 54 htable_init(&ht->raw, name##_hash, NULL); \ 55 } \ 56 static inline void name##_clear(struct name *ht) \ 57 { \ 58 htable_clear(&ht->raw); \ 59 } \ 60 static inline bool name##_add(struct name *ht, const type *elem) \ 61 { \ 62 return htable_add(&ht->raw, hashfn(keyof(elem)), elem); \ 63 } \ 64 static inline bool name##_del(struct name *ht, const type *elem) \ 65 { \ 66 return htable_del(&ht->raw, hashfn(keyof(elem)), elem); \ 67 } \ 68 static inline type *name##_get(const struct name *ht, \ 69 const HTABLE_KTYPE(keyof) k) \ 70 { \ 71 /* Typecheck for eqfn */ \ 72 (void)sizeof(eqfn((const type *)NULL, \ 73 keyof((const type *)NULL))); \ 74 return htable_get(&ht->raw, \ 75 hashfn(k), \ 76 (bool (*)(const void *, void *))(eqfn), \ 77 k); \ 78 } \ 79 static inline bool name##_delkey(struct name *ht, \ 80 const HTABLE_KTYPE(keyof) k) \ 81 { \ 82 type *elem = name##_get(ht, k); \ 83 if (elem) \ 84 return name##_del(ht, elem); \ 85 return false; \ 86 } \ 87 static inline type *name##_first(const struct name *ht, \ 88 struct name##_iter *iter) \ 89 { \ 90 return htable_first(&ht->raw, &iter->i); \ 91 } \ 92 static inline type *name##_next(const struct name *ht, \ 93 struct name##_iter *iter) \ 94 { \ 95 return htable_next(&ht->raw, &iter->i); \ 96 } 97 98 #if HAVE_TYPEOF 99 #define HTABLE_KTYPE(keyof) typeof(keyof(NULL)) 100 #else 101 #define HTABLE_KTYPE(keyof) void * 102 #endif 103 #endif /* CCAN_HTABLE_TYPE_H */ 104