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

intafscp_GetStatus(const struct afscp_venusfid *fid, struct AFSFetchStatus *s){    struct afscp_volume *v;    struct afscp_server *server;    struct AFSCallBack cb;    struct AFSVolSync vs;    struct AFSFid tf = fid->fid;    struct afscp_statent *stored, key;    void *cached;    int code, i, j;    time_t now;    v = afscp_VolumeById(fid->cell, fid->fid.Volume);    if (v == NULL) {	return -1;    }    memset(&key, 0, sizeof(key));    memcpy(&key.me, fid, sizeof(*fid));    cached = tfind(&key, &v->statcache, statcompare);    if (cached != NULL) {	stored = *(struct afscp_statent **)cached;	pthread_mutex_lock(&(stored->mtx));	memmove(s, &stored->status, sizeof(*s));	afs_dprintf(("Stat %u.%lu.%lu.%lu returning cached result/n",		     fid->cell->id, fid->fid.Volume, fid->fid.Vnode,		     fid->fid.Unique));	if (stored->nwaiters)	    pthread_cond_broadcast(&(stored->cv));	pthread_mutex_unlock(&(stored->mtx));	return 0;    }    code = ENOENT;    for (i = 0; i < v->nservers; i++) {	server = afscp_ServerByIndex(v->servers[i]);	if (server && server->naddrs > 0) {	    for (j = 0; j < server->naddrs; j++) {		time(&now);		code = RXAFS_FetchStatus(server->conns[j], &tf, s, &cb, &vs);		if (code == 0) {		    afscp_AddCallBack(server, &fid->fid, s, &cb, now);	/* calls _StatStuff */		    afs_dprintf(("Stat %d.%lu.%lu.%lu"				 " ok: type %ld size %ld/n",				 fid->cell->id,				 afs_printable_uint32_lu(fid->fid.Volume),				 afs_printable_uint32_lu(fid->fid.Vnode),				 afs_printable_uint32_lu(fid->fid.Unique),				 afs_printable_int32_ld(s->FileType),				 afs_printable_int32_ld(s->Length)));		    return 0;		}	    }	}    }    afscp_errno = code;    return -1;}

char* sp_rtrace_tracker_query_symbol(sp_rtrace_tracker_t* tracker, const char* name){	char* demangled_name = (char*)cplus_demangle(name, DMGL_ANSI | DMGL_PARAMS);	if (!tfind(demangled_name ? demangled_name : name, &tracker->symbols, (int (*)(const void *, const void *))_strcmpp)) {		return NULL;	}	return demangled_name ? demangled_name : strdup(name);}

DfsFile *findFile(char *path){    if (!path[0] || !strcmp(path, "/")) 	return root;    DfsFile **fh = tfind(path, &pathRoot, file_compare);    return fh ? *fh : NULL;}

/* find existing service queue */struct tpservice *fnd_service(char *svcname){	assert(svcname);	debug(1, "fnd_service(%.*s)", XATMI_SERVICE_NAME_LENGTH, svcname);	struct tpservice **svc = tfind(svcname, &services, cmp_service);	debug(2, "fnd_service(%.*s) -> 0x%x", XATMI_SERVICE_NAME_LENGTH, svcname, svc ? *svc : 0);	return svc ? *svc : 0;}

int__pmUnpinPDUBuf(void *handle){    bufctl_t	*pcp, pcp_search;    void	*bcp;    assert(((__psint_t)handle % sizeof(int)) == 0);    PM_INIT_LOCKS();    PM_LOCK(__pmLock_libpcp);    /*     * Initialize a dummy bufctl_t to use only as search key;     * only its bc_buf & bc_size fields need to be set, as that's     * all that bufctl_t_compare will look at.     */    pcp_search.bc_buf = handle;    pcp_search.bc_size = 1;    bcp = tfind(&pcp_search, &buf_tree, &bufctl_t_compare);    /*     * NB: don't release the lock until final disposition of this object;     * we don't want to play TOCTOU.     */    if (likely(bcp != NULL)) {	pcp = *(bufctl_t **)bcp;    } else {#ifdef PCP_DEBUG	if (pmDebug & DBG_TRACE_PDUBUF) {	    fprintf(stderr, "__pmUnpinPDUBuf(" PRINTF_P_PFX "%p) -> fails/n",		    handle);	    pdubufdump();	}#endif	PM_UNLOCK(__pmLock_libpcp);	return 0;    }#ifdef PCP_DEBUG    if (unlikely(pmDebug & DBG_TRACE_PDUBUF))	fprintf(stderr, "__pmUnpinPDUBuf(" PRINTF_P_PFX "%p) -> pdubuf="			PRINTF_P_PFX "%p, pincnt=%d/n", handle,		pcp->bc_buf, pcp->bc_pincnt - 1);#endif    assert((&pcp->bc_buf[0] <= (char*)handle) &&	   ((char*)handle < &pcp->bc_buf[pcp->bc_size]));    if (likely(--pcp->bc_pincnt == 0)) {	tdelete(pcp, &buf_tree, &bufctl_t_compare);	PM_UNLOCK(__pmLock_libpcp);	free(pcp);    }    else {	PM_UNLOCK(__pmLock_libpcp);    }    return 1;}

intcps_contains(    pid_t pid){    return        root == NULL            ? 0            : tfind(&pid, &root, compare) != NULL;}

// return true only if the device and inode information has not been added beforestatic inline int find_object(struct stat *st){  struct dev_and_inode obj;  void *res;  obj.dev = st->st_dev;  obj.ino = st->st_ino;  res = (void *) tfind(&obj, &seen_inodes, compare_func);  return res != (void *) NULL;}

node_t* dict_find(struct dict* d, uint64_t k){  dictPair* p = malloc(sizeof(dictPair));  p->key = k;    dictPair* r = (dictPair*) tfind(p, &d->root, compar);    if (r == NULL) return NULL;  else return (*(dictPair **)r)->value;}

static variable_t *Lookup( vlc_object_t *obj, const char *psz_name ){    vlc_object_internals_t *priv = vlc_internals( obj );    variable_t **pp_var;    vlc_mutex_lock(&priv->var_lock);    pp_var = tfind( &psz_name, &priv->var_root, varcmp );    return (pp_var != NULL) ? *pp_var : NULL;}

HTokenType h_get_token_type_number(const char* name) {  Entry e;  e.name = name;  Entry **ret = (Entry**)tfind(&e, &tt_registry, compare_entries);  if (ret == NULL)    return 0;  else    return (*ret)->value;}

static cometd_client_subscription* cometd_find_subscription(cometd_client_t * client, const char * channel) {	if (!client || !channel)		return 0;	cometd_client_impl* cli = (cometd_client_impl*)client;	cometd_client_subscription test;	test.channel = channel;	void ** found = tfind(&test, &cli->subscriptions, &compare_subs);	return found ? *(cometd_client_subscription**)found : 0;}

/** Internal use only. */static dictionary_entry_t *dictionary_tfind(dictionary_t *d, const char *key){	dictionary_entry_t tentry = {key, NULL};	void *tresult = tfind((void *)&tentry, &d->root, compare);	if (tresult == NULL)		return NULL;	else		return *((dictionary_entry_t **)tresult);}

metafield_t* metafield_search(const char * name){    metafield_t **metafield, search;    if (!name) return NULL;    search.name = name;    metafield = tfind(&search, &metafields_root, (ELEMENT_COMPARE) metafield_compare);    return metafield ? *metafield : NULL;}

datastore_entry_t *dictionary_tfind(datastore_t *ds, const char *key){	datastore_entry_t tentry = {key, NULL, 0};	void *tresult = tfind((void *)&tentry, &ds->root, compare);	if (tresult == NULL)		return NULL;	else		return *((datastore_entry_t **)tresult);}

algorithm_t * algorithm_search(const char * name){    algorithm_t ** algorithm, search;    if (!name) return NULL;    search.name = name;    algorithm = tfind(&search, &algorithms_root, (ELEMENT_COMPARE) algorithm_compare);    return algorithm ? *algorithm : NULL;}

// Returns 1 if the proper function name of cur_entry is found in// prog_pts_tree and 0 otherwise.  Always look for cur_entry->fjalar_name.Bool prog_pts_tree_entry_found(FunctionEntry* cur_entry) {  if (tfind((void*)cur_entry->fjalar_name,            (void**)&prog_pts_tree,            compareStrings)) {    return 1;  }  else {    return 0;  }}

/* Look in caches, 0=found and valid, 1=not or uncachable in the first place */static enum cache_task_return Cache_Get_Common_Dir(struct dirblob *db, time_t * duration, const struct tree_node *tn){	enum cache_task_return ctr_ret;	time_t now = NOW_TIME;	size_t size;	struct tree_opaque *opaque;	LEVEL_DEBUG("Get from cache sn " SNformat " pointer=%p extension=%d", SNvar(tn->tk.sn), tn->tk.p, tn->tk.extension);	CACHE_RLOCK;	opaque = tfind(tn, &cache.temporary_tree_new, tree_compare) ;	if ( opaque == NULL ) {		// not found in new tree		if ( cache.time_retired + duration[0] > now ) {			// old tree could be new enough			opaque = tfind(tn, &cache.temporary_tree_old, tree_compare) ;		}	}	if ( opaque != NULL ) {		duration[0] = opaque->key->expires - now ;		if (duration[0] >= 0) {			LEVEL_DEBUG("Dir found in cache");			size = opaque->key->dsize;			if (DirblobRecreate(TREE_DATA(opaque->key), size, db) == 0) {				//printf("Cache: snlist=%p, devices=%lu, size=%lu/n",*snlist,devices[0],size) ;				ctr_ret = ctr_ok;			} else {				ctr_ret = ctr_size_mismatch;			}		} else {			//char b[26];			//printf("GOT DEAD now:%s",ctime_r(&now,b)) ;			//printf("        then:%s",ctime_r(&opaque->key->expires,b)) ;			LEVEL_DEBUG("Dir expired in cache");			ctr_ret = ctr_expired;		}	} else {		LEVEL_DEBUG("Dir not found in cache");		ctr_ret = ctr_not_found;	}	CACHE_RUNLOCK;	return ctr_ret;}

/** * Removes a source (if present) by index. */static void RemoveSource (services_discovery_t *sd, uint32_t idx){    services_discovery_sys_t *sys = sd->p_sys;    struct device **dp = tfind (&idx, &sys->root, cmpsrc);    if (dp == NULL)        return;    struct device *d = *dp;    tdelete (d, &sys->root, cmpsrc);    DestroySource (d);}

/* * Returns the unit-and-identifier whose ASCII identifier corresponding to a * unit. * * Arguments: *	map	The unit-to-identifier map. *	unit	The unit to be used as the key in the search. * Returns: *	NULL	The map doesn't contain an entry corresponding to "unit" whose *		identifier is in ASCII. *	else	Pointer to the entry corresponding to "unit" whose identifier is *		in ASCII. */static UnitAndId*utimFindAsciiByUnit(    UnitToIdMap* const	map,    const ut_unit* const	unit){    UnitAndId	targetEntry;    UnitAndId**	treeEntry;    targetEntry.unit = (ut_unit*)unit;    treeEntry = tfind(&targetEntry, &map->ascii, compareUnits);    return treeEntry == NULL ? NULL : *treeEntry;}

/* look in persistent alias->sn tree */static void Cache_Del_Alias_Persistent( struct alias_tree_node * atn){	struct tree_opaque *opaque;	struct alias_tree_node *atn_found = NULL;	PERSISTENT_RLOCK;	opaque = tfind(atn, &cache.persistent_alias_tree, alias_tree_compare) ;	if ( opaque != NULL ) {		atn_found = (struct alias_tree_node *) (opaque->key);	}	PERSISTENT_RUNLOCK;	owfree(atn_found) ;}

/** * Removes a udev device (if present). */static void RemoveDevice (services_discovery_t *sd, struct udev_device *dev){    services_discovery_sys_t *p_sys = sd->p_sys;    dev_t num = udev_device_get_devnum (dev);    struct device **dp = tfind (&(dev_t){ num }, &p_sys->root, cmpdev);    if (dp == NULL)        return;    struct device *d = *dp;    tdelete (d, &p_sys->root, cmpdev);    DestroyDevice (d);}

xtreePos_t xtreeFind(void *treehandle, char *key){	xtree_t *tree = treehandle;	treerec_t **result, rec;	if (!tree) return NULL;	rec.key = key;	rec.userdata = NULL;	rec.compare = tree->compare;	result = tfind(&rec, &tree->root, xtree_i_compare);	return (result ? *result : NULL);}

char * grdx_scgi_get_header(const char * __name, const scgi_t * __scgi){    struct header_s _header_key;    void * _tfind_ret;        _header_key.name = __name;    _header_key.value = NULL;    _tfind_ret = tfind(&_header_key, &(__scgi->tree_header), compare_header);    if(_tfind_ret == NULL)    {        return NULL;    }    return (*((struct header_s**)_tfind_ret))->value;}

/* * Stage 1: Input * *  filename should either be `-' for `stdin' else an accessible *  disk file. */uint32_tinhx32_tree_input(void **root, const char *filename, uint32_t *count){	FILE *fp = stdin;	uint32_t nbytes = 0;	void *entry;	pic_data *data;		*count = 0;	/* Open file or stdin */	if (strcmp(filename, "-") && (fp = fopen(filename, "rb")) == NULL) {		printf("%s: error: fopen failed [%s] [%s]/n",			__func__, filename, strerror(errno));		return 0; /* Empty */	}	/* While not EOF, process data */	while ((data = inhx32_get(fp)) != NULL) {		/* Detect duplicate data in tree */		entry = tfind((void *)data, root, inhx32_tree_compare);		if (entry != NULL) {			printf("%s: fatal error: duplicate address [%08X]/n",				__func__, data->address);			io_exit(EX_SOFTWARE); /* Panic */		}		/* Add new data to tree */		entry = tsearch((void *)data, root, inhx32_tree_compare);		if (entry == NULL) {			printf("%s: fatal error: tsearch failed/n", __func__);			io_exit(EX_OSERR); /* Panic */		}		/* Update counters */		(*count)++;		nbytes += data->nbytes;	}	/* Close file or stdin */	if (strcmp(filename, "-"))		fclose(fp);	/* Information */	if (nbytes == 0)		printf("%s: information: no valid input data/n", __func__);	/* Return number of bytes */	return nbytes;}

/** * Ensures that a PID doesn't exist. * * @param pid       [in] The PID to not exist. */voidcps_remove(    pid_t pid){    void  *node = tfind(&pid, &root, compare);    if (node != NULL) {        pid_t *elt = *(pid_t**)node;        (void)tdelete(&pid, &root, compare);        free(elt);        count--;    }}

int delString(struct StringTable *st, const char *key){  struct StringTableNode *result;  char *toFree;  result = (struct StringTableNode *)           tfind(&key, &st->stringTableNodeTab, compare);  if (result == NULL) return ERR_NOSTRING;  result = * (struct StringTableNode **) result;  toFree = result->key;  tdelete(result, &st->stringTableNodeTab, compare);  free(toFree);  free(result);  return 0;}

intiol_del_event(int fd){	struct ioloop_event_desc tmpdesc = {.iol_fd = fd};	struct epoll_event       tmpev; 	struct epoll_event **ev = NULL;	tmpev.data.ptr = &tmpdesc;	ev = tfind(&tmpev, &_iol_manager.root, _iol_cmp);    if(ev){	    return _iol_del_internal_event(fd, *ev);    }    return -1;}

static INDEX_OR_ERROR Cache_Get_Alias_Common( struct alias_tree_node * atn){	INDEX_OR_ERROR bus = INDEX_BAD;	time_t now = NOW_TIME;	struct tree_opaque *opaque;		CACHE_RLOCK;	opaque = tfind(atn, &cache.temporary_alias_tree_new, alias_tree_compare) ;	if ( opaque == NULL ) {		// try old tree		opaque = tfind(atn, &cache.temporary_alias_tree_old, alias_tree_compare) ;	}	if ( opaque != NULL ) {		// test expiration		if ( ((struct alias_tree_node *)(opaque->key))->expires > now) {			bus = ((struct alias_tree_node *)(opaque->key))->bus ;			LEVEL_DEBUG("Found %s on bus.%d",ALIAS_TREE_DATA(atn),bus) ;		}	}	CACHE_RUNLOCK;	LEVEL_DEBUG("Finding %s unsuccessful",ALIAS_TREE_DATA(atn)) ;	owfree(atn) ;	return bus;}

static struct perf_apm *find_or_add_perf(const char *name){	struct perf_apm perf, *ret;	perf.name = strdup(name);	ret = tfind(&perf, &root, compare);	free(perf.name);	if (!ret) {		ret = new_perf(name);	} else {		ret = *((void **)ret);	}	return ret;}

static GOOD_OR_BAD Cache_Del_Common(const struct tree_node *tn){	struct tree_opaque *opaque;	time_t now = NOW_TIME;	GOOD_OR_BAD ret = gbBAD;	LEVEL_DEBUG("Delete from cache sn " SNformat " in=%p index=%d", SNvar(tn->tk.sn), tn->tk.p, tn->tk.extension);	CACHE_WLOCK;	opaque = tfind(tn, &cache.temporary_tree_new, tree_compare) ;	if ( opaque == NULL ) {		// not in new tree		if ( cache.time_to_kill > now ) {			// old tree still alive			opaque = tfind(tn, &cache.temporary_tree_old, tree_compare) ;		}	}	if ( opaque != NULL ) {		opaque->key->expires = now - 1;		ret = gbGOOD;	}	CACHE_WUNLOCK;	return ret;}