]>
git.datanom.net - hashtable.git/blob - test.c
10 typedef struct _Node
{
14 uint64_t word_hash_func(const void* o
) {
15 uint64_t hash_value
= 0;
17 for (size_t i
= 0; i
< strlen(name
); i
++) {
18 hash_value
+= name
[i
];
19 hash_value
= hash_value
* name
[i
];
24 void generate_random_word(char* buffer
, size_t length
) {
25 for (size_t i
= 0; i
< length
- 1; i
++) {
26 buffer
[i
] = 'a' + (rand() % 26);
28 buffer
[length
- 1] = 0;
31 void my_str_free(void* o
) {
32 printf("Freeing %p\n", o
);
36 void my_ptr_free(void* o
) {
38 //printf("Freeing %p\n", node);
43 void my_print(void* o
) {
45 printf("%s", n
->name
);
48 bool my_ptr_equal(const void* a
, const void* b
) {
49 const Node
* nodea
= a
;
50 const Node
* nodeb
= b
;
52 if (nodea
== NULL
|| nodeb
== NULL
) return false;
53 if (nodea
->name
== NULL
|| nodeb
->name
== NULL
) return false;
55 printf("Comparing %s to %s\n", nodea
->name
, nodeb
->name
);
56 if (strcmp(nodea
->name
, nodeb
->name
) == 0)
61 void count_good_guesses(void* key
, void* value
, void* userdata
) {
62 uint32_t* good_guesses
= userdata
;
66 char* s1
= node
->name
;
67 printf("%u: Found: %p - %s\n", *good_guesses
, key
, s1
);
70 int main(int argc
, char** argv
) {
72 printf("usage: %s <wordlist filename> <num guesses>\n", argv
[0]);
76 char* filename
= argv
[1];
77 uint32_t num_guesses
= atol(argv
[2]);
79 Hashtable
* table
= /*hash_table_create(str_hash, str_equal)*/ hash_table_create_notify(ptr_hash
, my_ptr_equal
, my_ptr_free
);
81 FILE* fp
= fopen(filename
, "r");
82 char* buffer
= calloc(sizeof(char), MAX_LINE
);
83 uint32_t numwords
= 0;
85 while (!feof(fp
) && fgets(buffer
, MAX_LINE
, fp
) != NULL
) {
86 buffer
[strcspn(buffer
, "\r\n")] = 0;
87 /* char* newentry = strdup(buffer);
88 bool result = hash_table_insert(table, newentry, newentry);
89 if (result == false) {
90 printf("Failed [%u] storing %s\n", ++failed, newentry);
95 Node
* node
= calloc(sizeof(Node
*), 1);
96 node
->name
= strdup(buffer
);
97 bool result
= hash_table_insert(table
, node
, node
);
98 if (result
== false) {
99 printf("Failed [%u] storing %s\n", ++failed
, node
->name
);
107 printf("Loaded %d words into the table.\n", numwords
);
108 hash_table_print(table
);
109 hash_table_set_print_func(table
, my_print
);
110 hash_table_print(table
);
113 uint32_t good_guesses = 0;
114 fp = fopen(filename, "r");
116 Node* node = calloc(sizeof(Node*), 1);
117 while (!feof(fp) && fgets(buffer, MAX_LINE, fp) != NULL) {
118 buffer[strcspn(buffer, "\r\n")] = 0;
119 node->name = strdup(buffer);
120 //printf("Buffer: %s\n", node->name);
121 if ((data = hash_table_lookup(table, node)) != NULL) {
122 char* s1 = ((Node*) data)->name;
123 printf("Lookup: %s - Found: %s\n", node->name, s1);
133 //hash_table_print(table);
134 uint32_t good_guesses = 0;
135 const int shortest_guess = 2;
136 const int longest_guess = 15;
138 Node* lookup = calloc(sizeof(Node*), 1);
139 for (uint32_t i = 0; i < num_guesses; i++) {
140 generate_random_word(buffer, shortest_guess +
141 (rand() % (longest_guess - shortest_guess)));
142 lookup->name = strdup(buffer);
143 printf("Buffer: %s\n", lookup->name);
144 if ((data = hash_table_lookup(table, lookup)) != NULL) {
145 char* s1 = ((Node*) data)->name;
146 printf("Lookup: %s - Found: %s\n", lookup->name, s1);
153 printf("%u out of %u guesses were in the table\n", good_guesses, num_guesses);
157 printf("---------------------------------------\n");
158 List
* values
= hash_table_values(table
);
162 uint32_t good_guesses
= 0;
163 while (head
!= NULL
) {
164 Node
* d
= head
->data
;
165 printf("%lu: %s\n", i
++, (char *) d
->name
);
166 if ((data
= hash_table_lookup(table
, d
)) != NULL
) {
167 char* s1
= ((Node
*) data
)->name
;
168 printf("Lookup: %s - Found: %s\n", d
->name
, s1
);
173 hash_table_list_free(values
);
175 printf("%u out of %u inserted words in table were in the table\n", good_guesses
, numwords
);
178 List* keys = hash_table_keys(table);
183 while (head != NULL) {
184 Node* d = head->data;
185 printf("%lu: %p\n", i++, d->name);
186 if ((data = hash_table_lookup(table, d)) != NULL) {
187 char* s1 = ((Node*) data)->name;
188 printf("Lookup: %s - Found: %s\n", d->name, s1);
193 hash_table_list_free(keys);
196 hash_table_foreach(table
, count_good_guesses
, &good_guesses
);
198 printf("%u out of %u inserted words in table were in the table\n", good_guesses
, numwords
);
204 hash_table_iter_init(&iter
, table
);
205 while (hash_table_iter_next(&iter
, &key
, &value
)) {
206 char* s1
= ((Node
*) value
)->name
;
207 printf("Key: %p value: %s\n", key
, s1
);
210 Node
* node1
= calloc(sizeof(Node
*), 1);
211 node1
->name
= strdup("Dummy Test Name");
212 if (hash_table_insert(table
, node1
, node1
) == true) {
213 hash_table_iter_init(&iter
, table
);
214 printf("Hashtable size: %lu. Key found: %d\n", hash_table_size(table
), hash_table_contains(table
, node1
));
215 void* data
= hash_table_delete(table
, node1
);
216 printf("Deleted: [%p] %s\n", node1
, ((Node
*) data
)->name
);
217 free(((Node
*) data
)->name
);
219 printf("Hashtable size: %lu. Key found: %d\n", hash_table_size(table
), hash_table_contains(table
, node1
));
220 Node
* node2
= calloc(sizeof(Node
*), 1);
221 node2
->name
= strdup("Test Name");
222 hash_table_replace(table
, node2
, node2
);
223 printf("Hashtable size: %lu. Key found: %d\n", hash_table_size(table
), hash_table_contains(table
, node2
));
226 hash_table_destroy(table
);
228 table
= hash_table_create(str_hash
, str_equal
);
229 char *names
[] = { "Adam", "Eva", "Abraham", "Kain", "Abel", NULL
};
230 for (int i
= 0; names
[i
]; i
++) {
231 void* name
= names
[i
];
232 hash_table_insert(table
, name
, strdup(name
));
234 hash_table_iter_init(&iter
, table
);
235 while (hash_table_iter_next(&iter
, &key
, &value
)) {
236 printf("Key: %p value: %s\n", (char*)key
, (char*)value
);
238 data
= hash_table_delete(table
, (void*) names
[4]);
239 printf("Deleted: [%p] %s\n", data
, (char*) data
);
241 hash_table_replace(table
, (void*) names
[4], strdup(names
[4]));
242 hash_table_replace(table
, (void*) names
[4], strdup("Johannes"));
243 hash_table_iter_init(&iter
, table
);
244 while (hash_table_iter_next(&iter
, &key
, &value
)) {
245 printf("Key: %p value: %s\n", (char*)key
, (char*)value
);
248 hash_table_destroy(table
);
This page took 0.089984 seconds and 6 git commands to generate.