/*
* Driver code
*/
int main()
{
hash_table_t *table = NULL;
table = hash_table_init(INITIAL_SIZE, 1);
hash_table_insert(table, "hardik");
hash_table_insert(table, "goel");
hash_table_insert(table, "goel");
hash_table_insert(table, "goel");
hash_table_insert(table, "koel");
hash_table_insert(table, "loge");
hash_table_insert(table, "goel");
hash_table_insert(table, "hardik");
hash_table_insert(table, "aljkjkafd");
hash_table_insert(table, "asldfjasldkjsflasjdfashdfajkdhfkajjdsklfajslkdfjalsdkjfalkj");
hash_table_insert(table, "asldfjasldkjsflasjdfashdfajkdhfkajjdsklfajslkdfjalsdkjfalkj");
hash_table_insert(table, "asldfjasldkjsflasjdfashdfajkdhfkajjdsklfajslkdfjalsdkjfalkj");
hash_table_insert(table, "asldfjasldkjsflasjdfashdfajkdhfkajjdsklfajslkdfjalsdkjfalkj");
hash_table_insert(table, "asldfjasldkjsflasjdfashdfajkdhfkajjdsklfajslkdfjalsdkjfalkj");
hash_table_print(table);
hash_table_delete(table, "asldfjasldkjsflasjdfashdfajkdhfkajjdsklfajslkdfjalsdkjfalkj");
hash_table_delete(table, "asldfjasldkjsflasjdfashdfajkdhfkajjdsklfajslkdfjalsdkjfalkj");
hash_table_print(table);
hash_table_insert(table, "asldfjasldkjsflasjdfashdfajkdhfkajjdsklfajslkdfjalsdkjfalkj");
hash_table_print(table);
hash_table_cleanup(table);
return 0;
}
int main(int argc, char ** argv) {
int i;
struct hash_table * table = hash_table_new(1);
struct client * cli = malloc(sizeof(struct client));
cli->name = "foo bar"; cli->credit = 5;
hash_table_store(table, cli->name, cli);
cli = malloc(sizeof(struct client));
cli->name = "far bar"; cli->credit = 6;
hash_table_store(table, cli->name, cli);
cli = hash_table_delete(table, "foo bar"); /* returns the deleted value */
printf("deleting: %i, should be 1\n", cli != NULL);
cli = hash_table_delete(table, "doesn't exist"); /* returns NULL */
printf("deleting: %i, should be 1\n", cli == NULL);
struct client * cl2 = hash_table_get(table, "far bar");
printf("%s has %i money\n", cl2->name, cl2->credit);
/* get all of the keys and list them */
char ** keys = hash_table_get_all_keys(table);
for (i = 0; i < table->population; i++) {
printf("key: %s\n", keys[i]);
}
free(keys);
free(cli);
free(cl2);
hash_table_destroy(table, free_fn);
return 0;
}
void obj_free(obj_t * c)
{
if( !c )
return;
hash_table_delete( c->data );
free(c);
}
void deltadb_delete( struct deltadb *db )
{
// should delete all nvpairs in the table here
if(db->table) hash_table_delete(db->table);
//if(db->logfile) fclose(db->logfile);
free(db);
}
int main(int argc, char* argv[])
{
int i = 0;
int n = 10000;
int ret_data = 0;
HashTable* hash_table = hash_table_create(NULL, NULL, hash_int, 31);
for(i = 0; i < n; i++)
{
assert(hash_table_length(hash_table) == i);
assert(hash_table_insert(hash_table, (void*)i) == RET_OK);
assert(hash_table_length(hash_table) == (i + 1));
assert(hash_table_find(hash_table, cmp_int, (void*)i, (void**)&ret_data) == RET_OK);
assert(ret_data == i);
}
for(i = 0; i < n; i++)
{
assert(hash_table_delete(hash_table, cmp_int, (void*)i) == RET_OK);
assert(hash_table_length(hash_table) == (n - i -1));
assert(hash_table_find(hash_table, cmp_int, (void*)i, (void**)&ret_data) != RET_OK);
}
hash_table_destroy(hash_table);
return 0;
}
void makeflow_wrapper_delete(struct makeflow_wrapper *w)
{
if(w->command)
free(w->command);
list_free(w->input_files);
list_delete(w->input_files);
list_free(w->output_files);
list_delete(w->output_files);
if(w->uses_remote_rename){
uint64_t f;
char *remote;
itable_firstkey(w->remote_names);
while(itable_nextkey(w->remote_names, &f, (void **) &remote)){
free(remote);
}
}
itable_delete(w->remote_names);
hash_table_delete(w->remote_names_inv);
free(w);
}
/* new a HashTable instance */
HashTable* hash_table_new()
{
HashTable* ht = malloc(sizeof(HashTable));
if (NULL == ht) {
hash_table_delete(ht);
return NULL;
}
ht->table = malloc(sizeof(struct kv*) * TABLE_SIZE);
if (NULL == ht->table) {
hash_table_delete(ht);
return NULL;
}
memset(ht->table, 0, sizeof(struct kv*) * TABLE_SIZE);
return ht;
}
// Delete an object from the cache, if it's still there
void cache_delete(cache_t cache, key_type key){
item_t item_ptr = hash_table_find_item(cache->hash_table, key);
if (item_ptr!=NULL){
linked_list_delete(cache->linked_list, item_ptr->node_ptr);
hash_table_delete(cache->hash_table, item_ptr);
}
}
void num_space_collapser_delete (num_space_collapser_t *nsc)
{
hash_table_delete(nsc->hash_table);
pthread_mutex_destroy(&nsc->mutex);
free(nsc);
}
/* Terminate timer sub-sytem */
static void timer_terminate(void)
{
timer_flush_queues();
assert(timer_id_hash);
hash_table_delete(timer_id_hash);
timer_id_hash = NULL;
}
void pop_front() {
if(head) {
struct node *old_head = head;
head = head->next;
hash_table_delete(old_head->hash_table);
free(old_head);
}
}
void hash_cache_delete(struct hash_cache *cache)
{
if(cache) {
if(cache->table)
hash_table_delete(cache->table);
free(cache);
}
}
// when we see }, go back one hash table and delete
void scope_leave(){
// include check for null?
// h = hash_table_lookup(h, "0prev"); // move h back
h = h->prev; // move h back
hash_table_clear(h->next);
hash_table_delete(h->next);
h->next = NULL;
// hash_table_clear(hash_table_lookup(h,"0next")); // clear
// hash_table_delete(hash_table_lookup(h,"0next")); // delete table
}
int
ps_unset_search(ps_decoder_t *ps, const char *name)
{
ps_search_t *search = hash_table_delete(ps->searches, name);
if (!search)
return -1;
if (ps->search == search)
ps->search = NULL;
ps_search_free(search);
return 0;
}
void batch_queue_delete(struct batch_queue *q)
{
if(q) {
char *key;
char *value;
debug(D_BATCH, "deleting queue %p", q);
q->module->free(q);
for (hash_table_firstkey(q->options); hash_table_nextkey(q->options, &key, (void **) &value); free(value))
;
hash_table_delete(q->options);
for (hash_table_firstkey(q->features); hash_table_nextkey(q->features, &key, (void **) &value); free(value))
;
hash_table_delete(q->features);
itable_delete(q->job_table);
itable_delete(q->output_table);
free(q);
}
}
void prog_free(struct prog **pp)
{
if (!pp || !(*pp)) {
return;
}
struct prog *p = *pp;
decl_free(&p->ast);
hash_table_delete(p->strings);
symbol_free(&p->symbols);
free(p);
*pp = 0;
}
void chirp_audit_delete(struct hash_table *table)
{
char *key;
struct chirp_audit *entry;
hash_table_firstkey(table);
while(hash_table_nextkey(table, &key, (void *) &entry)) {
free(hash_table_remove(table, key));
}
hash_table_delete(table);
}
void nvpair_delete(struct nvpair *n)
{
char *key;
void *value;
if(!n) return;
hash_table_firstkey(n->table);
while(hash_table_nextkey(n->table, &key, &value)) {
hash_table_remove(n->table, key);
free(value);
}
hash_table_delete(n->table);
free(n);
}
int main() {
hash_table* h = hash_table_new();
hash_table_register_print(h, int_print);
hash_table_register_copy(h, int_copy);
hash_table_register_delete(h, int_delete);
hash_table_print(h);
char buff[3];
int ints[20];
for(int i=0; i < 20; i++) {
ints[i] = i;
sprintf(buff, "%i", i);
hash_table_add(h, buff, &(ints[i]));
}
hash_table_print(h);
hash_table_get(h, "1");
hash_table_remove(h, "1");
hash_table_print(h);
hash_table_delete(h);
return 0;
}
int partychan_shutdown(void)
{
partychan_t *chan, *next;
partymember_common_t *common, *next_common;
if (partychan_head != NULL) {
for (chan = partychan_head; chan; ) {
next = chan->next;
partychan_delete(chan);
chan = next;
}
partychan_head = NULL;
}
if (common_list_head) {
for (common = common_list_head; common; ) {
next_common = common->next;
free(common->members);
free(common);
common = next_common;
}
common_list_head = NULL;
}
bind_table_del(BT_partypub);
bind_table_del(BT_partypart);
bind_table_del(BT_partyjoin);
/* flush any pending partychan deletes */
garbage_run();
hash_table_delete(cid_ht);
return (0);
}
void deltadb_delete( struct deltadb *db )
{
if(db->table) hash_table_delete(db->table);
free(db);
}
void uhost_cache_destroy()
{
hash_table_walk(uhost_cache_ht, uhost_cache_delete, NULL);
hash_table_delete(uhost_cache_ht);
}
static inline void remove_non_intersect_nodes(hkey_t node, Covg *covgs,
Covg num, HashTable *ht)
{
if(covgs[node] != num)
hash_table_delete(ht, node);
}
// Pseduo Unit Tests
int main(){
hash_table * t = hash_table_new();
// Does the hash function work correctly?
printf("Testing Hash Function:\n");
printf("----------------------\n");
char test [5] = {1,2,3,4,'\0'}; // these two keys collide with the default constants
char test2 [5] = {4,8,5,4,'\0'}; // we will use this property later
printf("hash: %d\n",hash(t,test));
printf("hash: %d\n",hash(t,test2));
printf("%s\n\n",(hash(t,test) == (((1 + 2 + 3 + 4) * MULTIPLY_PRIME ) % 11 )) ? "passed" : "failed");
// Does the set function set and the get function get when there are no collisions?
printf("Testing Set/Get Functions(no collision):\n");
printf("----------------------------------------\n");
int item = 12358;
hash_table_set(t,test,&item);
printf("item = %d\n",(*(int *)hash_table_get(t,test)));
printf("%s\n\n",(hash_table_get(t,test) == &item) ? "passed" : "failed");
// Does the set function set and the get function get when there is a collision?
printf("Testing Set/Get Functions(with collision):\n");
printf("------------------------------------------\n");
int item2 = 55555;
hash_table_set(t,test2,&item2);
printf("%d\n",(*(int *)hash_table_get(t,test))); // get the original item, which will be down the chain
printf("%d\n",(*(int *)hash_table_get(t,test2))); // get the second item, which will be on top
printf("%s\n\n",(hash_table_get(t,test2) == &item2) ? "passed" : "failed");
// Has the hash table been resized?
printf("Testing whether the hash table has been resized:\n");
printf("------------------------------------------\n");
printf("hash: %d\n",hash(t,test));
printf("hash: %d\n",hash(t,test2));
printf("If so, these values should not be equal to the earlier hash values\n");
printf("As a bonus, they will no longer collide, which is why the expansion was necessary in the first place\n\n");
// Does get return NULL if nothing set?
printf("Testing Get Failure:\n");
printf("--------------------\n");
printf("%x\n",hash_table_get(t,"abcdefgh"));
printf("%s\n\n",(hash_table_get(t,"abcdefgh") == NULL) ? "passed" : "failed");
// Some fun stuff
hash_table * h = hash_table_new();
char name[] = "Fake";
hash_table_set(h,"first_name",&name);
char last[] = "Person";
hash_table_set(h,"last_name",&last);
int age = 100;
hash_table_set(h,"age",&age);
printf("My full name is %s %s. I am %d years old\n",(char *)hash_table_get(h,"first_name"), (char *)hash_table_get(h,"last_name"),*((int*)hash_table_get(h,"age")));
hash_table_delete(t);
hash_table_delete(h);
}
