int regusers_save(const struct bot *bot, const char *file) { FILE *f; if ((f = fopen(file, "w"))) { struct hashtable_iterator iter; void *k; void *v; hashtable_iterator_init(&iter, bot->regusers); while (hashtable_iterator_next(&iter, &k, &v)) { char flgstr[33] = {0}; struct reguser *usr = v; _reguser_flgtostr(usr->flags, flgstr, sizeof(flgstr)); fprintf(f, "%s:%s:%s\n", usr->name, flgstr, usr->mask); } } else { log_perror("fopen()", LOG_ERROR); return 1; } fclose(f); return 0; }
struct reguser *reguser_find(const struct bot *bot, const char *pre) { struct hashtable_iterator iter; void *k; void *v; hashtable_iterator_init(&iter, bot->regusers); while (hashtable_iterator_next(&iter, &k, &v)) if (regex_match(((struct reguser *)v)->mask, pre)) return v; return NULL; }
amibis_iterator_t amibis_iterator_next(amibis_iterator_t itr) { switch (itr->type) { case HASHTABLE_ITERATOR: itr->ptr = hashtable_iterator_next(itr->ptr); break; } if (itr->ptr == NULL) { free(itr); itr = NULL; } return itr; }
void print_bitcoin_ticker(struct json_value *ticker) { struct hashtable *rootobj = json_get_object(ticker); struct hashtable_iterator iter; hashtable_iterator_init(&iter, rootobj); const char *key; struct json_value *val; while (hashtable_iterator_next(&iter, (void**)&key, (void **)&val)) { printf(" %s (%s) / BTC: %.2lf\n", key, JSON_GET(JSON_OBJECT_LOOKUP(val, "symbol"), const char*), JSON_GET(JSON_OBJECT_LOOKUP(val, "15m"), double)); } }
/* main */ int main(int argc, char *argv[]) { struct hashtable * hashtable; struct hashtable_iterator iter; struct hashtable_entry entry; void * valuepointer; int valueint, seed = 0, stringcount = 0, stringlength, key_bytes = 0, value_bytes = 0, entrynumber, collisions = 0, delete_count; char * source, * destination, * value; diag("02b-hashtable"); plan(4); hashtable = hashtable_new(); srand(seed); /* TODO: get a portable seed from for example current time */ while (stringcount<STRINGCOUNT) { /* nondeterministic because of collisions */ char * key = random_string(MAXKEYLENGTH); /* create a value consisting of the key reversed followed by */ /* the original key, for example 'abc' -> 'cbaabc' */ stringlength = strlen(key); value = (char *) malloc(2 * stringlength + 1); destination=value+stringlength; * destination -- = '\0'; for (source=key; stringlength-->0; ) { * destination -- = * source ++; } strcat( value, key ); /* test whether the key is already in the hashtable */ if ( hashtable_fetch(hashtable, key, strlen(key), & valuepointer, & valueint) ) { /* it is already in the hash table, free these values */ free(key); free(value); ++ collisions; } else { /* it is not already in the hash table, add it */ hashtable_store(hashtable, key, strlen(key), value, strlen(value)); key_bytes += strlen(key); value_bytes += strlen(value); ++ stringcount; } } is_ii( stringcount, STRINGCOUNT, "created a hash with 5000 entries"); srand(seed); /* Test 2 - iterate the entries and delete them */ hashtable_iterator_init(hashtable, & iter); delete_count = 0; while (hashtable_iterator_next(& iter, & entry)) { key_bytes -= strlen(entry.keypointer); value_bytes -= strlen(entry.valuepointer); /* fprintf(stderr,"iter A '%s' => '%s'\n", (char *) entry.keypointer, (char *) entry.valuepointer); */ free(entry.keypointer); free(entry.valuepointer); ++delete_count; } is_ii(delete_count, stringcount, "iterate 5000 entries and delete"); /* Test 3 - verify total number of bytes in keys */ is_ii(key_bytes, 0, "all bytes in keys reclaimed"); /* Test 4 - verify total number of bytes in keys */ is_ii(value_bytes, 0, "all bytes in values reclaimed"); /* Cannot test this internally, but Valgrind should show that no */ /* bytes remain allocated on the heap. */ hashtable_free(hashtable); return 0; }
void script_closure_pred_equivalence_classes() { closure_operator *clop = clop_alloc_straightforward(); pred *ess_preds; size_t ess_sz; get_essential_predicates(2, &ess_preds, &ess_sz); /** We use a hash table to store a mapping between clones (equivalence * classes) and predicates that generate those clones (closure-equivalent * predicates). */ hashtable *ht = hashtable_alloc(512, clone_hash, (int (*)(const void *, const void *))clone_eq); /* construct the closure of all essential predicates */ for(pred *p = ess_preds; p < ess_preds + ess_sz; ++p) { clone *closure = aligned_alloc(32, sizeof(clone)); assert(closure); closure_one_pred(clop, p, closure); /* lookup equivalence class corresponding to `p` */ clone *equiv_preds = hashtable_lookup(ht, closure); if(equiv_preds == NULL) { equiv_preds = malloc(sizeof(clone)); assert(equiv_preds); clone_init(equiv_preds); hashtable_insert(ht, closure, equiv_preds); } else { free(closure); } clone_insert_pred(equiv_preds, p); } /* print the equivalence classes */ int idx = 1; for(hashtable_iterator it = hashtable_iterator_begin(ht); !hashtable_iterator_end(&it); hashtable_iterator_next(&it)) { hash_elem *elem = hashtable_iterator_deref(&it); printf("====== class %u ====================================\n", idx); for(clone_iterator itc = clone_iterator_begin((clone *)elem->value); !clone_iterator_end((clone *)elem->value, &itc); clone_iterator_next(&itc)) { pred p = clone_iterator_deref(&itc); printf("%s\t%s\n", pred_print_fingerprint(&p), pred_print_extensional_ex(&p)); } printf("\n"); free(elem->key); free(elem->value); ++idx; } hashtable_free(ht); free(ess_preds); clop_free(clop); }