自学教程：C++ HASH_FIND_INT函数代码示例

inline js_type_class_t *js_get_type_from_native(T* native_obj) {    js_type_class_t *typeProxy;    long typeId = cocos2d::getHashCodeByString(typeid(*native_obj).name());    HASH_FIND_INT(_js_global_type_ht, &typeId, typeProxy);    if (!typeProxy) {        cocos2d::TypeInfo *typeInfo = dynamic_cast<cocos2d::TypeInfo *>(native_obj);        if (typeInfo) {            typeId = typeInfo->getClassTypeInfo();        } else {            typeId = cocos2d::getHashCodeByString(typeid(T).name());        }        HASH_FIND_INT(_js_global_type_ht, &typeId, typeProxy);    }    return typeProxy;}

page_node *add_page(stored_object *object, uint32_t page_id){    page_node *curr,*page;    HASH_FIND_INT(global_page_table,&page_id,page);    if(page)    {        printf("ERROR[add_page] Object %lu already contains page %d/n",page->object_id,page_id);        return NULL;    }    object->size += PAGE_SIZE;    if(object->pages == NULL)    {        page = allocate_new_page(object->id,page_id);        HASH_ADD_INT(global_page_table, page_id, page);         object->pages = page;        return object->pages;    }    for(curr=page=object->pages; page && page->page_id != page_id; curr=page,page=page->next)        ;    if(page)    {        printf("ERROR[add_page] Object %lu already contains page %d/n",page->object_id,page_id);        return NULL;    }    page = allocate_new_page(object->id,page_id);    HASH_ADD_INT(global_page_table, page_id, page);     curr->next = page;    return curr->next;}

void CCActionManager::removeAllActionsFromTarget(CAObject *pTarget){    // explicit null handling    if (pTarget == NULL)    {        return;    }    tHashElement *pElement = NULL;    HASH_FIND_INT(m_pTargets, &pTarget, pElement);    if (pElement)    {        if (ccArrayContainsObject(pElement->actions, pElement->currentAction) && (! pElement->currentActionSalvaged))        {            pElement->currentAction->retain();            pElement->currentActionSalvaged = true;        }        ccArrayRemoveAllObjects(pElement->actions);        if (m_pCurrentTarget == pElement)        {            m_bCurrentTargetSalvaged = true;        }        else        {            deleteHashElement(pElement);        }    }    else    {//        CCLOG("CrossApp: removeAllActionsFromTarget: Target not found");    }}

struct mystruct *find_key(off_t st_size){	struct mystruct *s;	HASH_FIND_INT(myfiles, &st_size, s);	return s;}

/** * Return an array of prototypes labeled with cluster numbers * @param c cluster structure * @param a assignment of prototypes * @param p prototypes * @return rejected feature vectors */farray_t *cluster_get_prototypes(cluster_t *c, assign_t *a, farray_t *p){    int i;    farray_t *n = farray_create("prototypes");    count_t *hash = NULL, *entry;    for (i = 0; i < a->len; i++) {        /* Skip rejected clusters */        if (!c->cluster[i])            continue;        /* Check if prototype has been added */        int j = a->proto[i];        HASH_FIND_INT(hash, &j, entry);        if (entry)            continue;        /* Add new prototype */        entry = malloc(sizeof(count_t));        entry->label = j;        HASH_ADD_INT(hash, label, entry);        /* Add prototype */        farray_add(n, fvec_clone(p->x[j]), cluster_get_name(c, i));    }    /* Delete hash table */    while (hash) {        entry = hash;        HASH_DEL(hash, entry);        free(entry);    }    return n;}

ETERM *space_delete(ETERM *fromp, ETERM *argp) {    // get the args    ETERM *space_refp = erl_element(1, argp);    erlmunk_space *s;    int space_id = ERL_REF_NUMBER(space_refp);    HASH_FIND_INT(erlmunk_spaces, &space_id, s);    // remove all subscribers    for(erlmunk_subscriber *subscriber = s->subscribers; subscriber != NULL;        subscriber = subscriber->hh.next) {        space_remove_subscriber(s, subscriber);    }    // remove all bodies    for(erlmunk_body *b = s->bodies; b != NULL;        b = b->hh.next) {        erlmunk_body_data *data = cpBodyGetUserData(b->body);        if (data->term != NULL)            erl_free_compound(data->term);        free(data);        cpSpaceRemoveBody(s->space, b->body);        cpBodyDestroy(b->body);        cpBodyFree(b->body);        space_remove_body_hash(s, b);    }    return NULL;}

bool consolidate_gpos_single(otfcc_Font *font, table_OTL *table, otl_Subtable *_subtable,                             const otfcc_Options *options) {	subtable_gpos_single *subtable = &(_subtable->gpos_single);	gpos_single_hash *h = NULL;	for (glyphid_t k = 0; k < subtable->length; k++) {		if (!GlyphOrder.consolidateHandle(font->glyph_order, &subtable->items[k].target)) {			logWarning("[Consolidate] Ignored missing glyph /%s./n", subtable->items[k].target.name);			continue;		}		gpos_single_hash *s;		int fromid = subtable->items[k].target.index;		HASH_FIND_INT(h, &fromid, s);		if (s) {			logWarning("[Consolidate] Detected glyph double-mapping about /%s./n", subtable->items[k].target.name);		} else {			NEW(s);			s->fromid = subtable->items[k].target.index;			s->fromname = sdsdup(subtable->items[k].target.name);			s->v = subtable->items[k].value;			HASH_ADD_INT(h, fromid, s);		}	}	HASH_SORT(h, gpos_by_from_id);	iSubtable_gpos_single.clear(subtable);	gpos_single_hash *s, *tmp;	HASH_ITER(hh, h, s, tmp) {		iSubtable_gpos_single.push(subtable,		                           ((otl_GposSingleEntry){		                               .target = Handle.fromConsolidated(s->fromid, s->fromname), .value = s->v,		                           }));

void del_giga_fi(int fd){    giga_file_info_t *info;    HASH_FIND_INT(_open_files, &fd, info);    if(info != NULL)        HASH_DEL(_open_files, info);}

struct fl_url_filter *find_filter(int url_id) {    struct fl_url_filter *s;    HASH_FIND_INT(filters, &url_id, s);  /* s: output pointer */    return s;}

struct file_descriptor_table * allocate_file_descriptor_table(int pid) {	struct file_descriptor_table * result_table;	HASH_FIND_INT(file_descriptor_tables, &pid, result_table);        if (result_table == NULL) {    	int i;    	struct file_descriptor_table * table = (struct file_descriptor_table *) malloc(sizeof(struct file_descriptor_table));    	table->pid = pid;    	table->entries = (struct file_descriptor_entry *) malloc(8 * sizeof(struct file_descriptor_entry));    	table->total_descriptors = 8;    	table->used_descriptors = 3;    	table->entries[0].fd = 0;    	table->entries[1].fd = 1;    	table->entries[2].fd = 2;    	for (i = 3; i < table->total_descriptors; i++) {    		table->entries[i].fd = FD_NOT_USED;    	}    	    	HASH_ADD_INT(file_descriptor_tables, pid, table);    	return table;    }    return NULL;}

bool sec_exists_entry(uint32_t secid) {  struct secentry *se=NULL;  HASH_FIND_INT(hash, &secid, se);  if(!se)    return false;  return true;}

static int adtn_socket_base(const char *data_path){	static int UID = 1;	int sock_id = -1;	int len;	bunsock_s *identifier;	++UID;	HASH_FIND_INT( sockStore, &sock_id, identifier);	if (identifier == NULL) {		sock_id = UID;		identifier = (bunsock_s *)calloc(1, sizeof(bunsock_s));		identifier->id = sock_id;		identifier->sopt.proc_flags = H_DESS | H_NOTF;		identifier->sopt.block_flags = B_DEL_NP;		identifier->sopt.lifetime = 100000; //this time is in seconds		len = strlen(data_path) + 1;		identifier->data_path = (char *)calloc(len, sizeof(char));		strncpy(identifier->data_path, data_path, len);		identifier->bdata = NULL;		HASH_ADD_INT( sockStore, id, identifier);	} else {		errno = EBUSY;	}	return sock_id;}

int adtn_setcodopt_base(int fd, code_type_e option, const char *code, int from_file, int replace){	int ret = -1;	bunsock_s *identifier;	HASH_FIND_INT(sockStore, &fd, identifier);	if (!identifier) {		errno = ENOTSOCK;		goto end;	}	if (code == NULL || strcmp(code, "") == 0 || from_file < 0 || from_file > 1) {		errno = EINVAL;		goto end;	}	switch (option) {	case ROUTING_CODE:		if (identifier->opt.rcode) {			if (replace) {				free(identifier->opt.rcode);			} else {				errno = EOPNOTSUPP;				goto end;			}		}		identifier->opt.rcode = strdup(code);		identifier->opt.r_fromfile = from_file;		break;	case LIFE_CODE:		if (identifier->opt.lcode) {			if (replace) {				free(identifier->opt.lcode);			} else {				errno = EOPNOTSUPP;				goto end;			}		}		identifier->opt.lcode = strdup(code);		identifier->opt.l_fromfile = from_file;		break;	case PRIO_CODE:		if (identifier->opt.pcode) {			if (replace) {				free(identifier->opt.pcode);			} else {				errno = EOPNOTSUPP;				goto end;			}		}		identifier->opt.pcode = strdup(code);		identifier->opt.p_fromfile = from_file;		break;	default:		errno = EINVAL;		goto end;	}	ret = 0;end:	return ret;}

int swDataBuffer_clear(swDataBuffer *data_buffer, int fd){	swDataBuffer_item *item = NULL;	HASH_FIND_INT(data_buffer->ht, &fd, item);	if (item == NULL)	{		swTrace("buffer item not found/n");		return SW_ERR;	}	else	{		swDataBuffer_trunk *trunk = item->first;		swDataBuffer_trunk *will_free_trunk; //保存trunk的指针，用于释放内存		while (trunk != NULL)		{			sw_free(trunk->data);			will_free_trunk = trunk;			trunk = trunk->next;			sw_free(will_free_trunk);		}		HASH_DEL(data_buffer->ht, item);		sw_free(item);	}	return SW_OK;}

CCAction* CCActionManager::getActionByTag(int tag, NSObject *pTarget){	assert(tag != kCCActionTagInvalid);	tHashElement *pElement = NULL;	HASH_FIND_INT(m_pTargets, &pTarget, pElement);	if (pElement)	{		if (pElement->actions != NULL)		{			unsigned int limit = pElement->actions->num;			for (unsigned int i = 0; i < limit; ++i)			{				CCAction *pAction = (CCAction*)pElement->actions->arr[i];				if (pAction->getTag() == tag)				{					return pAction;				}			}		}		CCLOG("cocos2d : getActionByTag: Action not found");	}	else	{        CCLOG("cocos2d : getActionByTag: Target not found");	}	return NULL;}

int h3m_object_add_by_def(h3mlib_ctx_t ctx, const char *def, int x, int y,    int z, int *od_index){    struct META_OA_HASH_ENTRY *oa_hash_entry = NULL;    int oa_index = 0;    int oa_body_index = 0;    // Currently oa_body_index is used as key in the    // oa hash... The current code is a bit unoptimal as if this function    // ends up calling h3m_add_oa_by_def below, an additional    // hash lookup for this hash inside that function will be performed.    if (NULL == h3m_get_def_body(def, &oa_body_index)) {        return 1;    }    // if oa for this object has not yet been added to map, add it,    // otherwise use the existing oa_index for the oa    HASH_FIND_INT(ctx->meta.oa_hash, &oa_body_index, oa_hash_entry);    if (NULL == oa_hash_entry) {        h3m_add_oa_by_def(ctx, def, &oa_index);    } else {        oa_index = oa_hash_entry->oa_index;    }    return h3m_add_od(ctx, oa_index, x, y, z, od_index);}

// Read a value from an 16-bit area of memoryuint16_t read_memory_16(gb_mem16_t* hash, int addr){	gb_mem16_t *s;			HASH_FIND_INT(hash, &addr, s);	return s->value;}

void ActionManager::addAction(Action *pAction, Node *target, bool paused){    CCASSERT(pAction != NULL, "");    CCASSERT(target != NULL, "");    tHashElement *pElement = NULL;    // we should convert it to Object*, because we save it as Object*    Object *tmp = target;    HASH_FIND_INT(_targets, &tmp, pElement);    if (! pElement)    {        pElement = (tHashElement*)calloc(sizeof(*pElement), 1);        pElement->paused = paused;        target->retain();        pElement->target = target;        HASH_ADD_INT(_targets, target, pElement);    }     actionAllocWithHashElement(pElement);      CCASSERT(! ccArrayContainsObject(pElement->actions, pAction), "");     ccArrayAppendObject(pElement->actions, pAction);      pAction->startWithTarget(target);}

JSBool js_cocos2dx_GLNode_constructor(JSContext *cx, uint32_t argc, jsval *vp){      if (argc == 0) {    GLNode* cobj = new GLNode();#ifdef COCOS2D_JAVASCRIPT    cocos2d::Object *_ccobj = dynamic_cast<cocos2d::Object *>(cobj);    if (_ccobj) {      _ccobj->autorelease();    }#endif    TypeTest<GLNode> t;    js_type_class_t *typeClass;    uint32_t typeId = t.s_id();    HASH_FIND_INT(_js_global_type_ht, &typeId, typeClass);    assert(typeClass);    JSObject *obj = JS_NewObject(cx, typeClass->jsclass, typeClass->proto, typeClass->parentProto);    JS_SET_RVAL(cx, vp, OBJECT_TO_JSVAL(obj));    // link the native object with the javascript object    js_proxy_t *p = jsb_new_proxy(cobj, obj);#ifdef COCOS2D_JAVASCRIPT    JS_AddNamedObjectRoot(cx, &p->obj, "cocos2d::GLNode");#endif    return JS_TRUE;  }  JS_ReportError(cx, "wrong number of arguments: %d, was expecting %d", argc, 0);  return JS_FALSE;}

tEffectElement* SoundDataManager::getSoundData(int nSoundID){    tEffectElement* pElement = NULL;    HASH_FIND_INT(m_pEffects, &nSoundID, pElement);    return pElement;}

void CCActionManager::removeAction(CCAction *pAction){    // explicit null handling    // 确定处理， null    if (pAction == NULL)    {        return;    }    tHashElement *pElement = NULL;    CCObject *pTarget = pAction->getOriginalTarget();    HASH_FIND_INT(m_pTargets, &pTarget, pElement);    if (pElement)    {        unsigned int i = ccArrayGetIndexOfObject(pElement->actions, pAction);        if (UINT_MAX != i)        {            removeActionAtIndex(i, pElement);        }    }    else    {        CCLOG("cocos2d: removeAction: Target not found");    }}

int main(int argc,char *argv[]) {    int i;    example_user_t *user, *tmp, *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);    }    /* delete each even ID */    for(i=0;i<10;i+=2) {        HASH_FIND_INT(users,&i,tmp);        if (tmp) {            HASH_DEL(users,tmp);            free(tmp);        } else printf("user id %d not found/n", i);    }    /* show the hash */    for(user=users; user != NULL; user=(example_user_t*)(user->hh.next)) {        printf("user %d, cookie %d/n", user->id, user->cookie);    }   return 0;}

hash_token_t *uq_tokenize_to_hash(const char *str, const char *delimiters) {	unsigned int hash;	hash_token_t *s, *table = NULL;	char *tok;	char tmp[strlen(str) + 1];	strcpy(tmp, str);	tok = strtok(tmp, delimiters);	while(tok != NULL) {		hash = str_hash(tok);		HASH_FIND_INT(table, &hash, s);		if(s == NULL) {			s = malloc(sizeof(hash_token_t));			s->key = str_hash(tok);			s->value = strdup(tok);			HASH_ADD_INT(table, key, s);		}		tok = strtok(NULL, delimiters);	}	return (table);}

void CCActionManager::addAction(CCAction *pAction, CAView *pTarget, bool paused){    CCAssert(pAction != NULL, "");    CCAssert(pTarget != NULL, "");    tHashElement *pElement = NULL;    // we should convert it to CAObject*, because we save it as CAObject*    CAObject *tmp = pTarget;    HASH_FIND_INT(m_pTargets, &tmp, pElement);    if (! pElement)    {        pElement = (tHashElement*)calloc(sizeof(*pElement), 1);        pElement->paused = paused;        pTarget->retain();        pElement->target = pTarget;        HASH_ADD_INT(m_pTargets, target, pElement);    }     actionAllocWithHashElement(pElement);      CCAssert(! ccArrayContainsObject(pElement->actions, pAction), "");     ccArrayAppendObject(pElement->actions, pAction);      pAction->startWithTarget(pTarget);}

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++;	}

JSBool js_cocos2dx_extension_HttpRequest_constructor(JSContext *cx, uint32_t argc, jsval *vp){	if(argc == 0){		HttpRequest* cobj = new HttpRequest(); 		cocos2d::CCObject *_ccobj = dynamic_cast<cocos2d::CCObject *>(cobj);		if (_ccobj) {			_ccobj->autorelease();		}		TypeTest<cocos2d::extension::CCHttpRequest> t;		js_type_class_t *typeClass;		uint32_t typeId = t.s_id();		HASH_FIND_INT(_js_global_type_ht, &typeId, typeClass);		assert(typeClass);		JSObject *obj = JS_NewObject(cx, typeClass->jsclass, typeClass->proto, typeClass->parentProto);		JS_SET_RVAL(cx, vp, OBJECT_TO_JSVAL(obj));		// link the native object with the javascript object		js_proxy_t *p;		JS_NEW_PROXY(p, cobj, obj);		JS_AddNamedObjectRoot(cx, &p->obj, "HttpRequest");		return JS_TRUE;	}	JS_ReportError(cx, "wrong number of arguments: %d, was expecting %d", argc, 0);	return JS_FALSE;}