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

void Region::cleanupRegionData() {    for (int32_t i = 0 ; i < URGN_LIMIT ; i++ ) {        if ( availableRegions[i] ) {            delete availableRegions[i];        }    }    if (regionAliases) {        uhash_close(regionAliases);    }    if (numericCodeMap) {        uhash_close(numericCodeMap);    }    if (regionIDMap) {        uhash_close(regionIDMap);    }    if (allRegions) {        allRegions->removeAllElements(); // Don't need the temporary list anymore.        delete allRegions;        allRegions = NULL;    }    regionAliases = numericCodeMap = regionIDMap = NULL;    gRegionDataInitOnce.reset();}

/** * Cleanup callback func */static UBool U_CALLCONV zoneMeta_cleanup(void){     umtx_destroy(&gZoneMetaLock);    if (gCanonicalMap != NULL) {        uhash_close(gCanonicalMap);        gCanonicalMap = NULL;    }    gCanonicalMapInitialized = FALSE;    if (gOlsonToMeta != NULL) {        uhash_close(gOlsonToMeta);        gOlsonToMeta = NULL;    }    gOlsonToMetaInitialized = FALSE;    if (gMetaToOlson != NULL) {        uhash_close(gMetaToOlson);        gMetaToOlson = NULL;    }    gMetaToOlsonInitialized = FALSE;        freeUStringTable();    return TRUE;}

U_CDECL_BEGIN/** * Cleanup callback func */static UBool U_CALLCONV zoneMeta_cleanup(void){    if (gCanonicalIDCache != NULL) {        uhash_close(gCanonicalIDCache);        gCanonicalIDCache = NULL;    }    gCanonicalIDCacheInitialized = FALSE;    if (gOlsonToMeta != NULL) {        uhash_close(gOlsonToMeta);        gOlsonToMeta = NULL;    }    gOlsonToMetaInitialized = FALSE;    if (gMetaZoneIDTable != NULL) {        uhash_close(gMetaZoneIDTable);    }    // delete after closing gMetaZoneIDTable, because it holds    // value objects held by the hashtable    delete gMetaZoneIDs;    gMetaZoneIDsInitialized = FALSE;    delete gSingleZoneCountries;    delete gMultiZonesCountries;    gCountryInfoVectorsInitialized = FALSE;    return TRUE;}

static void U_CALLCONV initAvailableMetaZoneIDs () {    U_ASSERT(gMetaZoneIDs == NULL);    U_ASSERT(gMetaZoneIDTable == NULL);    ucln_i18n_registerCleanup(UCLN_I18N_ZONEMETA, zoneMeta_cleanup);    UErrorCode status = U_ZERO_ERROR;    gMetaZoneIDTable = uhash_open(uhash_hashUnicodeString, uhash_compareUnicodeString, NULL, &status);    if (U_FAILURE(status) || gMetaZoneIDTable == NULL) {        gMetaZoneIDTable = NULL;        return;    }    uhash_setKeyDeleter(gMetaZoneIDTable, uprv_deleteUObject);    // No valueDeleter, because the vector maintain the value objects    gMetaZoneIDs = new UVector(NULL, uhash_compareUChars, status);    if (U_FAILURE(status) || gMetaZoneIDs == NULL) {        gMetaZoneIDs = NULL;        uhash_close(gMetaZoneIDTable);        gMetaZoneIDTable = NULL;        return;    }    gMetaZoneIDs->setDeleter(uprv_free);    UResourceBundle *rb = ures_openDirect(NULL, gMetaZones, &status);    UResourceBundle *bundle = ures_getByKey(rb, gMapTimezonesTag, NULL, &status);    UResourceBundle res;    ures_initStackObject(&res);    while (U_SUCCESS(status) && ures_hasNext(bundle)) {        ures_getNextResource(bundle, &res, &status);        if (U_FAILURE(status)) {            break;        }        const char *mzID = ures_getKey(&res);        int32_t len = uprv_strlen(mzID);        UChar *uMzID = (UChar*)uprv_malloc(sizeof(UChar) * (len + 1));        if (uMzID == NULL) {            status = U_MEMORY_ALLOCATION_ERROR;            break;        }        u_charsToUChars(mzID, uMzID, len);        uMzID[len] = 0;        UnicodeString *usMzID = new UnicodeString(uMzID);        if (uhash_get(gMetaZoneIDTable, usMzID) == NULL) {            gMetaZoneIDs->addElement((void *)uMzID, status);            uhash_put(gMetaZoneIDTable, (void *)usMzID, (void *)uMzID, &status);        } else {            uprv_free(uMzID);            delete usMzID;        }    }    ures_close(&res);    ures_close(bundle);    ures_close(rb);    if (U_FAILURE(status)) {        uhash_close(gMetaZoneIDTable);        delete gMetaZoneIDs;        gMetaZoneIDTable = NULL;        gMetaZoneIDs = NULL;    }}

voidTZGNCore::cleanup() {    if (fLocaleDisplayNames != NULL) {        delete fLocaleDisplayNames;    }    if (fTimeZoneNames != NULL) {        delete fTimeZoneNames;    }    uhash_close(fLocationNamesMap);    uhash_close(fPartialLocationNamesMap);}

voidTimeZoneNamesImpl::cleanup() {    if (fZoneStrings != NULL) {        ures_close(fZoneStrings);        fZoneStrings = NULL;    }    if (fMZNamesMap != NULL) {        uhash_close(fMZNamesMap);        fMZNamesMap = NULL;    }    if (fTZNamesMap != NULL) {        uhash_close(fTZNamesMap);        fTZNamesMap = NULL;    }}

ConfusabledataBuilder::~ConfusabledataBuilder() {    uprv_free(fInput);    uregex_close(fParseLine);    uregex_close(fParseHexNum);    uhash_close(fSLTable);    uhash_close(fSATable);    uhash_close(fMLTable);    uhash_close(fMATable);    delete fKeySet;    delete fKeyVec;    delete fStringTable;    delete fStringLengthsTable;    delete fValueVec;    delete stringPool;}

U_CDECL_END/** Initializes the cache for resources */static voidinitCache(UErrorCode * status){	UBool makeCache;	UMTX_CHECK(&usprepMutex, (SHARED_DATA_HASHTABLE ==  NULL), makeCache);	if (makeCache)	{		UHashtable * newCache = uhash_open(hashEntry, compareEntries, NULL, status);		if (U_SUCCESS(*status))		{			umtx_lock(&usprepMutex);			if (SHARED_DATA_HASHTABLE == NULL)			{				SHARED_DATA_HASHTABLE = newCache;				ucln_common_registerCleanup(UCLN_COMMON_USPREP, usprep_cleanup);				newCache = NULL;			}			umtx_unlock(&usprepMutex);		}		if (newCache != NULL)		{			uhash_close(newCache);		}	}}

static void hashIChars(void) {    static const char which[] = "which";    static const char WHICH2[] = "WHICH";    static const char where[] = "where";    UErrorCode status = U_ZERO_ERROR;    UHashtable *hash;    hash = uhash_open(uhash_hashIChars, uhash_compareIChars, NULL, &status);    if (U_FAILURE(status)) {        log_err("FAIL: uhash_open failed with %s and returned 0x%08x/n",                u_errorName(status), hash);        return;    }    if (hash == NULL) {        log_err("FAIL: uhash_open returned NULL/n");        return;    }    log_verbose("Ok: uhash_open returned 0x%08X/n", hash);    _put(hash, which, 1, 0);    _put(hash, WHICH2, 2, 1);    _put(hash, where, 3, 0);    if(uhash_count(hash) != 2){         log_err("FAIL: uhas_count() failed. Expected: 1, Got: %d/n", uhash_count(hash));    }    _remove(hash, which, 2);    uhash_close(hash);}

CollDataCache::~CollDataCache(){    umtx_lock(&lock);    uhash_close(cache);    cache = NULL;    umtx_unlock(&lock);}

 /*   udata_getCacheHashTable() *     Get the hash table used to store the data cache entries. *     Lazy create it if it doesn't yet exist. */static UHashtable *udata_getHashTable() {    UErrorCode   err = U_ZERO_ERROR;    UBool        cacheIsInitialized;    UHashtable  *tHT = NULL;    UMTX_CHECK(NULL, (gCommonDataCache != NULL), cacheIsInitialized);    if (cacheIsInitialized) {        return gCommonDataCache;    }    tHT = uhash_open(uhash_hashChars, uhash_compareChars, NULL, &err);    /* Check for null pointer. */    if (tHT == NULL) {    	return NULL; /* TODO:  Handle this error better. */    }    uhash_setValueDeleter(tHT, DataCacheElement_deleter);    umtx_lock(NULL);    if (gCommonDataCache == NULL) {        gCommonDataCache = tHT;        tHT = NULL;        ucln_common_registerCleanup(UCLN_COMMON_UDATA, udata_cleanup);    }    umtx_unlock(NULL);    if (tHT != NULL) {        uhash_close(tHT);    }    if (U_FAILURE(err)) {        return NULL;      /* TODO:  handle this error better.  */    }    return gCommonDataCache;}

//--------------------------------------------------------------------------////   zap            Delete everything owned by this RegexPattern.////--------------------------------------------------------------------------void RegexPattern::zap() {    delete fCompiledPat;    fCompiledPat = NULL;    int i;    for (i=1; i<fSets->size(); i++) {        UnicodeSet *s;        s = (UnicodeSet *)fSets->elementAt(i);        if (s != NULL) {            delete s;        }    }    delete fSets;    fSets = NULL;    delete[] fSets8;    fSets8 = NULL;    delete fGroupMap;    fGroupMap = NULL;    delete fInitialChars;    fInitialChars = NULL;    delete fInitialChars8;    fInitialChars8 = NULL;    if (fPattern != NULL) {        utext_close(fPattern);        fPattern = NULL;    }    if (fPatternString != NULL) {        delete fPatternString;        fPatternString = NULL;    }    uhash_close(fNamedCaptureMap);    fNamedCaptureMap = NULL;}

static void U_CALLCONVuloc_deleteKeyDataEntry(void* obj) {    LocExtKeyData* keyData = (LocExtKeyData*)obj;    if (keyData->typeMap != NULL) {        uhash_close(keyData->typeMap);    }    uprv_free(keyData);}

IdentifierInfo::~IdentifierInfo() {    delete fIdentifier;    delete fRequiredScripts;    uhash_close(fScriptSetSet);    delete fCommonAmongAlternates;    delete fNumerics;    delete fIdentifierProfile;}

SPUStringPool::~SPUStringPool() {    int i;    for (i=fVec->size()-1; i>=0; i--) {        SPUString *s = static_cast<SPUString *>(fVec->elementAt(i));        delete s;    }    delete fVec;    uhash_close(fHash);}

static UBool U_CALLCONV usprep_cleanup(void){    if (SHARED_DATA_HASHTABLE != NULL) {        usprep_internal_flushCache(TRUE);        if (SHARED_DATA_HASHTABLE != NULL && uhash_count(SHARED_DATA_HASHTABLE) == 0) {            uhash_close(SHARED_DATA_HASHTABLE);            SHARED_DATA_HASHTABLE = NULL;        }    }    gSharedDataInitOnce.reset();    return (SHARED_DATA_HASHTABLE == NULL);}

U_NAMESPACE_ENDU_CDECL_BEGINstatic UBool U_CALLCONV cdf_cleanup(void) {  if (gCompactDecimalData != NULL) {    uhash_close(gCompactDecimalData);    gCompactDecimalData = NULL;  }  return TRUE;}

static UBool U_CALLCONV uprv_loaded_normalizer2_cleanup() {    delete nfkcSingleton;    nfkcSingleton = NULL;    delete nfkc_cfSingleton;    nfkc_cfSingleton = NULL;    uhash_close(cache);    cache=NULL;    nfkcInitOnce.reset();     nfkc_cfInitOnce.reset();     return TRUE;}

UnifiedCache::~UnifiedCache() {    // Try our best to clean up first.    flush();    {        // Now all that should be left in the cache are entries that refer to        // each other and entries with hard references from outside the cache.        // Nothing we can do about these so proceed to wipe out the cache.        Mutex lock(&gCacheMutex);        _flush(TRUE);    }    uhash_close(fHashtable);}

AlphabeticIndex::~AlphabeticIndex() {    uhash_close(alreadyIn_);    delete bucketList_;    delete collator_;    delete collatorPrimaryOnly_;    delete firstScriptCharacters_;    delete labels_;    delete inputRecords_;    delete noDistinctSorting_;    delete notAlphabetic_;    delete initialLabels_;}

static void TestBasic(void) {    const char one[4] =   {0x6F, 0x6E, 0x65, 0}; /* "one" */    const char one2[4] =  {0x6F, 0x6E, 0x65, 0}; /* Get around compiler optimizations */    const char two[4] =   {0x74, 0x77, 0x6F, 0}; /* "two" */    const char three[6] = {0x74, 0x68, 0x72, 0x65, 0x65, 0}; /* "three" */    const char omega[6] = {0x6F, 0x6D, 0x65, 0x67, 0x61, 0}; /* "omega" */    UErrorCode status = U_ZERO_ERROR;    UHashtable *hash;    hash = uhash_open(hashChars, isEqualChars,  &status);    if (U_FAILURE(status)) {        log_err("FAIL: uhash_open failed with %s and returned 0x%08x/n",                u_errorName(status), hash);        return;    }    if (hash == NULL) {        log_err("FAIL: uhash_open returned NULL/n");        return;    }    log_verbose("Ok: uhash_open returned 0x%08X/n", hash);    _put(hash, one, 1, 0);    _put(hash, omega, 24, 0);    _put(hash, two, 2, 0);    _put(hash, three, 3, 0);    _put(hash, one, -1, 1);    _put(hash, two, -2, 2);    _put(hash, omega, 48, 24);    _put(hash, one, 100, -1);    _get(hash, three, 3);    _remove(hash, two, -2);    _get(hash, two, 0);    _get(hash, one, 100);    _put(hash, two, 200, 0);    _get(hash, omega, 48);    _get(hash, two, 200);    if(_compareChars((void*)one, (void*)three) == TRUE ||        _compareChars((void*)one, (void*)one2) != TRUE ||        _compareChars((void*)one, (void*)one) != TRUE ||        _compareChars((void*)one, NULL) == TRUE  )  {        log_err("FAIL: compareChars failed/n");    }    if(_compareIChars((void*)one, (void*)three) == TRUE ||        _compareIChars((void*)one, (void*)one) != TRUE ||        _compareIChars((void*)one, (void*)one2) != TRUE ||        _compareIChars((void*)one, NULL) == TRUE  )  {        log_err("FAIL: compareIChars failed/n");    }         uhash_close(hash);}

ZNStringPool::~ZNStringPool() {    if (fHash != NULL) {        uhash_close(fHash);        fHash = NULL;    }    while (fChunks != NULL) {        ZNStringPoolChunk *nextChunk = fChunks->fNext;        delete fChunks;        fChunks = nextChunk;    }}

U_CDECL_BEGIN/** * Cleanup callback func */static UBool U_CALLCONV tzgnCore_cleanup(void){    if (gTZGNCoreCache != NULL) {        uhash_close(gTZGNCoreCache);        gTZGNCoreCache = NULL;    }    gTZGNCoreCacheInitialized = FALSE;    return TRUE;}

U_CDECL_BEGIN/** * Cleanup callback func */static UBool U_CALLCONV timeZoneNames_cleanup(void){    if (gTimeZoneNamesCache != NULL) {        uhash_close(gTimeZoneNamesCache);        gTimeZoneNamesCache = NULL;    }    gTimeZoneNamesCacheInitialized = FALSE;    return TRUE;}

/*                Not supported  API.  Marked U_CAPI only for use by test programs.    */U_CFUNC UBool U_EXPORT2 ucnv_cleanup(void) {    if (SHARED_DATA_HASHTABLE != NULL) {        ucnv_flushCache();        if (SHARED_DATA_HASHTABLE != NULL && uhash_count(SHARED_DATA_HASHTABLE) == 0) {            uhash_close(SHARED_DATA_HASHTABLE);            SHARED_DATA_HASHTABLE = NULL;        }    }    umtx_destroy(&cnvCacheMutex);           /* Don't worry about destroying the mutex even  */                                            /*  if the hash table still exists.  The mutex  */                                            /*  will lazily re-init  itself if needed.      */    return (SHARED_DATA_HASHTABLE == NULL);}

static UBool U_CALLCONV usprep_cleanup(void){    if (SHARED_DATA_HASHTABLE != NULL) {        usprep_internal_flushCache(TRUE);        if (SHARED_DATA_HASHTABLE != NULL && uhash_count(SHARED_DATA_HASHTABLE) == 0) {            uhash_close(SHARED_DATA_HASHTABLE);            SHARED_DATA_HASHTABLE = NULL;        }    }    umtx_destroy(&usprepMutex);             /* Don't worry about destroying the mutex even  */                                            /*  if the hash table still exists.  The mutex  */                                            /*  will lazily re-init  itself if needed.      */    return (SHARED_DATA_HASHTABLE == NULL);}

static UBool U_CALLCONV locale_cleanup(void){    U_NAMESPACE_USE    delete [] gLocaleCache;    gLocaleCache = NULL;    gLocaleCacheInitOnce.reset();    if (gDefaultLocalesHashT) {        uhash_close(gDefaultLocalesHashT);   // Automatically deletes all elements, using deleter func.        gDefaultLocalesHashT = NULL;    }    gDefaultLocale = NULL;    return TRUE;}

static UBool U_CALLCONV numfmt_cleanup(void) {#if !UCONFIG_NO_SERVICE    if (gService) {        delete gService;        gService = NULL;    }#endif    if (NumberingSystem_cache) {        // delete NumberingSystem_cache;        uhash_close(NumberingSystem_cache);        NumberingSystem_cache = NULL;    }    return TRUE;}