ttxml: removed cruft from tests
[ccan] / ccan / htable / htable_type.h
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 */