int
printNodes(any_t extraData, any_t item)
{
struct NodeItem* nodeItem = (struct NodeItem*)malloc(sizeof(struct NodeItem));
ContainerNode *node = (ContainerNode*)item;
nodeItem->nodeName = node->name;
hashmap_iterate(node->networkInformation, fillAddress, &nodeItem->nodeIp);
struct SuperData* data = (struct SuperData*)extraData;
nodeItem->requiredDeployUnit = data->requiredDU;
nodeItem->requiresDeployUnit = 0;
// print components and their type
printf("Node %s\n", node->name);
hashmap_iterate(node->components, printComponents, nodeItem);
if (nodeItem->requiresDeployUnit) {
// add element to list
list_t l = *data->l;
list_add(l, nodeItem);
}
return MAP_OK;
}
int
fillAddress(any_t extra, any_t item)
{
NetworkInfo *nInfo = (NetworkInfo*)item;
hashmap_iterate(nInfo->values, fillLocalAddress, extra);
return MAP_OK;
}
int
symcopy(struct sym *from, struct sym *to, struct allocator *al)
{
iter_t iter;
void *key, *data;
to->flags = from->flags & 0xFFFF;
to->idl_type = dupstr(from->idl_type, al);
to->ndr_type = dupstr(from->ndr_type, al);
to->interface = from->interface;
hashmap_iterate(&from->attrs, &iter);
while ((key = hashmap_next(&from->attrs, &iter))) {
if ((data = hashmap_get(&from->attrs, key)) == NULL ||
hashmap_put(&to->attrs, key, data) == -1) {
AMSG("");
return -1;
}
}
linkedlist_iterate(&from->mems, &iter);
while ((data = linkedlist_next(&from->mems, &iter))) {
if (linkedlist_add(&to->mems, data) == -1) {
AMSG("");
return -1;
}
}
to->name = dupstr(from->name, al);
to->value = dupstr(from->value, al);
to->ptr = from->ptr;
to->align = from->align;
return 0;
}
void
filter_nodes(ContainerRoot* model, int children_count, char* childrenIP[], const char* deployUnitType, list_t* r)
{
struct SuperData superData = { .l = r, .requiredDU=deployUnitType };
// print address of each node
hashmap_iterate(model->nodes, printNodes , &superData);
// filter out elements if they are not in the list of children results
list_t nodes = *r;
LIST(tmp);
list_init(tmp);
for (int i = 0 ; i < children_count ; i++) {
struct NodeItem * found = NULL;
for (struct NodeItem* p =list_head(nodes); p != NULL ; p = list_item_next(p)) {
if (compare_ips(childrenIP[i], p->nodeIp)) {
found = p;
}
}
if (found) {
list_remove(nodes, found);
list_push(tmp, found);
}
}
// now just empty the previous list
while (list_length(nodes) > 0) {
void* item = list_pop(nodes);
free(item);
}
// now add elements to the empty list
while (list_length(tmp) > 0) {
void* item = list_pop(tmp);
list_push(nodes, item);
}
}
// Grabs a string from a buffered queue and counts it
void *reduce(void* rArgs){
struct reducerArgs *args = (struct reducerArgs*) rArgs;
int mappersFinished = 0;
int error;
int count;
map_t map = *(args->map);
struct buffered_queue *conn = (args->conns)[args->reducerId]; // Corresponding buffered queue
while (1){ // continually attempt to read until signal received all mappers done
char *str = (char*)buffered_queue_pop(conn); // Word to reduce from buffered queue
if (str == NULL) {
// Received mappers finished signal
break;
} else {
printf("Reducer %d is counting \"%s\"\n", args->reducerId, str);
error = hashmap_get(map, str, &count);
if (error == MAP_OK){
hashmap_put(map, str, count + 1);
printf("Reducer %d counted \"%s\" %d times\n", args->reducerId, str, count + 1);
} else {
hashmap_put(map, str, 1);
printf("Reducer %d counted \"%s\" 1 time\n",args->reducerId, str);
}
}
}
hashmap_iterate(map, print_result);
return NULL;
}
void LXMapDestroy(LXMapPtr r)
{
if ( !r) return;
map_t map = (map_t)r;
hashmap_iterate(map, destroyMapValue, NULL);
hashmap_free(map);
}
void help_action(vector_t *arguments) {
// basically I did a little hack where the hashmap
// is the first argument on here
map_t *commands = get_vector_item(arguments, 0);
printf("%s\n", help_template);
hashmap_iterate(commands, print_command, NULL);
printf("\n");
}
// Publishes the given message to all peers subscribing to the message topic.
// Returns -1 on failure, 0 on success.
int publish(struct sn_client* self,uint32_t channel_id, msg_t* msg)
{
map_t* subscribers;
if (hashmap_get(self->thread->pubsub, channel_id, (void**) &subscribers) == MAP_OK)
{
hashmap_iterate(subscribers, send_msg ,msg);
}else
return -1;
return 0;
}
_public_ const char* sd_bus_track_next(sd_bus_track *track) {
const char *n = NULL;
if (!track)
return NULL;
if (track->modified)
return NULL;
hashmap_iterate(track->names, &track->iterator, (const void**) &n);
return n;
}
_public_ const char* sd_bus_track_first(sd_bus_track *track) {
const char *n = NULL;
if (!track)
return NULL;
track->modified = false;
track->iterator = ITERATOR_FIRST;
hashmap_iterate(track->names, &track->iterator, (const void**) &n);
return n;
}
void fetch_action(vector_t *arguments) {
load_t *project_config_loader = load_project_config();
if (!project_config_loader) {
printf("error: are you sure the current directory contains an Ark project?\n");
return;
}
table_t *deps = get_table(project_config_loader, "dependencies");
if (!deps) {
printf("error: [dependencies] was not found in the config file!\n");
return;
}
hashmap_iterate(deps->nodes, dependencies_iterate, false);
}
// Exception callback
// VM Death callback
static void JNICALL
callbackVMDeath(jvmtiEnv * const jvmti_env, JNIEnv * const jni_env)
{
(void) jvmti_env;
(void) jni_env;
#ifdef DETAILED_RESULTS
enter_critical_section(jvmti);
hashmap_iterate(map, &print_method_info, NULL);
exit_critical_section(jvmti);
#endif
}
void freeStuff()
{
iter_t iter; char* varname;
hashmap_iterate(&vars, &iter);
while ((varname = (char*) hashmap_next(&vars, &iter)))
free(varname);
hashmap_clear(&vars, NULL, NULL, NULL);
Expr el;
linkedlist_iterate(&exprPool, &iter);
while ((el = linkedlist_next(&exprPool, &iter))){
vc_deleteExpr(el);
}
linkedlist_clear(&exprPool, NULL, NULL);
}
int
print_values(struct hashmap *words)
{
iter_t iter;
char *word;
int val;
hashmap_iterate(words, &iter);
while ((word = hashmap_next(words, &iter))) {
val = (int)hashmap_get(words, word);
fprintf(stderr, "%d %s\n", val, word);
}
return 0;
}
int
sprint_sym(char *buf, struct sym *sym, int indent, int spacer)
{
char *bp = buf, *key;
int i, fill = spacer * 2;
iter_t iter;
bp += sprintf(bp, "%3d ", sym->id);
for (i = 0; i < 15; i++) {
if ((sym->flags & (1 << i))) {
*bp++ = FLAGS[i];
}
}
FILL(buf, bp, 9 + indent);
bp += sprintf(bp, "%s", NN(sym->idl_type));
FILL(buf, bp, fill); fill += spacer;
bp += sprintf(bp, "%d ", sym->ptr);
bp += sprintf(bp, "%c ", PTR_TYPES[sym->ptr_type]);
bp += sprintf(bp, "%s", NN(sym->name));
FILL(buf, bp, fill); fill += spacer;
bp += sprintf(bp, "%s", NN(sym->out_type));
FILL(buf, bp, fill); fill += spacer / 2;
bp += sprintf(bp, "%s", NN(sym->ndr_type));
FILL(buf, bp, fill); fill += spacer;
bp += sprintf(bp, "%3d %3d %3d ", sym->ndr_size, sym->align, sym->offset);
bp += sprintf(bp, "(%s) %d ", NN(sym->interface), IS_IMPORTED(sym));
i = 0;
hashmap_iterate(&sym->attrs, &iter);
while ((key = hashmap_next(&sym->attrs, &iter))) {
const char *val = hashmap_get(&sym->attrs, key);
if (i++) {
*bp++ = ',';
}
if (key == val) {
bp += sprintf(bp, "%s", key);
} else {
bp += sprintf(bp, "%s=%s", key, val);
}
}
return bp - buf;
}
void dowse_stop() {
/*
* The "start" function is called once, when the program
* is exiting normally. It might be used to clean up state,
* free memory, etc.
*/
if(fileout) fclose(fileout);
if(listdir) {
hashmap_iterate(domainlist, free_domainlist_f, NULL);
hashmap_free(domainlist);
}
// free the map
hashmap_free(visited);
redisFree(redis);
}
void minpf_cleanup_plugin_manager(void)
{
if (managerInstance) {
size_t i = 0;
for (i = 0; i < managerInstance->num_exit_functions; ++i)
managerInstance->exit_functions[i]();
for (i = 0; i < managerInstance->num_libraries; ++i) {
if (managerInstance->dynamic_libraries[i])
free(managerInstance->dynamic_libraries[i]);
}
hashmap_iterate(managerInstance->plugins, minpf_free_hash_value, NULL);
hashmap_free(managerInstance->plugins);
free(managerInstance);
}
managerInstance = NULL;
}
int main(char * argv,int argc)
{
#if defined(DEBUG)
atexit(report_mem_leak);
#endif
_fileNameNode *pFiles = getFileNameByDir(INFILEPATH);
_fileNameNode *pCur = pFiles;
map_t mymap;
mymap = hashmap_new(2000000ul);
while(pCur) {
/*
* 对每个文件操作
*/
//doFilter(mymap,pCur->fileName);
doWork(mymap,pCur->fileName);
pCur=pCur->next;
}
hashmap_iterate(mymap,freeVale,(void *)NULL);
hashmap_free(mymap);
freefileNameList(pFiles);
pFiles = pCur = NULL;
return 0;
}
int main(int argc, char **argv)
{
hashmap_t * map;
if (argc != 2) {
fprintf(stderr, "Usage: %s string\n",argv[0]);
exit(EXIT_FAILURE);
}
map = (hashmap_t *)malloc(sizeof(hashmap_t));
hashmap_init(map);
decode(argv[1], map);
hashmap_iterate(map,print_hashmap);
hashmap_delete_all(map);
hashmap_free(map);
free(map);
exit(0);
}
void *set_iterate(Set *s, Iterator *i) {
return hashmap_iterate(MAKE_HASHMAP(s), i, NULL);
}
int
HashmapExercise(int verbose, struct cfg *cfg, char *args[])
{
struct hashmap *h;
int rate = 0, i, n = 0;
int count = atoi(args[0]);
int interval = atoi(args[1]);
iter_t riter;
iter_t iter;
char *str;
struct allocator *al = NULL;
char *mem;
clock_t t0;
int chkpnt = 0;
struct allocator *hal;
if ((mem = malloc(0xFFFFFF)) == NULL ||
(al = suba_init(mem, 0xFFFFFF, 1, 0)) == NULL ||
(h = hashmap_new(hash_str, cmp_str, NULL, al)) == NULL) {
AMSG("");
return -1;
}
hal = AL(h);
/*
if ((h = hashmap_new(hash_str, cmp_str, NULL, al)) == NULL) {
AMSG("");
return -1;
}
*/
srand(0);
t0 = clock();
if (verbose)
fprintf(stderr, "\n time count size mem\n");
hashmap_iterate(h, &iter);
rate_iterate(&riter);
for (i = 0; i < count; i++) {
if ((i % interval) == 0) {
if (verbose)
fprintf(stderr, "%2d %8ld %8d %8d %8d\n", chkpnt++, (clock() - t0) / 1000, hashmap_size(h), table_sizes[h->table_size_index], hal->alloc_total - hal->free_total);
rate = rate_next(&riter);
}
if (rand() % 10 < rate) {
str = allocator_alloc(NULL, 8, 0);
sprintf(str, "%07d", n++);
if (hashmap_put(h, str, str) == -1) {
AMSG("");
return -1;
} else {
/*fputc('+', stderr);
*/
tcase_printf(verbose, "put %s %d\r", str, hashmap_size(h));
}
} else {
if (hashmap_is_empty(h)) {
/*fputc('0', stderr);
*/
tcase_printf(verbose, "hashmap empty\r");
} else {
str = hashmap_next(h, &iter);
if (str) {
char *data;
tcase_printf(verbose, "get %s %d\r", str, hashmap_size(h));
if (hashmap_remove(h, (void **)&str, (void **)&data) == -1) {
AMSG("");
return -1;
}
/*fputc('-', stderr);
*/
tcase_printf(verbose, "rem %s %d\r", str, hashmap_size(h));
allocator_free(NULL, str);
} else {
/*fputc('x', stderr);
*/
tcase_printf(verbose, "nothing left to iterate over\r");
hashmap_iterate(h, &iter);
}
}
}
}
if (verbose)
fprintf(stderr, "%2d %8ld %8d %8d %8d\n", chkpnt++, (clock() - t0) / 1000, hashmap_size(h), table_sizes[h->table_size_index], hal->alloc_total - hal->free_total);
hashmap_del(h, allocator_free, NULL, NULL);
/*
free(mem);
*/
if (verbose)
fprintf(stderr, "bytes outstanding from allocator: %d\n", hal->alloc_total - hal->free_total);
cfg = NULL;
return 0;
}
int main(int argc, char* argv[])
{
hmap_t map;
userdata *dat;
userelem *el;
int ret, i, j;
/* 创建 hashmap */
map = hashmap_create();
/* 插入 hashmap 元素 */
for (i=0; i<100; i++) {
dat = (userdata *)malloc(sizeof(userdata));
/* 创建子 hashmap */
dat->map = hashmap_create();
/* 插入子 hashmap 元素 */
for (j=0; j<10; j++) {
el = (userelem *)malloc(sizeof(userelem));
sprintf(el->key, "%d", j);
el->value = (char*) malloc(30);
sprintf(el->value, "%d", j+1000);
ret = hashmap_put(dat->map, el->key, el);
assert(ret==HMAP_S_OK);
}
sprintf(dat->name, "%d", i);
ret = hashmap_put(map, dat->name, dat);
assert(ret==HMAP_S_OK);
}
printf("hashmap_size: %d\n", hashmap_size(map));
/* 删除指定元素: key="10" */
ret = hashmap_remove(map, "10", &dat);
assert(ret==HMAP_S_OK);
printf("hashmap_remove: name=%s. size=%d\n", dat->name, hashmap_size(map));
hashmap_iterate(dat->map, iter_elem, 0);
free_data(dat, 0);
/* 删除指定元素: key="11" */
ret = hashmap_remove(map, "11", &dat);
assert(ret==HMAP_S_OK);
printf("hashmap_remove: name=%s. size=%d\n", dat->name, hashmap_size(map));
hashmap_iterate(dat->map, iter_elem, 0);
free_data(dat, 0);
/* 查询元素: key="99" */
ret = hashmap_get(map, "99", &dat);
assert(ret==HMAP_S_OK);
printf("hashmap_get: name=%s. size=%d\n", dat->name, hashmap_size(map));
hashmap_iterate(dat->map, iter_elem, 0);
/* 删除整个 map */
hashmap_destroy(map, free_data, 0);
_CrtDumpMemoryLeaks();
return 0;
}
int
symresolve(struct idl *idl, struct sym *sym)
{
struct sym *s;
char *key;
iter_t iter;
int align;
size_t size;
s = symlook(idl, sym->idl_type);
if (s) {
/* merge stuff */
sym->flags |= s->flags & 0xFFFF;
sym->ndr_type = s->ndr_type;
if (sym->ptr && (!IS_PRIMATIVE(sym) || hashmap_get(&sym->attrs, "string"))) {
sym->ndr_size = 4;
} else {
sym->ndr_size = s->ndr_size;
}
sym->align = sym->ptr ? 4 : sym->ndr_size;
/* inherit attributes */
hashmap_iterate(&s->attrs, &iter);
while ((key = hashmap_next(&s->attrs, &iter))) {
/* Only add attributes that the symbol does not have already
*/
if (hashmap_get(&sym->attrs, key) == NULL) {
char *data;
data = hashmap_get(&s->attrs, key);
hashmap_put(&sym->attrs, key, data);
}
}
if (sym->out_type == NULL) {
if (s->out_type) {
sym->out_type = s->out_type;
} else if (IS_TYPEDEFD(sym)) {
sym->out_type = sym->idl_type = sym->name;
} else if (strncmp(sym->idl_type, "struct ", 7) == 0 ||
strncmp(sym->idl_type, "union ", 6) == 0) {
char buf[255];
if (*sym->idl_type == 's') {
sprintf(buf, "struct_%s", sym->idl_type + 7);
} else {
sprintf(buf, "union_%s", sym->idl_type + 7);
}
sym->out_type = dupstr(buf, idl->al);
}
if ((strcmp(idl->type, "java") == 0 || strcmp(idl->type, "jcifs") == 0) && IS_IMPORTED(sym)) {
char buf[255];
sprintf(buf, "%s.%s", sym->interface, sym->out_type);
sym->out_type = dupstr(buf, idl->al);
}
}
}
align = 0;
size = 0;
linkedlist_iterate(&sym->mems, &iter);
while ((s = linkedlist_next(&sym->mems, &iter))) {
size_t msiz, mali, m;
symresolve(idl, s);
if (s->align > align) {
align = s->align;
}
if (s->ptr) {
msiz = mali = 4;
} else {
msiz = s->ndr_size;
mali = s->align;
}
m = mali - 1;
size = (size + m) & ~m; /* align the type */
s->offset = size;
if (IS_ENUM(sym)) {
size = msiz; /* size only size of member not sum of mems */
} else if (IS_UNION(sym)) {
/* size is largest of mems (not really used for any logic so far) */
if (msiz > size) {
size = msiz;
}
} else {
size += msiz; /* and size of type */
}
}
if (align) {
sym->align = align;
}
if (size) {
sym->ndr_size = size;
}
/* check array conformance */
hashmap_iterate(&sym->attrs, &iter);
while ((key = hashmap_next(&sym->attrs, &iter))) {
if (!IS_FIXED(sym) && (strcmp(key, "size_is") == 0 || strcmp(key, "max_is") == 0)) {
sym->flags |= FLAGS_CONFORMANT;
break;
}
}
if (IS_PRIMATIVE(sym)) {
if (!IS_OPERATION(sym)) {
sym->interface = NULL;
}
sym->flags &= ~FLAGS_IMPORTED;
}
return 0;
}
int main() {
char *o, *p, *line;
queue *q;
double *r, *s;
double *pi = malloc(sizeof(double));
double *e = malloc(sizeof(double));
double *ans = malloc(sizeof(double));
*pi = 3.1415926535;
*e = 2.7182818285;
*ans = 0;
hm = hashmap_new();
hashmap_put(hm, "pi", pi);
hashmap_put(hm, "e", e);
hashmap_put(hm, "ans", ans);
/* read input using linenoise */
while((line = linenoise("> ")) != NULL) {
/* add the line to history */
linenoiseHistoryAdd(line);
/* check if there is an equals sign */
for (p = line; (*p != '\0') && (*p != '='); p++);
if (*p == '\0') p = line;
else { /* equals sign present */
/* check for spaces */
for (o = line; (*o != ' ') && (*o != '='); o++);
*o = '\0';
p++; /* skip equals sign when parsing equation */
}
q = syard_run(p);
if (q == NULL) continue;
#ifdef __DEBUG
queue_foreach(q, testfunc, NULL);
printf("\n");
#endif
r = rpn_calc(q, variable_resolver, func_wl);
if (r == NULL) continue;
printf("= %g\n", *r);
/* store ans */
*ans = *r;
if (p != line) {
/* equals sign present */
if ((s = hashmap_get(hm, line)) != NULL) {
/* existing value, just overwrite it */
*s = *r;
free(r);
} else {
/* new value */
hashmap_put(hm, line, r);
}
} else {
/* no equals sign, so we're done with the number now */
free(r);
}
/* free storage and stuff */
linenoiseFree(line);
}
hashmap_iterate(hm, hm_cleaner, NULL);
hashmap_destroy(hm);
return 0;
}
