antithread, foreach, grab_file, hashtable, str_talloc: fix _info depends.
[ccan] / ccan / hashtable / _info
1 #include <string.h>
2 #include <stdio.h>
3
4 /**
5  * hashtable - hash table routines
6  *
7  * A hash table is an efficient structure for looking up keys.  This version
8  * grows with usage and allows efficient deletion.
9  *
10  * Caveat: pointers placed into the hash must be aligned to 64 bits.
11  * ie. from malloc or because the structure they point to is aligned.
12  * An assert will be raised if this isn't true.
13  *
14  * Example:
15  *      #include <ccan/hashtable/hashtable.h>
16  *      #include <ccan/hash/hash.h>
17  *      #include <stdio.h>
18  *      #include <err.h>
19  *      #include <string.h>
20  *      
21  *      struct name_to_digit {
22  *              const char *name;
23  *              unsigned int val;
24  *      };
25  *      
26  *      static struct name_to_digit map[] = { 
27  *              { "zero", 0},
28  *              { "one", 1 },
29  *              { "two", 2 },
30  *              { "three", 3 },
31  *              { "four", 4 },
32  *              { "five", 5 },
33  *              { "six", 6 },
34  *              { "seven", 7 },
35  *              { "eight", 8 },
36  *              { "nine", 9 }
37  *      };
38  *      
39  *      // Wrapper for rehash function pointer.
40  *      static unsigned long rehash(const void *e, void *unused)
41  *      {
42  *              return hash_string(((struct name_to_digit *)e)->name);
43  *      }
44  *      
45  *      // Comparison function.
46  *      static bool streq(const void *e, void *string)
47  *      {
48  *              return strcmp(((struct name_to_digit *)e)->name, string) == 0;
49  *      }
50  *      
51  *      // We let them add their own aliases, eg. --alias=v=5
52  *      static void add_alias(struct hashtable *ht, const char *alias)
53  *      {
54  *              char *eq;
55  *              struct name_to_digit *n;
56  *      
57  *              n = malloc(sizeof(*n));
58  *              n->name = strdup(alias);
59  *      
60  *              eq = strchr(n->name, '=');
61  *              if (!eq || ((n->val = atoi(eq+1)) == 0 && !strcmp(eq+1, "0")))
62  *                      errx(1, "Usage: --alias=<name>=<value>");
63  *              *eq = '\0';
64  *              hashtable_add(ht, hash_string(n->name), n);
65  *      }
66  *      
67  *      int main(int argc, char *argv[])
68  *      {
69  *              struct hashtable *ht;
70  *              unsigned int i;
71  *              unsigned long val;
72  *      
73  *              if (argc < 2)
74  *                      errx(1, "Usage: %s [--alias=<name>=<val>]... <str>...",
75  *                           argv[0]);
76  *      
77  *              // Create and populate hash table.
78  *              ht = hashtable_new(rehash, NULL);
79  *              for (i = 0; i < sizeof(map)/sizeof(map[0]); i++)
80  *                      hashtable_add(ht, hash_string(map[i].name), &map[i]);
81  *      
82  *              // Add any aliases to the hash table.
83  *              for (i = 1; i < argc; i++) {
84  *                      if (!strncmp(argv[i], "--alias=", strlen("--alias=")))
85  *                              add_alias(ht, argv[i] + strlen("--alias="));
86  *                      else
87  *                              break;
88  *              }
89  *      
90  *              // Find the other args in the hash table.
91  *              for (val = 0; i < argc; i++) {
92  *                      struct name_to_digit *n;
93  *                      n = hashtable_find(ht, hash_string(argv[i]),
94  *                                         streq, argv[i]);
95  *                      if (!n)
96  *                              errx(1, "Invalid digit name %s", argv[i]);
97  *                      // Append it to the value we are building up.
98  *                      val *= 10;
99  *                      val += n->val;
100  *              }
101  *              printf("%lu\n", val);
102  *              return 0;
103  *      }
104  *
105  * License: GPLv2 (or later)
106  * Author: Rusty Russell <rusty@rustcorp.com.au>
107  */
108 int main(int argc, char *argv[])
109 {
110         if (argc != 2)
111                 return 1;
112
113         if (strcmp(argv[1], "depends") == 0) {
114                 printf("ccan/typesafe_cb\n");
115                 return 0;
116         }
117
118         return 1;
119 }