C++ HASH_COUNT函数代码示例

caryll_buffer *caryll_write_gsub_ligature_subtable(otl_subtable *_subtable) {
	caryll_buffer *buf = bufnew();
	subtable_gsub_ligature *subtable = &(_subtable->gsub_ligature);
	ligature_aggerator *h = NULL, *s, *tmp;
	uint16_t nLigatures = subtable->to->numGlyphs;
	for (uint16_t j = 0; j < nLigatures; j++) {
		int sgid = subtable->from[j]->glyphs[0].gid;
		HASH_FIND_INT(h, &sgid, s);
		if (!s) {
			NEW(s);
			s->gid = sgid;
			s->ligid = HASH_COUNT(h);
			HASH_ADD_INT(h, gid, s);
		}
	}
	HASH_SORT(h, by_gid);

	otl_coverage *startCoverage;
	NEW(startCoverage);
	startCoverage->numGlyphs = HASH_COUNT(h);
	NEW_N(startCoverage->glyphs, startCoverage->numGlyphs);

	uint16_t jj = 0;
	foreach_hash(s, h) {
		s->ligid = jj;
		startCoverage->glyphs[jj].gid = s->gid;
		startCoverage->glyphs[jj].name = NULL;
		jj++;
	}

uint32_t moloch_session_monitoring()
{
    uint32_t count = 0;
    int      i;

    for (i = 0; i < config.packetThreads; i++) {
        count += HASH_COUNT(h_, sessions[i][SESSION_TCP]) + HASH_COUNT(h_, sessions[i][SESSION_UDP]) + HASH_COUNT(h_, sessions[i][SESSION_ICMP]);
    }
    return count;
}

bool consolidate_gsub_single(caryll_font *font, table_otl *table, otl_subtable *_subtable,
                             sds lookupName) {
	subtable_gsub_single *subtable = &(_subtable->gsub_single);
	consolidate_coverage(font, subtable->from, lookupName);
	consolidate_coverage(font, subtable->to, lookupName);
	uint16_t len =
	    (subtable->from->numGlyphs < subtable->to->numGlyphs ? subtable->from->numGlyphs
	                                                         : subtable->from->numGlyphs);
	gsub_single_map_hash *h = NULL;
	for (uint16_t k = 0; k < len; k++) {
		if (subtable->from->glyphs[k].name && subtable->to->glyphs[k].name) {
			gsub_single_map_hash *s;
			int fromid = subtable->from->glyphs[k].gid;
			HASH_FIND_INT(h, &fromid, s);
			if (s) {
				fprintf(stderr, "[Consolidate] Double-mapping a glyph in a "
				                "single substitution /%s.\n",
				        subtable->from->glyphs[k].name);
			} else {
				NEW(s);
				s->fromid = subtable->from->glyphs[k].gid;
				s->toid = subtable->to->glyphs[k].gid;
				s->fromname = subtable->from->glyphs[k].name;
				s->toname = subtable->to->glyphs[k].name;
				HASH_ADD_INT(h, fromid, s);
			}
		}
	}
	HASH_SORT(h, by_from_id);
	if (HASH_COUNT(h) != subtable->from->numGlyphs || HASH_COUNT(h) != subtable->to->numGlyphs) {
		fprintf(stderr, "[Consolidate] In single subsitution lookup %s, some "
		                "mappings are ignored.\n",
		        lookupName);
	}
	subtable->from->numGlyphs = HASH_COUNT(h);
	subtable->to->numGlyphs = HASH_COUNT(h);
	FREE(subtable->from->glyphs);
	FREE(subtable->to->glyphs);
	NEW_N(subtable->from->glyphs, subtable->from->numGlyphs);
	NEW_N(subtable->to->glyphs, subtable->to->numGlyphs);
	{
		gsub_single_map_hash *s, *tmp;
		uint16_t j = 0;
		HASH_ITER(hh, h, s, tmp) {
			subtable->from->glyphs[j].gid = s->fromid;
			subtable->from->glyphs[j].name = s->fromname;
			subtable->to->glyphs[j].gid = s->toid;
			subtable->to->glyphs[j].name = s->toname;
			j++;
			HASH_DEL(h, s);
			free(s);
		}
	}

int matchInodefiles(void) {
    fileop_t *f;
    fileop_t *finode;
    char fpath[PATH_MAX];
    struct stat st;
    int64_t inode;

    // first try to match inodefiles to files
    for (f = files; f != NULL; f = (fileop_t*) (f->hh.next)) {
        // get ino of the file
        getAbsolutePath(fpath, config.snapshot, f->relpath);

        if (stat(fpath, &st) != -1) {
            inode = st.st_ino;
        } else {
            // this should not happen: we can't open the file
            errMsg(LOG_WARNING, "Could not stat file %s ", fpath);
        }

        // if this ino is in inodefiles, merge the operations in f and
        // remove the element from inodefiles
        // TODO: what about order?
        HASH_FIND_INT(inodefiles, &inode, finode);
        if (finode != NULL) {
            if (mergeOperations(f, finode) != 0)
                return -1;

            free(finode->operations);
            HASH_DEL(inodefiles, finode);
            free(finode);
        }

        // if there are no entries in inodefiles left, we are done
        if (HASH_COUNT(inodefiles) == 0) // HASH_COUNT is cheap
            return 0;
    }

    // the rest must be matched by file tree walk (nftw)
    int flags = 0;
    flags |= FTW_MOUNT; // stay in the file system
    flags |= FTW_PHYS; // do not dereference symlinks

    if (nftw(config.snapshot, matchInode, 10, flags) == -1) {
        errMsg(LOG_WARNING, "Could not stat file %s ", fpath);
    }

    // if there are still some entries left in inodefiles, we have a problem
    if (HASH_COUNT(inodefiles) == 0)
        return 0;
    else
        return -1;
}

void MAT_PARSER_show(Parser* p) {

  // Local variables
  MAT_Parser* parser = (MAT_Parser*)PARSER_get_data(p);
  int len_bus_list;
  int len_branch_list;
  int len_gen_list;
  int len_cost_list;
  int len_util_list;

  // No parser
  if (!parser)
    return;

  // List lengths
  LIST_len(MAT_Bus,parser->bus_list,next,len_bus_list);
  LIST_len(MAT_Branch,parser->branch_list,next,len_branch_list);
  LIST_len(MAT_Gen,parser->gen_list,next,len_gen_list);
  LIST_len(MAT_Cost,parser->cost_list,next,len_cost_list);
  LIST_len(MAT_Util,parser->util_list,next,len_util_list);

  // Show
  printf("\nParsed Data\n");
  printf("base power : %.2f\n",parser->base_power);
  printf("bus list   : %d\n",len_bus_list);
  printf("bus hash   : %d\n",HASH_COUNT(parser->bus_hash));
  printf("gen list   : %d\n",len_gen_list);
  printf("branch list: %d\n",len_branch_list);
  printf("cost list  : %d\n",len_cost_list);
  printf("util list  : %d\n",len_util_list);
}

int olsr_db_rt_report_so(char** str_out) {
    int report_str_len = 70;
    olsr_db_rt_t* current_entry = rt_set;
    char* output;
    char entry_str[report_str_len  + 1];

    output = malloc(sizeof(char) * report_str_len * (HASH_COUNT(rt_set)) + 1);

    if(output == NULL) {
        return false;
    }

    struct timeval curr_time;

    gettimeofday(&curr_time, NULL);

    // initialize first byte to \0 to mark output as empty
    *output = '\0';

    while(current_entry != NULL) {
        snprintf(entry_str, report_str_len + 1, MAC "\t" MAC "\t" MAC "\t%i\t%5.2f\n",
                 EXPLODE_ARRAY6(current_entry->dest_addr), EXPLODE_ARRAY6(current_entry->next_hop), EXPLODE_ARRAY6(current_entry->precursor_addr), current_entry->hop_count, current_entry->link_quality);
        strcat(output, entry_str);
        current_entry = current_entry->hh.next;
    }

    *str_out = output;
    return true;
}

void unit_end(unit_table_t *unit)
{
		struct link_unit_t *ut;
		char buf[10240];

		if(unit->valid == true || HASH_COUNT(unit->link_unit) > 1) {
				bzero(buf, 10240);
				// emit linked unit lists;
				if(unit->link_unit != NULL) {
						sprintf(buf, "type=unit list=\"");
						for(ut=unit->link_unit; ut != NULL; ut=ut->hh.next) {
								sprintf(buf+strlen(buf), "%d-%d,", ut->id.tid, ut->id.unitid);
						}
						sprintf(buf+strlen(buf), "\" tid=%d \n", unit->tid);
						emit_log(unit, buf);
				}
		}

		delete_unit_hash(unit->link_unit, unit->mem_unit);
		//if(unit->link_unit != NULL) printf("link_unit is not NULL %p\n", unit->link_unit);
		unit->link_unit = NULL;
		unit->mem_unit = NULL;
		unit->valid = false;
		unit->r_addr = 0;
		unit->w_addr = 0;
		unit->unitid++;
}

int draw_particles(void)
{
  static Vec pointv[512];
  static size_t pointc = ARRLEN(pointv, Vec);
  double z = zoom();
  particle_t* p = particles;
  int i = 0;
  size_t count = HASH_COUNT(particles);

  while(i < count) {
    for(; p != NULL && i < pointc; p = p->hh.next, i++) {
      cpVect pos = cpBodyGetPos(p->body);

      if(fabs(pos.x) <= z / 2 && fabs(pos.y) <= z / 2) {
        // rough check if position is inside screen borders
        // TODO: possibly make it separate function
        pointv[i] = cpv2vec(pos);
      }
    }
    if(draw_points(pointv, i % pointc)) {
      return -1;
    }
  }

  return 0;
}

static struct node *try_flat_dump(struct node *tree)
{
    struct node *current;

    current = tree;
    while (current != NULL)
    {
        if (HASH_COUNT(current) == 1)
        {
            printf("%s ", current->word);
            if (current->childs == NULL)
            {
                printf("\n");
                return NULL;
            }
        }
        else
        {
            printf("\n");
            return current;
        }
        current = current->childs;
    }
    printf("\n");
    return current;
}

uint32_t get_num_nodes(Graph *graph){
    if(graph == NULL){
        puts("Error: get_node graph given is null.");
        exit(1);
    }
    return (uint32_t)HASH_COUNT(graph->nodes);
}

void print_bot_list(void)
{
    struct bot *b, *tmp;
    if (HASH_COUNT(bots) == 0)
        printf("No bots!\n");
    HASH_ITER(hh, bots, b, tmp) {
        printf("%s: %s\n", b->name, b->desc);
    }

int
main (int argc, char *argv[])
{
  char in[10];
  int id = 1;
  User *s;
  unsigned num_users;

  while (1)
    {
      printf ("1. add user\n");
      printf ("2. find user\n");
      printf ("3. delete user\n");
      printf ("4. delete all users\n");
      printf ("5. sort items by name\n");
      printf ("6. sort items by id\n");
      printf ("7. print users\n");
      printf ("8. count users\n");
      gets (in);
      switch (atoi (in))
	{
	case 1:
	  printf ("name?\n");
	  add_user (id++, gets (in));
	  break;
	case 2:
	  printf ("id?\n");
	  s = find_user (atoi (gets (in)));
	  printf ("user: %s\n", s ? s->name : "unknown");
	  break;
	case 3:
	  printf ("id?\n");
	  s = find_user (atoi (gets (in)));
	  if (s)
	    delete_user (s);
	  else
	    printf ("id unknown\n");
	  break;
	case 4:
	  delete_all ();
	  break;
	case 5:
	  sort_by_name ();
	  break;
	case 6:
	  sort_by_id ();
	  break;
	case 7:
	  print_users ();
	  break;
	case 8:
	  num_users = HASH_COUNT (users);
	  printf ("there are %u users\n", num_users);
	  break;
	}
    }
}

const float overlap_coefficient_similarity_custom(const char *str1, const char *str2, std_tokenizer_t *tokenizer) {

	hash_token_t *h1 = tokenizer->tok_uq_hash_func(str1, tokenizer->delimiters);
	hash_token_t *h2 = tokenizer->tok_uq_hash_func(str2, tokenizer->delimiters);

	hash_token_t *all = merge_tokens(h1, h2);

	unsigned int ch1 = HASH_COUNT(h1), ch2 = HASH_COUNT(h2), ch3 = HASH_COUNT(all);
	unsigned int ct = (ch1 + ch2) - ch3;

	const float ret = ((float) ct) / ((float) MIN((float)ch1, (float)ch2));

	hash_token_free(h1);
	hash_token_free(h2);
	hash_token_free(all);

	return ret;

}

const float cosine_similarity_custom(const char *str1, const char *str2, std_tokenizer_t *tokenizer) {

	hash_token_t *h1 = tokenizer->tok_uq_hash_func(str1, tokenizer->delimiters);
	hash_token_t *h2 = tokenizer->tok_uq_hash_func(str2, tokenizer->delimiters);

	hash_token_t *all = merge_tokens(h1, h2);

	unsigned int ch1 = HASH_COUNT(h1), ch2 = HASH_COUNT(h2), ch3 = HASH_COUNT(all);
	unsigned int ct = (ch1 + ch2) - ch3;

	const float ret = ((float)ct / (powf((float)ch1, (float)0.5) * powf((float)ch2, (float)0.5)));

	hash_token_free(h1);
	hash_token_free(h2);
	hash_token_free(all);

	return ret;

}

int pm_next_loop(void (*child_changed_status)(process_struct *ps))
{
  sigsetjmp(saved_jump_buf, 1); pm_can_jump = 0;

  while (!terminated && (HASH_COUNT(exited_children) > 0 || signaled)) pm_check_children(child_changed_status, terminated);
  pm_check_pending_processes(); // Check for pending signals arrived while we were in the signal handler

  pm_can_jump = 1;
  if (terminated) return -1;
  else return 0;
}