void
id_table_show_all_items()
{
struct scopes *tmp;
tmp = scopes;
printf("getting info about id_items...\n");
while (tmp != NULL) {
id_item_t *item;
struct hash_table_iter *iter;
void *key;
iter = hash_table_iterate_init(tmp->scope);
while (hash_table_iterate(iter, &key, (void **)&item) == TRUE) {
printf("name = %s, type = %d\n",
item->name, item->type);
}
hash_table_iterate_deinit(&iter);
tmp = tmp->prev;
}
printf("finishing...\n");
}
void
print_broken_links (void)
{
hash_table_iterator iter;
int num_elems;
if (!nonexisting_urls_set)
{
logprintf (LOG_NOTQUIET, _("Found no broken links.\n\n"));
return;
}
num_elems = hash_table_count (nonexisting_urls_set);
assert (num_elems > 0);
logprintf (LOG_NOTQUIET, ngettext("Found %d broken link.\n\n",
"Found %d broken links.\n\n", num_elems),
num_elems);
for (hash_table_iterate (nonexisting_urls_set, &iter);
hash_table_iter_next (&iter); )
{
/* Struct url_list *list; */
const char *url = (const char *) iter.key;
logprintf (LOG_NOTQUIET, _("%s\n"), url);
}
logputs (LOG_NOTQUIET, "\n");
}
const char *
password_scheme_detect(const char *plain_password, const char *crypted_password,
const struct password_generate_params *params)
{
struct hash_iterate_context *ctx;
const char *key;
const struct password_scheme *scheme;
const unsigned char *raw_password;
size_t raw_password_size;
const char *error;
ctx = hash_table_iterate_init(password_schemes);
while (hash_table_iterate(ctx, password_schemes, &key, &scheme)) {
if (password_decode(crypted_password, scheme->name,
&raw_password, &raw_password_size,
&error) <= 0)
continue;
if (password_verify(plain_password, params, scheme->name,
raw_password, raw_password_size,
&error) > 0)
break;
key = NULL;
}
hash_table_iterate_deinit(&ctx);
return key;
}
void auth_request_handler_abort_requests(struct auth_request_handler *handler)
{
struct hash_iterate_context *iter;
void *key;
struct auth_request *auth_request;
iter = hash_table_iterate_init(handler->requests);
while (hash_table_iterate(iter, handler->requests, &key, &auth_request)) {
switch (auth_request->state) {
case AUTH_REQUEST_STATE_NEW:
case AUTH_REQUEST_STATE_MECH_CONTINUE:
case AUTH_REQUEST_STATE_FINISHED:
auth_request_unref(&auth_request);
hash_table_remove(handler->requests, key);
break;
case AUTH_REQUEST_STATE_PASSDB:
case AUTH_REQUEST_STATE_USERDB:
/* can't abort a pending passdb/userdb lookup */
break;
case AUTH_REQUEST_STATE_MAX:
i_unreached();
}
}
hash_table_iterate_deinit(&iter);
}
void db_passwd_file_unref(struct db_passwd_file **_db)
{
struct db_passwd_file *db = *_db;
struct db_passwd_file **p;
struct hash_iterate_context *iter;
char *path;
struct passwd_file *file;
*_db = NULL;
i_assert(db->refcount >= 0);
if (--db->refcount > 0)
return;
for (p = &passwd_files; *p != NULL; p = &(*p)->next) {
if (*p == db) {
*p = db->next;
break;
}
}
if (db->default_file != NULL)
passwd_file_free(db->default_file);
else {
iter = hash_table_iterate_init(db->files);
while (hash_table_iterate(iter, db->files, &path, &file))
passwd_file_free(file);
hash_table_iterate_deinit(&iter);
hash_table_destroy(&db->files);
}
i_free(db->path);
i_free(db);
}
void test_hash_iterator_key_pair()
{
HashTable *hash_table;
HashTableIterator iterator;
HashTablePair pair;
int *key = 0;
int *val = 0;
hash_table = hash_table_new(int_hash, int_equal);
/* Add some values */
hash_table_insert(hash_table, &value1, &value1);
hash_table_insert(hash_table, &value2, &value2);
hash_table_iterate(hash_table, &iterator);
while (hash_table_iter_has_more(&iterator)) {
/* Retrieve both Key and Value */
pair = hash_table_iter_next(&iterator);
key = (int*) pair.key;
val = (int*) pair.value;
assert(*key == *val);
}
hash_table_free(hash_table);
}
void test_hash_table_iterating_remove(void)
{
HashTable *hash_table;
HashTableIterator iterator;
char buf[10];
char *val;
HashTablePair pair;
int count;
unsigned int removed;
int i;
hash_table = generate_hash_table();
/* Iterate over all values in the table */
count = 0;
removed = 0;
hash_table_iterate(hash_table, &iterator);
while (hash_table_iter_has_more(&iterator)) {
/* Read the next value */
pair = hash_table_iter_next(&iterator);
val = pair.value;
/* Remove every hundredth entry */
if ((atoi(val) % 100) == 0) {
hash_table_remove(hash_table, val);
++removed;
}
++count;
}
/* Check counts */
assert(removed == 100);
assert(count == NUM_TEST_VALUES);
assert(hash_table_num_entries(hash_table)
== NUM_TEST_VALUES - removed);
/* Check all entries divisible by 100 were really removed */
for (i=0; i<NUM_TEST_VALUES; ++i) {
sprintf(buf, "%i", i);
if (i % 100 == 0) {
assert(hash_table_lookup(hash_table, buf) == NULL);
} else {
assert(hash_table_lookup(hash_table, buf) != NULL);
}
}
hash_table_free(hash_table);
}
void
print_hash (struct hash_table *sht)
{
hash_table_iterator iter;
int count = 0;
for (hash_table_iterate (sht, &iter); hash_table_iter_next (&iter);
++count)
printf ("%s: %s\n", iter.key, iter.value);
assert (count == sht->count);
}
static void replicator_abort_all_requests(struct replicator_connection *conn)
{
struct hash_iterate_context *iter;
void *key, *value;
iter = hash_table_iterate_init(conn->requests);
while (hash_table_iterate(iter, conn->requests, &key, &value))
conn->callback(FALSE, value);
hash_table_iterate_deinit(&iter);
hash_table_clear(conn->requests, TRUE);
}
static void print_gfa_syntax(UnitigPrinter *p)
{
fputs("H VN:Z:1.0\n", p->fout);
unitig_graph_create(&p->ugraph, p->nthreads, p->visited,
print_unitig_gfa, p);
p->num_unitigs = p->ugraph.num_unitigs;
// Now print edges
hash_table_iterate(&p->db_graph->ht, p->nthreads, print_edges, p);
}
static void stats_drop_stale(struct top_context *ctx)
{
struct hash_iterate_context *iter;
char *id;
struct top_line *line;
iter = hash_table_iterate_init(ctx->sessions);
while (hash_table_iterate(iter, ctx->sessions, &id, &line)) {
if (line->flip != ctx->flip)
hash_table_remove(ctx->sessions, id);
}
hash_table_iterate_deinit(&iter);
}
void test_hash_table_iterating(void)
{
HashTable *hash_table;
HashTableIterator iterator;
int count;
hash_table = generate_hash_table();
/* Iterate over all values in the table */
count = 0;
hash_table_iterate(hash_table, &iterator);
while (hash_table_iter_has_more(&iterator)) {
hash_table_iter_next(&iterator);
++count;
}
assert(count == NUM_TEST_VALUES);
/* Test iter_next after iteration has completed. */
assert(hash_table_iter_next(&iterator) == HASH_TABLE_NULL);
hash_table_free(hash_table);
/* Test iterating over an empty table */
hash_table = hash_table_new(int_hash, int_equal);
hash_table_iterate(hash_table, &iterator);
assert(hash_table_iter_has_more(&iterator) == 0);
hash_table_free(hash_table);
}
static void
downloaded_files_free (void)
{
if (downloaded_files_hash)
{
hash_table_iterator iter;
for (hash_table_iterate (downloaded_files_hash, &iter);
hash_table_iter_next (&iter);
)
xfree (iter.key);
hash_table_destroy (downloaded_files_hash);
downloaded_files_hash = NULL;
}
}
void
id_table_free(struct hash_table *table)
{
void *key, *data;
struct hash_table_iter *iter;
iter = hash_table_iterate_init(table);
while (hash_table_iterate(iter, &key, &data) != FALSE)
id_table_destroy_cb((id_table_item_t*)data);
hash_table_iterate_deinit(&iter);
hash_table_destroy(&table);
}
void
__la_dump_table(HashTable *table, __value_handler_t func)
{
HashTableIterator itr;
LOGV("%p (hash table: dump table)", table);
if (func == NULL) {
LOGW("%p (dump hash table: given no handler)", table);
return;
}
/* Print each value in detail */
hash_table_iterate(table, &itr);
while (hash_table_iter_has_more(&itr)) {
(*func)(hash_table_iter_next(&itr));
}
}
void str_table_deinit(struct str_table **_table)
{
struct str_table *table = *_table;
struct hash_iterate_context *iter;
char *key;
void *value;
*_table = NULL;
iter = hash_table_iterate_init(table->hash);
while (hash_table_iterate(iter, table->hash, &key, &value))
i_free(key);
hash_table_iterate_deinit(&iter);
hash_table_destroy(&table->hash);
i_free(table);
}
static void print_dot_syntax(UnitigPrinter *p, bool dot_use_points)
{
fputs("digraph G {\n", p->fout);
fputs(" edge [dir=both arrowhead=none arrowtail=none color=\"blue\"]\n", p->fout);
fprintf(p->fout, " node [%s, fontname=courier, fontsize=9]\n",
dot_use_points ? "shape=point, label=none" : "shape=none");
unitig_graph_create(&p->ugraph, p->nthreads, p->visited,
print_unitig_dot, p);
p->num_unitigs = p->ugraph.num_unitigs;
// Now print edges
fputc('\n', p->fout);
hash_table_iterate(&p->db_graph->ht, p->nthreads, print_edges, p);
fputs("}\n", p->fout);
}
void
res_cleanup (void)
{
if (registered_specs)
{
hash_table_iterator iter;
for (hash_table_iterate (registered_specs, &iter);
hash_table_iter_next (&iter);
)
{
xfree (iter.key);
free_specs (iter.value);
}
hash_table_destroy (registered_specs);
registered_specs = NULL;
}
}
static void
auth_server_connection_remove_requests(struct auth_server_connection *conn)
{
static const char *const temp_failure_args[] = { "temp", NULL };
struct hash_iterate_context *iter;
void *key, *value;
iter = hash_table_iterate_init(conn->requests);
while (hash_table_iterate(iter, &key, &value)) {
struct auth_client_request *request = value;
auth_client_request_server_input(request,
AUTH_REQUEST_STATUS_FAIL,
temp_failure_args);
}
hash_table_iterate_deinit(&iter);
hash_table_clear(conn->requests, FALSE);
}
void
hash_ctx_table_destroy()
{
void *key, *data;
struct hash_table_iter *iter;
iter = hash_table_iterate_init(ctx_table->hash);
while (hash_table_iterate(iter, &key, &data) != FALSE)
hash_ctx_destroy_cb((struct hash_ctx *)data);
hash_table_iterate_deinit(&iter);
hash_table_destroy(&ctx_table->hash);
ufree(ctx_table);
ctx_table = NULL;
}
static void checkpassword_deinit(struct userdb_module *_module)
{
struct checkpassword_userdb_module *module =
(struct checkpassword_userdb_module *)_module;
struct hash_iterate_context *iter;
void *key, *value;
iter = hash_table_iterate_init(module->clients);
while (hash_table_iterate(iter, &key, &value)) {
checkpassword_request_finish(value,
USERDB_RESULT_INTERNAL_FAILURE);
}
hash_table_iterate_deinit(&iter);
hash_table_destroy(&module->clients);
if (checkpassword_userdb_children != NULL)
child_wait_free(&checkpassword_userdb_children);
}
void login_proxy_state_deinit(struct login_proxy_state **_state)
{
struct login_proxy_state *state = *_state;
struct hash_iterate_context *iter;
struct login_proxy_record *rec;
*_state = NULL;
/* sanity check: */
iter = hash_table_iterate_init(state->hash);
while (hash_table_iterate(iter, state->hash, &rec, &rec))
i_assert(rec->num_waiting_connections == 0);
hash_table_iterate_deinit(&iter);
timeout_remove(&state->to_reopen);
login_proxy_state_close(state);
hash_table_destroy(&state->hash);
pool_unref(&state->pool);
i_free(state);
}
void
host_cleanup (void)
{
if (host_name_addresses_map)
{
hash_table_iterator iter;
for (hash_table_iterate (host_name_addresses_map, &iter);
hash_table_iter_next (&iter);
)
{
char *host = iter.key;
struct address_list *al = iter.value;
xfree (host);
assert (al->refcount == 1);
address_list_delete (al);
}
hash_table_destroy (host_name_addresses_map);
host_name_addresses_map = NULL;
}
}
static void
auth_server_connection_remove_requests(struct auth_server_connection *conn,
const char *disconnect_reason)
{
static const char *const temp_failure_args[] = { "temp", NULL };
struct hash_iterate_context *iter;
void *key;
struct auth_client_request *request;
time_t created, oldest = 0;
unsigned int request_count = 0;
if (hash_table_count(conn->requests) == 0)
return;
iter = hash_table_iterate_init(conn->requests);
while (hash_table_iterate(iter, conn->requests, &key, &request)) {
if (!auth_client_request_is_aborted(request)) {
request_count++;
created = auth_client_request_get_create_time(request);
if (oldest > created || oldest == 0)
oldest = created;
}
auth_client_request_server_input(request,
AUTH_REQUEST_STATUS_INTERNAL_FAIL,
temp_failure_args);
}
hash_table_iterate_deinit(&iter);
hash_table_clear(conn->requests, FALSE);
if (request_count > 0) {
i_warning("Auth connection closed with %u pending requests "
"(max %u secs, pid=%s, %s)", request_count,
(unsigned int)(ioloop_time - oldest),
my_pid, disconnect_reason);
}
}
int main(int arg, char *argv) {
char * str1 = "HTTP/1.1 index.html";
char * str2 = "HTTP/1.0 aaaaa.html";
char * str3 = "HTTP/1.0 bbbbb.html";
char * str4 = "HTTP/1.1 ccccc.html";
char * str5 = "HTTP/0.9 ddddd.html";
char * str6 = "HTTP/1.1 fffff.html";
char * str7 = "HTTP/0.9 eeeee.html";
LST_String * nbytes1 = lst_string_new(str1, 1, strlen(str1));
LST_String * nbytes2 = lst_string_new(str2, 1, strlen(str2));
LST_String * nbytes3 = lst_string_new(str3, 1, strlen(str3));
LST_String * nbytes4 = lst_string_new(str4, 1, strlen(str4));
LST_String * nbytes5 = lst_string_new(str5, 1, strlen(str5));
LST_String * nbytes6 = lst_string_new(str6, 1, strlen(str6));
LST_String * nbytes7 = lst_string_new(str7, 1, strlen(str7));
LST_StringSet * set = lst_stringset_new();
lst_stringset_add(set, nbytes1);
lst_stringset_add(set, nbytes2);
lst_stringset_add(set, nbytes3);
lst_stringset_add(set, nbytes4);
lst_stringset_add(set, nbytes5);
lst_stringset_add(set, nbytes6);
lst_stringset_add(set, nbytes7);
int first_bytes = 8;
int last_bytes = 10;
int num_bytes = 19;
int gamma_merge = 2;
product_distribution_t * pd = product_distribution_new(set, first_bytes, last_bytes, num_bytes);
/* print pd */
HashTableIterator iterator1;
hash_table_iterate(pd->offset_distribution, &iterator1);
while (hash_table_iter_has_more(&iterator1)){
HashTablePair pair1 = hash_table_iter_next(&iterator1);
int *key1 = (int *) pair1.key;
byte_distribution_t *value1 = (byte_distribution_t *) pair1.value;
HashTableIterator iterator2;
hash_table_iterate(value1->value_frequency, &iterator2);
if (hash_table_num_entries(value1->value_frequency) > gamma_merge) {
continue;
}
printf("offset %d : ", *key1);
while(hash_table_iter_has_more(&iterator2)){
HashTablePair pair2 = hash_table_iter_next(&iterator2);
char *key2 = (char *) pair2.key;
int *value2 = (int *) pair2.value;
//printf("<%c, %d>\t", key2[0], *value2);
if (0 == *key1) {
printf("^%s\t", key2);
} else if (num_bytes - 1 == *key1) {
printf("%s$\t", key2);
} else {
printf("%s\t", key2);
}
}
printf("\n");
}
product_distribution_free(pd);
return 0;
}
static void iterate_all_classes(void *(f)(void*, void*)) {
hash_table_iterate(class_key_table, f);
}
