自学教程：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);    }

intmain (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;}

int transfer(char *host, char *port) {    int sfd; // server socket    fileop_t *f; // contains all operations for a file    sfd = inetConnect(host, port, SOCK_STREAM);    if (sfd == -1) {        errnoMsg(LOG_ERR, "Unable to connect to the server.");        return -1;    }    // initiate sync (sync-id, resource, number of files)    errMsg(LOG_INFO, "Number of files: %d", HASH_COUNT(files));    switch (initiateSync(sfd, HASH_COUNT(files))) {        case -1: // error            return -1;        case -2: // there's nothing to synchronize            return 0;        default:            break;    }    // iterate over files in correct order    HASH_SORT(files, sortByOrder);    for (f = files; f != NULL; f = (fileop_t*) (f->hh.next)) {        if (transferFile(sfd, f) == -1) {            errMsg(LOG_ERR, "Transfer of file %s has failed.",                    f->relpath);            return -1;        }    }    // wait for ACK    SyncFinish *conf;    conf = (SyncFinish *) recvMessage(sfd, SyncFinishType, NULL);    if (conf == NULL) {        errMsg(LOG_ERR, "Could not get transfer confirmation.");        return -1;    }    return 0;}

/*** WARNING: This function actually deletes a mobile from the world.** @param char_data *ch The person doing the deleting.* @param mob_vnum vnum The vnum to delete.*/void olc_delete_mobile(char_data *ch, mob_vnum vnum) {		void extract_pending_chars();	void remove_mobile_from_table(char_data *mob);		char_data *proto, *mob_iter, *next_mob;	descriptor_data *desc;	struct global_data *glb, *next_glb;	room_template *rmt, *next_rmt;	sector_data *sect, *next_sect;	crop_data *crop, *next_crop;	bld_data *bld, *next_bld;	bool found;		if (!(proto = mob_proto(vnum))) {		msg_to_char(ch, "There is no such mobile %d./r/n", vnum);		return;	}		if (HASH_COUNT(mobile_table) <= 1) {		msg_to_char(ch, "You can't delete the last mob./r/n");		return;	}			// remove mobs from the list: DO THIS FIRST	for (mob_iter = character_list; mob_iter; mob_iter = next_mob) {		next_mob = mob_iter->next;				if (IS_NPC(mob_iter)) {			if (GET_MOB_VNUM(mob_iter) == vnum) {				// this is the removed mob				act("$n has been deleted.", FALSE, mob_iter, NULL, NULL, TO_ROOM);				extract_char(mob_iter);			}		}	}	// their data will already be free, so we need to clear them out now	extract_pending_chars();		// pull from hash ONLY after removing from the world	remove_mobile_from_table(proto);	// save mob index and mob file now so there's no trouble later	save_index(DB_BOOT_MOB);	save_library_file_for_vnum(DB_BOOT_MOB, vnum);		// update buildings	HASH_ITER(hh, building_table, bld, next_bld) {		found = delete_mob_from_spawn_list(&GET_BLD_SPAWNS(bld), vnum);		found |= delete_from_interaction_list(&GET_BLD_INTERACTIONS(bld), TYPE_MOB, vnum);		if (found) {			save_library_file_for_vnum(DB_BOOT_BLD, GET_BLD_VNUM(bld));		}	}

dessert_per_result_t send_tc(void *data, struct timeval *scheduled, struct timeval *interval) {	pthread_rwlock_wrlock(&pp_rwlock);	if (HASH_COUNT(dir_neighbors_head) == 0) {		return 0;	}	dessert_msg_t *tc;	dessert_msg_new(&tc);	tc->ttl = TTL_MAX;	tc->u8 = ++tc_seq_nr;	// delete old entries from NH list	node_neighbors_t *dir_neigh = dir_neighbors_head;	while (dir_neigh) {		if (dir_neigh->entry_age-- == 0) {			node_neighbors_t* el_to_delete = dir_neigh;			HASH_DEL(dir_neighbors_head, el_to_delete);			free(el_to_delete);		}		dir_neigh = dir_neigh->hh.next;	}	// add TC extension	dessert_ext_t *ext;	uint8_t ext_size = 1 + ((sizeof(node_neighbors_t)- sizeof(dir_neighbors_head->hh)) * HASH_COUNT(dir_neighbors_head));	dessert_msg_addext(tc, &ext, LSR_EXT_TC, ext_size);	void* tc_ext = ext->data;	memcpy(tc_ext, &(ext_size), 1);	tc_ext++;	// copy NH list into extension	dir_neigh = dir_neighbors_head;	while (dir_neigh) {		memcpy(tc_ext, dir_neigh->addr, ETH_ALEN);		tc_ext += ETH_ALEN;		memcpy(tc_ext, &(dir_neigh->entry_age), 1);		tc_ext++;		memcpy(tc_ext, &(dir_neigh->weight), 1);		tc_ext++;		dir_neigh = dir_neigh->hh.next;	}	// add l2.5 header	dessert_msg_addext(tc, &ext, DESSERT_EXT_ETH, ETHER_HDR_LEN);	struct ether_header* l25h = (struct ether_header*) ext->data;	memcpy(l25h->ether_shost, dessert_l25_defsrc, ETH_ALEN);	memcpy(l25h->ether_dhost, ether_broadcast, ETH_ALEN);	dessert_meshsend_fast(tc, NULL);	dessert_msg_destroy(tc);	pthread_rwlock_unlock(&pp_rwlock);	return 0;}

void moloch_session_add_tag_type(MolochSession_t *session, int tagtype, const char *tag) {    moloch_session_incr_outstanding(session);    moloch_db_get_tag(session, tagtype, tag, moloch_session_get_tag_cb);    if (session->stopSaving == 0 && HASH_COUNT(s_, config.dontSaveTags)) {        MolochString_t *tstring;        HASH_FIND(s_, config.dontSaveTags, tag, tstring);        if (tstring) {            session->stopSaving = (long)tstring->uw;        }    }}

void remove_tex(unsigned int idmin, unsigned int idmax){    unsigned int n = 0;    texlist *current, *tmp;    GLuint *t = (GLuint*)malloc(HASH_COUNT(list) * sizeof(GLuint));    HASH_ITER(hh, list, current, tmp)    {        if (current->id >= idmin && current->id < idmax)        {            t[n++] = current->tex_id;            HASH_DEL(list, current);            free(current);        }    }    glDeleteTextures(n, t);    free(t);#ifdef LOG_TEXTUREMEM    if (log_cb)        log_cb(RETRO_LOG_DEBUG, "RMVTEX nbtex is now %d (%06x - %06x)/n", HASH_COUNT(list), idmin, idmax);#endif}

FCITX_EXPORT_APIchar* fcitx_utils_string_hash_set_join(FcitxStringHashSet* sset, char delim){    if (!sset)        return NULL;    if (HASH_COUNT(sset) == 0)        return strdup("");    size_t len = 0;    HASH_FOREACH(string, sset, FcitxStringHashSet) {        len += strlen(string->name) + 1;    }

void moloch_session_add_tag(MolochSession_t *session, const char *tag) {    moloch_session_incr_outstanding(session);    moloch_db_get_tag(session, config.tagsField, tag, moloch_session_get_tag_cb);    moloch_field_string_add(config.tagsStringField, session, tag, -1, TRUE);    if (session->stopSaving == 0 && HASH_COUNT(s_, config.dontSaveTags)) {        MolochString_t *tstring;        HASH_FIND(s_, config.dontSaveTags, tag, tstring);        if (tstring) {            session->stopSaving = (int)(long)tstring->uw;        }    }}

void query(struct trie *lexicon, FILE *index, struct mapping **map, char *term) {  struct token *results = malloc(sizeof(struct token));  struct token *s, *tmp;  uint32_t ptr = lexicon_find(lexicon, term);  fseek(index, ptr, SEEK_SET);  index_find(index, ptr, &results);  printf("%s/n", term);  printf("%u/n", HASH_COUNT(results));  HASH_ITER(hh, results, s, tmp) {    printf("%s, %u/n", unmap_document(map, s->id), s->count);  }

void wise_print_stats(){    int i;    for (i = 0; i < 4; i++) {        LOG("%8s lookups:%7d cache:%7d requests:%7d inprogress:%7d fail:%7d hash:%7d list:%7d",            wiseStrings[i],            stats[i][0],            stats[i][1],            stats[i][2],            stats[i][3],            stats[i][4],            HASH_COUNT(wih_, itemHash[i]),            DLL_COUNT(wil_, &itemList[i]));    }}

int main(int argc,char *argv[]) {    int i;    example_user_t *user, *users=NULL;    /* create elements */    for(i=0;i<10;i++) {        if ( (user = (example_user_t*)malloc(sizeof(example_user_t))) == NULL) exit(-1);        user->id = i;        user->cookie = i*i;        HASH_ADD_INT(users,id,user);    }        printf("hash contains %d items/n", HASH_COUNT(users));   return 0;}

static void consolidateMarkArray(caryll_font *font, table_otl *table, sds lookupName,                                 otl_coverage *marks, otl_mark_array *markArray,                                 uint16_t classCount) {	mark_hash *hm = NULL;	for (uint16_t k = 0; k < marks->numGlyphs; k++) {		if (marks->glyphs[k].name) {			mark_hash *s = NULL;			HASH_FIND_INT(hm, &(marks->glyphs[k].gid), s);			if (!s && markArray->records[k].anchor.present &&			    markArray->records[k].markClass < classCount) {				NEW(s);				s->gid = marks->glyphs[k].gid;				s->name = marks->glyphs[k].name;				s->markrec = markArray->records[k];				HASH_ADD_INT(hm, gid, s);			} else {				fprintf(stderr, "[Consolidate] Ignored invalid or "				                "double-mapping mark definition for /%s in "				                "lookup %s./n",				        marks->glyphs[k].name, lookupName);			}		}	}	HASH_SORT(hm, mark_by_gid);	marks->numGlyphs = HASH_COUNT(hm);	markArray->markCount = HASH_COUNT(hm);	mark_hash *s, *tmp;	uint16_t k = 0;	HASH_ITER(hh, hm, s, tmp) {		marks->glyphs[k].gid = s->gid;		marks->glyphs[k].name = s->name;		markArray->records[k] = s->markrec;		k++;		HASH_DEL(hm, s);		free(s);	}

/* Client Mode */ void *connectToPeer(void *temp) {    struct sockaddr_in remote_addr;    int new_fd;    char *buffer = malloc(MAXBUFFSIZE), *buf1 = malloc(MAXBUFFSIZE), *buf2 = malloc(MAXBUFFSIZE);    struct peerList *peer = (struct peerList *)temp;    if (!add_peer(peer) && (peer->net_fd)) return NULL;  /* Create TCP Socket */    if ((new_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {        perror("could not create socket");        exit(1);    }    memset((char *)&remote_addr, 0, sizeof(remote_addr));    remote_addr.sin_family = AF_INET;    remote_addr.sin_port = htons(peer->listenPort);    inet_aton((char *)inet_ntoa(peer->listenIP), &remote_addr.sin_addr);    sprintf(buf1, "%s %d", inet_ntoa(local_info->listenIP), local_info->listenPort);    sprintf(buf2, "%s %d", inet_ntoa(peer->listenIP), peer->listenPort);    if (debug) printf("COMPARING %s --- %s/n", buf1, buf2);    if (!(strcmp(buf1, buf2))) return NULL;    puts("Client Mode:");    printf("NEW PEER: Connecting to %s:%d/n", inet_ntoa(remote_addr.sin_addr), ntohs(remote_addr.sin_port));  /* Connect to server */    if ((connect(new_fd, (struct sockaddr *)&remote_addr, sizeof(remote_addr))) < 0) {        printf("NEW PEER: Peer Removed %s:%d: Failed to connect/n", inet_ntoa(peer->listenIP), peer->listenPort);        if (debug) printf("errno: %d/n", errno);        remove_peer(peer);    } else {    /* Create single link state packet */        strcpy(buffer, peer->tapDevice);        peer->net_fd = new_fd;        printf("NEW PEER: Connected to server %s:%d - %d/n", inet_ntoa(peer->listenIP), peer->listenPort, peer->net_fd);        // sprintf(buffer, "0xabcd 2048%s blah blah", send_peerList(peer));        // send(peer->net_fd, buffer, strlen(buffer), 0);        send_singleLinkStatePacket(peer);        lsPacket->neighbors = HASH_COUNT(peers);        if (debug) print_linkStatePacket();    }    if (debug) puts("Leaving connectToPeer");    return NULL; }

Graph *load_graph(Database *db){    if(db == NULL){        puts("Error: load graph failed. Db is null.");        exit(1);    }    Graph *graph = _new_graph();    graph->db = db;    graph->nodes = NULL;    int i;    uint64_t count = 0;    uint64_t total = 0;    NodeData *node_data;    ArcData *arc_data;    Node *node;    Arc *arc;    ArcNode *arcnode;    puts("Loading graph into memory...");    fseek(db->fp, 0L, SEEK_SET);    while(!feof(db->fp)){        node_data = malloc(sizeof(NodeData));        count = read_database(node_data, sizeof(NodeData), db);        total += count;        if(count == 0){            continue;        }        HASH_FIND_INT(graph->nodes, &(node_data->id), node);        if(node != NULL){            printf("Error: node %i already in tree./n", node_data->id);            exit(1);        }        node = _new_node(node_data, graph);        HASH_ADD_INT(graph->nodes, data->id, node);        if(node_data->num_arcnodes > 0){            for(i=0; i<node_data->num_arcnodes; i++){                arc_data = malloc(sizeof(ArcData));                total += read_database((void *)arc_data, sizeof(ArcData), db);                arc = _new_arc(arc_data);                arcnode = _new_arcnode(arc);                node->arcnodes[i] = arcnode;            }        }    }    printf("Loaded %i nodes./n", (int)HASH_COUNT(graph->nodes));    printf("Read %llu bytes from database./n", (long long unsigned int)total);    return graph;}

/*** WARNING: This function actually deletes a crop.** @param char_data *ch The person doing the deleting.* @param crop_vnum vnum The vnum to delete.*/void olc_delete_crop(char_data *ch, crop_vnum vnum) {	void remove_crop_from_table(crop_data *crop);	extern const sector_vnum climate_default_sector[NUM_CLIMATES];		obj_data *obj, *next_obj;	descriptor_data *desc;	struct map_data *map;	room_data *room;	crop_data *crop;	sector_data *base = NULL;	int count;		if (!(crop = crop_proto(vnum))) {		msg_to_char(ch, "There is no such crop %d./r/n", vnum);		return;	}		if (HASH_COUNT(crop_table) <= 1) {		msg_to_char(ch, "You can't delete the last crop./r/n");		return;	}	// remove it from the hash table first	remove_crop_from_table(crop);		// save base sect for later	base = sector_proto(climate_default_sector[GET_CROP_CLIMATE(crop)]);	// save index and crop file now	save_index(DB_BOOT_CROP);	save_library_file_for_vnum(DB_BOOT_CROP, vnum);		// update world	count = 0;	LL_FOREACH(land_map, map) {		room = real_real_room(map->vnum);				if (map->crop_type == crop || (room && ROOM_CROP(room) == crop)) {			if (!room) {				room = real_room(map->vnum);			}			set_crop_type(room, NULL);	// remove it explicitly			change_terrain(room, GET_SECT_VNUM(base));			++count;		}	}