/** * @brief Store an entire hashmap. * @param d Disk to store \p map on. * @param key Key to store \p map under. * @param map Hashmap to store. * @return An error code. */ int disk_store_hm(struct disk *d, char *key, struct hashmap *map) { struct hashmap_node *node; char *data, *msg, *query; struct string *s; struct hashmap_iterator *it; int rc; it = hashmap_new_iterator(map); for(node = hashmap_iterator_next(it); node; node = hashmap_iterator_next(it)) { s = container_of(node, struct string, node); string_get(s, &data); xfiredb_sprintf(&query, DISK_STORE_QUERY, key, node->key, "hashmap", data); rc = sqlite3_exec(d->handle, query, &dummy_hook, d, &msg); if(rc != SQLITE_OK) fprintf(stderr, "Disk store failed: %s\n", msg); sqlite3_free(msg); xfiredb_free(query); xfiredb_free(data); } return -XFIREDB_OK; }
void TestHashmaplinked_IterateHandlesCollisions( CuTest * tc ) { hashmap_t *hm, *hm2; hashmap_iterator_t iter; void *key; hm = hashmap_new(__uint_hash, __uint_compare, 4); hm2 = hashmap_new(__uint_hash, __uint_compare, 4); hashmap_put(hm, (void *) 1, (void *) 92); hashmap_put(hm, (void *) 5, (void *) 91); hashmap_put(hm, (void *) 9, (void *) 90); hashmap_put(hm2, (void *) 1, (void *) 92); hashmap_put(hm2, (void *) 5, (void *) 91); hashmap_put(hm2, (void *) 9, (void *) 90); hashmap_iterator(hm, &iter); /* remove every key we iterate on */ while ((key = hashmap_iterator_next(hm, &iter))) { CuAssertTrue(tc, NULL != hashmap_remove(hm2, key)); } /* check if the hashmap is empty */ CuAssertTrue(tc, 0 == hashmap_count(hm2)); hashmap_freeall(hm); }
/** * Compute the range's length if it was a milestone * @param df the dest file whose queue is to be scanned * @param tlen the length of the underlying text * @return true if it worked else 0 */ static int compute_range_lengths( dest_file *df, int tlen ) { int res = 1; hashmap *map = hashmap_create(); if ( map != NULL ) { range *r = df->queue; while ( r != NULL ) { range *s = hashmap_get( map, range_get_name(r) ); if ( s != NULL ) range_set_len( s, range_get_start(r)-range_get_start(s) ); hashmap_put( map, range_get_name(r), r ); r = range_get_next( r ); } hashmap_iterator *iter = hashmap_iterator_create( map ); if ( iter != NULL ) { while ( hashmap_iterator_has_next(iter) ) { char *key = hashmap_iterator_next(iter); range *t = hashmap_get( map, key ); range_set_len( t, tlen-range_get_start(t) ); } hashmap_iterator_dispose( iter ); } else res = 0; hashmap_dispose( map ); } else res = 0; return res; }
static void __peer_release(peer_t* p) { hashmap_iterator_t iter; piece_t* pce; for (hashmap_iterator(p->have_pieces, &iter); (pce = hashmap_iterator_next(p->have_pieces, &iter));) { hashmap_remove(p->have_pieces, p); } }
int bt_rarestfirst_selector_poll_best_piece( void *r, const void *peer ) { rarestfirst_t *rf = r; heap_t *hp; peer_t *pr; void *p; int piece_idx; hashmap_iterator_t iter; piece_t *pce; if (!(pr = hashmap_get(rf->peers, peer))) { return -1; } /* if we have no pieces, fail */ if (0 == hashmap_count(pr->have_pieces)) { return -1; } hp = heap_new(__cmp_piece, rf); /* add to priority queue */ for (hashmap_iterator(rf->pieces, &iter); (p = hashmap_iterator_next(rf->pieces, &iter));) { /* only add if peer has it */ if (hashmap_get(pr->have_pieces, p)) { pce = hashmap_get(rf->pieces, p); heap_offer(hp, pce); } } /* queue best from priority queue */ if ((pce = heap_poll(hp))) { piece_idx = pce->idx; hashmap_remove(rf->pieces, (void *) (long) pce->idx); hashmap_put(rf->pieces_polled, (void *) (long) pce->idx, pce); } else { piece_idx = -1; } heap_free(hp); return piece_idx; }
void TestHashmaplinked_IterateAndRemoveDoesntBreakIteration( CuTest * tc ) { hashmap_t *hm; hashmap_t *hm2; hashmap_iterator_t iter; void *key; hm = hashmap_new(__uint_hash, __uint_compare, 11); hm2 = hashmap_new(__uint_hash, __uint_compare, 11); hashmap_put(hm, (void *) 50, (void *) 92); hashmap_put(hm, (void *) 49, (void *) 91); hashmap_put(hm, (void *) 48, (void *) 90); hashmap_put(hm, (void *) 47, (void *) 89); hashmap_put(hm, (void *) 46, (void *) 88); hashmap_put(hm, (void *) 45, (void *) 87); /* the following 3 collide: */ hashmap_put(hm, (void *) 1, (void *) 92); hashmap_put(hm, (void *) 5, (void *) 91); hashmap_put(hm, (void *) 9, (void *) 90); hashmap_put(hm2, (void *) 50, (void *) 92); hashmap_put(hm2, (void *) 49, (void *) 91); hashmap_put(hm2, (void *) 48, (void *) 90); hashmap_put(hm2, (void *) 47, (void *) 89); hashmap_put(hm2, (void *) 46, (void *) 88); hashmap_put(hm2, (void *) 45, (void *) 87); /* the following 3 collide: */ hashmap_put(hm2, (void *) 1, (void *) 92); hashmap_put(hm2, (void *) 5, (void *) 91); hashmap_put(hm2, (void *) 9, (void *) 90); hashmap_iterator(hm, &iter); /* remove every key we iterate on */ while ((key = hashmap_iterator_next(hm, &iter))) { CuAssertTrue(tc, NULL != hashmap_remove(hm2, key)); hashmap_remove(hm,key); } /* check if the hashmap is empty */ CuAssertTrue(tc, 0 == hashmap_count(hm2)); hashmap_freeall(hm); hashmap_freeall(hm2); }
/** * @return peer that corresponds to conn_ctx, otherwise NULL */ void *bt_peermanager_conn_ctx_to_peer(void * pm, void* conn_ctx) { bt_peermanager_t *me = pm; hashmap_iterator_t iter; /* find peerconn that has this conn_ctx */ for (hashmap_iterator(me->peers,&iter); hashmap_iterator_has_next(me->peers,&iter);) { bt_peer_t* peer; peer = hashmap_iterator_next(me->peers,&iter); if (peer->conn_ctx == conn_ctx) return peer; } return NULL; }
void* bt_peermanager_get_peer_from_pc(void* pm, const void* pc) { bt_peermanager_t *me = pm; hashmap_iterator_t iter; /* find peerconn that has this ip and port */ for (hashmap_iterator(me->peers,&iter); hashmap_iterator_has_next(me->peers,&iter);) { bt_peer_t* p = hashmap_iterator_next(me->peers,&iter); if (p->pc == pc) { return p; } } return NULL; }
void bt_peermanager_forall( void* pm, void* caller, void* udata, void (*run)(void* caller, void* peer, void* udata)) { bt_peermanager_t *me = pm; hashmap_iterator_t iter; for (hashmap_iterator(me->peers,&iter); hashmap_iterator_has_next(me->peers,&iter);) { bt_peer_t* peer; peer = hashmap_iterator_next(me->peers,&iter); run(caller,peer,udata); } }
/** * @return 1 if the peer is within the manager */ int bt_peermanager_contains(void *pm, const char *ip, const int port) { bt_peermanager_t *me = pm; hashmap_iterator_t iter; /* find peerconn that has this ip and port */ for (hashmap_iterator(me->peers,&iter); hashmap_iterator_has_next(me->peers,&iter);) { bt_peer_t* peer; peer = hashmap_iterator_next(me->peers,&iter); if (!strcmp(peer->ip, ip) && peer->port == port) { return 1; } } return 0; }
void bt_rarestfirst_selector_free( void *r ) { rarestfirst_t *rf = r; hashmap_iterator_t iter; peer_t* p; for (hashmap_iterator(rf->pieces, &iter); (p = hashmap_iterator_next(rf->pieces, &iter));) { hashmap_remove(rf->pieces, p); free(p); } hashmap_free(rf->peers); hashmap_free(rf->pieces); hashmap_free(rf->pieces_polled); free(rf); }
/** * Print out details of any unfreed blocks or report that all blocks were freed */ void memory_print() { if ( allocations != NULL ) { int unfreed = 0; hashmap_iterator *iter = hashmap_iterator_create( allocations ); while ( hashmap_iterator_has_next(iter) ) { UChar *key = hashmap_iterator_next( iter ); UChar *value = hashmap_get( allocations, key ); debug_report("unfreed block %s at %s \n", key, value ); unfreed++; } if ( unfreed == 0 ) debug_report("all blocks were freed\n"); hashmap_dispose( allocations ); free( strings ); strings = NULL; } }
iterator_t *hashmap_iterator_filter(hashmap_t * map, char *keyStartsWith) { iterator_t *it = (iterator_t *)malloc(sizeof(iterator_t)); int first_bucket_idx = 0; it->map = map; it->cur_bucket_idx = first_bucket_idx; it->current = NULL; it->filter = keyStartsWith; it = it_nxt(it); if(it == NULL) return NULL; if(!startsWith(it->filter, hashmap_iterator_key(it))) it = hashmap_iterator_next(it); return it; }
void* hashmap_value_iterator_next(id self) { hashmap_entry ent = (hashmap_entry)hashmap_iterator_next(self); return ent->value; }
void* hashmap_key_iterator_next(id self) { hashmap_entry ent = (hashmap_entry)hashmap_iterator_next(self); return ent->key; }