ResourceBundle ResourceBundle::getNext(UErrorCode& status) { UResourceBundle r; ures_initStackObject(&r); ures_getNextResource(fResource, &r, &status); ResourceBundle res(&r, status); if (U_SUCCESS(status)) { ures_close(&r); } return res; }
ResourceBundle ResourceBundle::get(int32_t indexR, UErrorCode& status) const { UResourceBundle r; ures_initStackObject(&r); ures_getByIndex(fResource, indexR, &r, &status); ResourceBundle res(&r, status); if (U_SUCCESS(status)) { ures_close(&r); } return res; }
static UBool getOlsonMeta() { if (OLSON_ZONE_COUNT == 0) { UErrorCode ec = U_ZERO_ERROR; UResourceBundle *top = ures_openDirect(0, kZONEINFO, &ec); if (U_SUCCESS(ec)) { getOlsonMeta(top); } ures_close(top); } return (OLSON_ZONE_COUNT > 0); }
const UChar *getErrorName(UErrorCode errorNumber) { UErrorCode status = U_ZERO_ERROR; int32_t len = 0; UResourceBundle *error = ures_open(currdir, locale, &status); UResourceBundle *errorcodes = ures_getByKey(error, "errorcodes", NULL, &status); const UChar *result = ures_getStringByIndex(errorcodes, errorNumber, &len, &status); ures_close(errorcodes); ures_close(error); if(U_SUCCESS(status)) { return result; } else { return baderror; } }
UBool hasCollationElements(const char *locName) { UErrorCode status = U_ZERO_ERROR; UResourceBundle *ColEl = NULL; UResourceBundle *loc = ures_open(U_ICUDATA_COLL, locName, &status); if(U_SUCCESS(status)) { status = U_ZERO_ERROR; ColEl = ures_getByKey(loc, "collations", ColEl, &status); if(status == U_ZERO_ERROR) { /* do the test - there are real elements */ ures_close(ColEl); ures_close(loc); return TRUE; } ures_close(ColEl); ures_close(loc); } return FALSE; }
ResourceBundle ResourceBundle::get(const char* key, UErrorCode& status) const { UResourceBundle r; ures_initStackObject(&r); ures_getByKey(fResource, key, &r, &status); ResourceBundle res(&r, status); if (U_SUCCESS(status)) { ures_close(&r); } return res; }
const UnicodeString U_EXPORT2 TimeZone::getEquivalentID(const UnicodeString& id, int32_t index) { U_DEBUG_TZ_MSG(("gEI(%d)\n", index)); UnicodeString result; UErrorCode ec = U_ZERO_ERROR; UResourceBundle res; ures_initStackObject(&res); UResourceBundle *top = openOlsonResource(id, res, ec); int32_t zone = -1; if (U_SUCCESS(ec)) { int32_t size = ures_getSize(&res); if (size == 4 || size == 6) { UResourceBundle r; ures_initStackObject(&r); ures_getByIndex(&res, size-1, &r, &ec); const int32_t* v = ures_getIntVector(&r, &size, &ec); if (index >= 0 && index < size && getOlsonMeta()) { zone = v[index]; } ures_close(&r); } } ures_close(&res); if (zone >= 0) { UResourceBundle *ares = ures_getByKey(top, kNAMES, NULL, &ec); // dereference Zones section if (U_SUCCESS(ec)) { int32_t idLen = 0; const UChar* id = ures_getStringByIndex(ares, zone, &idLen, &ec); result.fastCopyFrom(UnicodeString(TRUE, id, idLen)); U_DEBUG_TZ_MSG(("gei(%d) -> %d, len%d, %s\n", index, zone, result.length(), u_errorName(ec))); } ures_close(ares); } ures_close(top); #if defined(U_DEBUG_TZ) if(result.length() ==0) { U_DEBUG_TZ_MSG(("equiv [__, #%d] -> 0 (%s)\n", index, u_errorName(ec))); } #endif return result; }
static jstring getCurrencySymbolNative(JNIEnv* env, jclass clazz, jstring locale, jstring currencyCode) { // LOGI("ENTER getCurrencySymbolNative"); UErrorCode status = U_ZERO_ERROR; const char *locName = env->GetStringUTFChars(locale, NULL); UResourceBundle *root = ures_open(NULL, locName, &status); env->ReleaseStringUTFChars(locale, locName); if(U_FAILURE(status)) { return NULL; } UResourceBundle *rootElems = ures_getByKey(root, "Currencies", NULL, &status); if(U_FAILURE(status)) { ures_close(root); return NULL; } const char *currName = env->GetStringUTFChars(currencyCode, NULL); UResourceBundle *currencyElems = ures_getByKey(rootElems, currName, NULL, &status); env->ReleaseStringUTFChars(currencyCode, currName); if(U_FAILURE(status)) { ures_close(rootElems); ures_close(root); return NULL; } int currSymbL; const jchar *currSymbU = ures_getStringByIndex(currencyElems, 0, &currSymbL, &status); if(U_FAILURE(status)) { ures_close(currencyElems); ures_close(rootElems); ures_close(root); return NULL; } ures_close(currencyElems); ures_close(rootElems); ures_close(root); if(currSymbL == 0) { return NULL; } return env->NewString(currSymbU, currSymbL); }
const UChar* TimeZone::getRegion(const UnicodeString& id) { const UChar *result = WORLD; UErrorCode ec = U_ZERO_ERROR; UResourceBundle *rb = ures_openDirect(NULL, kZONEINFO, &ec); // resolve zone index by name UResourceBundle *res = ures_getByKey(rb, kNAMES, NULL, &ec); int32_t idx = findInStringArray(res, id, ec); // get region mapping ures_getByKey(rb, kREGIONS, res, &ec); const UChar *tmp = ures_getStringByIndex(res, idx, NULL, &ec); if (U_SUCCESS(ec)) { result = tmp; } ures_close(res); ures_close(rb); return result; }
// initCDFLocaleStyleData loads formatting data for a particular style. // decimalFormatBundle is the "decimalFormat" resource bundle in CLDR. // Loaded data stored in result. static void initCDFLocaleStyleData(const UResourceBundle* decimalFormatBundle, CDFLocaleStyleData* result, UErrorCode& status) { if (U_FAILURE(status)) { return; } // Iterate through all the powers of 10. int32_t size = ures_getSize(decimalFormatBundle); UResourceBundle* power10 = NULL; for (int32_t i = 0; i < size; ++i) { power10 = ures_getByIndex(decimalFormatBundle, i, power10, &status); if (U_FAILURE(status)) { ures_close(power10); return; } populatePower10(power10, result, status); if (U_FAILURE(status)) { ures_close(power10); return; } } ures_close(power10); fillInMissing(result); }
static int32_t _getStringOrCopyKey(const char *path, const char *locale, const char *tableKey, const char* subTableKey, const char *itemKey, const char *substitute, UChar *dest, int32_t destCapacity, UErrorCode *pErrorCode) { const UChar *s = NULL; int32_t length = 0; if(itemKey==NULL) { /* top-level item: normal resource bundle access */ UResourceBundle *rb; rb=ures_open(path, locale, pErrorCode); if(U_SUCCESS(*pErrorCode)) { s=ures_getStringByKey(rb, tableKey, &length, pErrorCode); /* see comment about closing rb near "return item;" in _res_getTableStringWithFallback() */ ures_close(rb); } } else { /* Language code should not be a number. If it is, set the error code. */ if (!uprv_strncmp(tableKey, "Languages", 9) && uprv_strtol(itemKey, NULL, 10)) { *pErrorCode = U_MISSING_RESOURCE_ERROR; } else { /* second-level item, use special fallback */ s=uloc_getTableStringWithFallback(path, locale, tableKey, subTableKey, itemKey, &length, pErrorCode); } } if(U_SUCCESS(*pErrorCode)) { int32_t copyLength=uprv_min(length, destCapacity); if(copyLength>0 && s != NULL) { u_memcpy(dest, s, copyLength); } } else { /* no string from a resource bundle: convert the substitute */ length=(int32_t)uprv_strlen(substitute); u_charsToUChars(substitute, dest, uprv_min(length, destCapacity)); *pErrorCode=U_USING_DEFAULT_WARNING; } return u_terminateUChars(dest, destCapacity, length, pErrorCode); }
NumberingSystem* U_EXPORT2 NumberingSystem::createInstanceByName(const char *name, UErrorCode& status) { UResourceBundle *numberingSystemsInfo = NULL; UResourceBundle *nsTop, *nsCurrent; const UChar* description = NULL; int32_t radix = 10; int32_t algorithmic = 0; int32_t len; numberingSystemsInfo = ures_openDirect(NULL,gNumberingSystems, &status); nsCurrent = ures_getByKey(numberingSystemsInfo,gNumberingSystems,NULL,&status); nsTop = ures_getByKey(nsCurrent,name,NULL,&status); description = ures_getStringByKey(nsTop,gDesc,&len,&status); ures_getByKey(nsTop,gRadix,nsCurrent,&status); radix = ures_getInt(nsCurrent,&status); ures_getByKey(nsTop,gAlgorithmic,nsCurrent,&status); algorithmic = ures_getInt(nsCurrent,&status); UBool isAlgorithmic = ( algorithmic == 1 ); UnicodeString nsd; nsd.setTo(description); ures_close(nsCurrent); ures_close(nsTop); ures_close(numberingSystemsInfo); if (U_FAILURE(status)) { status = U_UNSUPPORTED_ERROR; return NULL; } NumberingSystem* ns = NumberingSystem::createInstance(radix,isAlgorithmic,nsd,status); ns->setName(name); return ns; }
NumberingSystem* U_EXPORT2 NumberingSystem::createInstance(const Locale & inLocale, UErrorCode& status) { if (U_FAILURE(status)) { return NULL; } char buffer[ULOC_KEYWORDS_CAPACITY]; int32_t count = inLocale.getKeywordValue("numbers",buffer, sizeof(buffer),status); if ( count > 0 ) { // @numbers keyword was specified in the locale buffer[count] = '\0'; // Make sure it is null terminated. return NumberingSystem::createInstanceByName(buffer,status); } else { // Find the default numbering system for this locale. UResourceBundle *resource = ures_open(NULL, inLocale.getName(), &status); UResourceBundle *numberElementsRes = ures_getByKey(resource,gNumberElements,NULL,&status); const UChar *defaultNSName = ures_getStringByKeyWithFallback(numberElementsRes, gDefault, &count, &status); ures_close(numberElementsRes); ures_close(resource); if (U_FAILURE(status)) { status = U_USING_FALLBACK_WARNING; NumberingSystem *ns = new NumberingSystem(); return ns; } if ( count > 0 && count < ULOC_KEYWORDS_CAPACITY ) { // Default numbering system found u_UCharsToChars(defaultNSName,buffer,count); buffer[count] = '\0'; // Make sure it is null terminated. return NumberingSystem::createInstanceByName(buffer,status); } else { status = U_USING_FALLBACK_WARNING; NumberingSystem *ns = new NumberingSystem(); return ns; } } }
TZEnumeration(const char* country) : map(NULL), len(0), pos(0) { if (!getOlsonMeta()) { return; } char key[] = {0, 0, 0, 0,0, 0, 0,0, 0, 0,0}; // e.g., "US", or "Default" for no country if (country) { uprv_strncat(key, country, 2); } else { uprv_strcpy(key, kDEFAULT); } UErrorCode ec = U_ZERO_ERROR; UResourceBundle *top = ures_openDirect(0, kZONEINFO, &ec); top = ures_getByKey(top, kREGIONS, top, &ec); // dereference 'Regions' section if (U_SUCCESS(ec)) { UResourceBundle res; ures_initStackObject(&res); ures_getByKey(top, key, &res, &ec); // The list of zones is a list of integers, from 0..n-1, // where n is the total number of system zones. const int32_t* v = ures_getIntVector(&res, &len, &ec); if (U_SUCCESS(ec)) { U_ASSERT(len > 0); map = (int32_t*)uprv_malloc(sizeof(int32_t) * len); if (map != 0) { for (uint16_t i=0; i<len; ++i) { U_ASSERT(v[i] >= 0 && v[i] < OLSON_ZONE_COUNT); map[i] = v[i]; } } } else { U_DEBUG_TZ_MSG(("Failed to load tz for region %s: %s\n", country, u_errorName(ec))); } ures_close(&res); } ures_close(top); }
RuleBasedNumberFormat::RuleBasedNumberFormat(URBNFRuleSetTag tag, const Locale& alocale, UErrorCode& status) : ruleSets(NULL) , ruleSetDescriptions(NULL) , numRuleSets(0) , defaultRuleSet(NULL) , locale(alocale) , collator(NULL) , decimalFormatSymbols(NULL) , lenient(FALSE) , lenientParseRules(NULL) , localizations(NULL) { if (U_FAILURE(status)) { return; } const char* rules_tag = "RBNFRules"; const char* fmt_tag = ""; switch (tag) { case URBNF_SPELLOUT: fmt_tag = "SpelloutRules"; break; case URBNF_ORDINAL: fmt_tag = "OrdinalRules"; break; case URBNF_DURATION: fmt_tag = "DurationRules"; break; case URBNF_NUMBERING_SYSTEM: fmt_tag = "NumberingSystemRules"; break; default: status = U_ILLEGAL_ARGUMENT_ERROR; return; } // TODO: read localization info from resource LocalizationInfo* locinfo = NULL; UResourceBundle* nfrb = ures_open(U_ICUDATA_RBNF, locale.getName(), &status); if (U_SUCCESS(status)) { setLocaleIDs(ures_getLocaleByType(nfrb, ULOC_VALID_LOCALE, &status), ures_getLocaleByType(nfrb, ULOC_ACTUAL_LOCALE, &status)); UResourceBundle* rbnfRules = ures_getByKeyWithFallback(nfrb, rules_tag, NULL, &status); if (U_FAILURE(status)) { ures_close(nfrb); } UResourceBundle* ruleSets = ures_getByKeyWithFallback(rbnfRules, fmt_tag, NULL, &status); if (U_FAILURE(status)) { ures_close(rbnfRules); ures_close(nfrb); return; } UnicodeString desc; while (ures_hasNext(ruleSets)) { desc.append(ures_getNextUnicodeString(ruleSets,NULL,&status)); } UParseError perror; init (desc, locinfo, perror, status); ures_close(ruleSets); ures_close(rbnfRules); } ures_close(nfrb); }
U_CAPI UMeasurementSystem U_EXPORT2 ulocdata_getMeasurementSystem(const char *localeID, UErrorCode *status){ UResourceBundle* bundle=NULL; UResourceBundle* measurement=NULL; UMeasurementSystem system = UMS_LIMIT; if(status == NULL || U_FAILURE(*status)){ return system; } bundle = measurementDataBundleForLocale(localeID, status); measurement = ures_getByKeyWithFallback(bundle, MEASUREMENT_SYSTEM, NULL, status); system = (UMeasurementSystem) ures_getInt(measurement, status); ures_close(bundle); ures_close(measurement); return system; }
static UBool getOlsonMeta(const UResourceBundle* top) { if (OLSON_ZONE_COUNT == 0) { UErrorCode ec = U_ZERO_ERROR; UResourceBundle res; ures_initStackObject(&res); ures_getByKey(top, kZONES, &res, &ec); if(U_SUCCESS(ec)) { OLSON_ZONE_COUNT = ures_getSize(&res); U_DEBUG_TZ_MSG(("OZC%d\n",OLSON_ZONE_COUNT)); } ures_close(&res); } return (OLSON_ZONE_COUNT > 0); }
static jobjectArray getAmPmMarkers(JNIEnv *env, UResourceBundle *gregorian) { jobjectArray amPmMarkers; jstring pmU, amU; UErrorCode status = U_ZERO_ERROR; UResourceBundle *gregorianElems; gregorianElems = ures_getByKey(gregorian, "AmPmMarkers", NULL, &status); if(U_FAILURE(status)) { return NULL; } int lengthAm, lengthPm; ures_resetIterator(gregorianElems); const jchar* am = ures_getStringByIndex(gregorianElems, 0, &lengthAm, &status); const jchar* pm = ures_getStringByIndex(gregorianElems, 1, &lengthPm, &status); if(U_FAILURE(status)) { ures_close(gregorianElems); return NULL; } amPmMarkers = env->NewObjectArray(2, string_class, NULL); amU = env->NewString(am, lengthAm); env->SetObjectArrayElement(amPmMarkers, 0, amU); env->DeleteLocalRef(amU); pmU = env->NewString(pm, lengthPm); env->SetObjectArrayElement(amPmMarkers, 1, pmU); env->DeleteLocalRef(pmU); ures_close(gregorianElems); return amPmMarkers; }
const CompactTrieDictionary * ICULanguageBreakFactory::loadDictionaryFor(UScriptCode script, int32_t /*breakType*/) { UErrorCode status = U_ZERO_ERROR; // Open root from brkitr tree. char dictnbuff[256]; char ext[4]={'\0'}; UResourceBundle *b = ures_open(U_ICUDATA_BRKITR, "", &status); b = ures_getByKeyWithFallback(b, "dictionaries", b, &status); b = ures_getByKeyWithFallback(b, uscript_getShortName(script), b, &status); int32_t dictnlength = 0; const UChar *dictfname = ures_getString(b, &dictnlength, &status); if (U_SUCCESS(status) && (size_t)dictnlength >= sizeof(dictnbuff)) { dictnlength = 0; status = U_BUFFER_OVERFLOW_ERROR; } if (U_SUCCESS(status) && dictfname) { UChar* extStart=u_strchr(dictfname, 0x002e); int len = 0; if(extStart!=NULL){ len = extStart-dictfname; u_UCharsToChars(extStart+1, ext, sizeof(ext)); // nul terminates the buff u_UCharsToChars(dictfname, dictnbuff, len); } dictnbuff[len]=0; // nul terminate } ures_close(b); UDataMemory *file = udata_open(U_ICUDATA_BRKITR, ext, dictnbuff, &status); if (U_SUCCESS(status)) { const CompactTrieDictionary *dict = new CompactTrieDictionary( file, status); if (U_SUCCESS(status) && dict == NULL) { status = U_MEMORY_ALLOCATION_ERROR; } if (U_FAILURE(status)) { delete dict; dict = NULL; } return dict; } else if (dictfname != NULL){ //create dummy dict if dictionary filename not valid UChar c = 0x0020; status = U_ZERO_ERROR; MutableTrieDictionary *mtd = new MutableTrieDictionary(c, status, TRUE); mtd->addWord(&c, 1, status, 1); return new CompactTrieDictionary(*mtd, status); } return NULL; }
TZNames* TZNames::createInstance(UResourceBundle* rb, const char* key, const UnicodeString& tzID) { if (rb == NULL || key == NULL || *key == 0) { return NULL; } const UChar** names = loadData(rb, key); const UChar* locationName = NULL; UChar* locationNameOwned = NULL; UErrorCode status = U_ZERO_ERROR; int32_t len = 0; UResourceBundle* table = ures_getByKeyWithFallback(rb, key, NULL, &status); locationName = ures_getStringByKeyWithFallback(table, gEcTag, &len, &status); // ignore missing resource here status = U_ZERO_ERROR; ures_close(table); if (locationName == NULL) { UnicodeString tmpName; int32_t tmpNameLen = 0; TimeZoneNamesImpl::getDefaultExemplarLocationName(tzID, tmpName); tmpNameLen = tmpName.length(); if (tmpNameLen > 0) { locationNameOwned = (UChar*) uprv_malloc(sizeof(UChar) * (tmpNameLen + 1)); if (locationNameOwned) { tmpName.extract(locationNameOwned, tmpNameLen + 1, status); locationName = locationNameOwned; } } } TZNames* tznames = NULL; if (locationName != NULL || names != NULL) { tznames = new TZNames(names); if (tznames == NULL) { if (locationNameOwned) { uprv_free(locationNameOwned); } } tznames->fLocationName = locationName; tznames->fLocationNameOwned = locationNameOwned; } return tznames; }
static ListFormatInternal* loadListFormatInternal( const Locale& locale, const char * style, UErrorCode& errorCode) { UResourceBundle* rb = ures_open(NULL, locale.getName(), &errorCode); if (U_FAILURE(errorCode)) { ures_close(rb); return NULL; } rb = ures_getByKeyWithFallback(rb, "listPattern", rb, &errorCode); rb = ures_getByKeyWithFallback(rb, style, rb, &errorCode); // TODO(Travis Keep): This is a hack until fallbacks can be added for // listPattern/duration and listPattern/duration-narrow in CLDR. if (errorCode == U_MISSING_RESOURCE_ERROR) { errorCode = U_ZERO_ERROR; rb = ures_getByKeyWithFallback(rb, "standard", rb, &errorCode); } if (U_FAILURE(errorCode)) { ures_close(rb); return NULL; } UnicodeString two, start, middle, end; getStringByKey(rb, "2", two, errorCode); getStringByKey(rb, "start", start, errorCode); getStringByKey(rb, "middle", middle, errorCode); getStringByKey(rb, "end", end, errorCode); ures_close(rb); if (U_FAILURE(errorCode)) { return NULL; } ListFormatInternal* result = new ListFormatInternal(two, start, middle, end); if (result == NULL) { errorCode = U_MEMORY_ALLOCATION_ERROR; return NULL; } return result; }
U_CAPI void U_EXPORT2 u_getDataVersion(UVersionInfo dataVersionFillin, UErrorCode *status) { UResourceBundle *icudatares = NULL; if (U_FAILURE(*status)) { return; } if (dataVersionFillin != NULL) { icudatares = ures_openDirect(NULL, U_ICU_VERSION_BUNDLE , status); if (U_SUCCESS(*status)) { ures_getVersionByKey(icudatares, U_ICU_DATA_KEY, dataVersionFillin, status); } ures_close(icudatares); } }
UnicodeString& TimeZone::dereferOlsonLink(const UnicodeString& linkTo, UnicodeString& linkFrom) { UErrorCode ec = U_ZERO_ERROR; linkFrom.remove(); UResourceBundle *top = ures_openDirect(0, kZONEINFO, &ec); UResourceBundle *res = getZoneByName(top, linkTo, NULL, ec); if (U_SUCCESS(ec)) { if (ures_getSize(res) == 1) { int32_t deref = ures_getInt(res, &ec); UResourceBundle *nres = ures_getByKey(top, kNAMES, NULL, &ec); // dereference Names section int32_t len; const UChar* tmp = ures_getStringByIndex(nres, deref, &len, &ec); if (U_SUCCESS(ec)) { linkFrom.setTo(tmp, len); } ures_close(nres); } else { linkFrom.setTo(linkTo); } } ures_close(res); ures_close(top); return linkFrom; }
void TimeZoneNamesImpl::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; } }
UBool hasCollationElements(const char *locName) { UErrorCode status = U_ZERO_ERROR; UResourceBundle *loc = ures_open(U_ICUDATA_NAME U_TREE_SEPARATOR_STRING "coll", locName, &status);; if(U_SUCCESS(status)) { status = U_ZERO_ERROR; loc = ures_getByKey(loc, "collations", loc, &status); ures_close(loc); if(status == U_ZERO_ERROR) { /* do the test - there are real elements */ return TRUE; } } return FALSE; }
UBool getID(int32_t i) { UErrorCode ec = U_ZERO_ERROR; int32_t idLen = 0; const UChar* id = NULL; UResourceBundle *top = ures_openDirect(0, kZONEINFO, &ec); top = ures_getByKey(top, kNAMES, top, &ec); // dereference Zones section id = ures_getStringByIndex(top, i, &idLen, &ec); if(U_FAILURE(ec)) { unistr.truncate(0); } else { unistr.fastCopyFrom(UnicodeString(TRUE, id, idLen)); } ures_close(top); return U_SUCCESS(ec); }
UnicodeString& U_EXPORT2 ZoneMeta::getZoneIdByMetazone(const UnicodeString &mzid, const UnicodeString ®ion, UnicodeString &result) { UErrorCode status = U_ZERO_ERROR; const UChar *tzid = NULL; int32_t tzidLen = 0; char keyBuf[ZID_KEY_MAX + 1]; int32_t keyLen = 0; if (mzid.isBogus() || mzid.length() > ZID_KEY_MAX) { result.setToBogus(); return result; } keyLen = mzid.extract(0, mzid.length(), keyBuf, ZID_KEY_MAX + 1, US_INV); keyBuf[keyLen] = 0; UResourceBundle *rb = ures_openDirect(NULL, gMetaZones, &status); ures_getByKey(rb, gMapTimezonesTag, rb, &status); ures_getByKey(rb, keyBuf, rb, &status); if (U_SUCCESS(status)) { // check region mapping if (region.length() == 2 || region.length() == 3) { keyLen = region.extract(0, region.length(), keyBuf, ZID_KEY_MAX + 1, US_INV); keyBuf[keyLen] = 0; tzid = ures_getStringByKey(rb, keyBuf, &tzidLen, &status); if (status == U_MISSING_RESOURCE_ERROR) { status = U_ZERO_ERROR; } } if (U_SUCCESS(status) && tzid == NULL) { // try "001" tzid = ures_getStringByKey(rb, gWorldTag, &tzidLen, &status); } } ures_close(rb); if (tzid == NULL) { result.setToBogus(); } else { result.setTo(tzid, tzidLen); } return result; }
ResourceBundle& ResourceBundle::operator=(const ResourceBundle& other) { if(this == &other) { return *this; } if(fResource != 0) { ures_close(fResource); fResource = NULL; } UErrorCode status = U_ZERO_ERROR; if (other.fResource) { fResource = ures_copyResb(0, other.fResource, &status); } else { /* Copying a bad resource bundle */ fResource = NULL; } return *this; }
UBool RBTestData::nextCase(const DataMap *& nextCase, UErrorCode &status) { UErrorCode intStatus = U_ZERO_ERROR; UResourceBundle *currCase = ures_getByIndex(fCases, fCurrentCase++, NULL, &intStatus); if(U_SUCCESS(intStatus)) { if(fCurrCase == NULL) { fCurrCase = new RBDataMap(fHeaders, currCase, status); } else { ((RBDataMap *)fCurrCase)->init(fHeaders, currCase, status); } ures_close(currCase); nextCase = fCurrCase; return TRUE; } else { nextCase = NULL; return FALSE; } }
U_CAPI UMeasurementSystem U_EXPORT2 ulocdata_getMeasurementSystem(const char *localeID, UErrorCode *status){ UResourceBundle* measurement=NULL; UMeasurementSystem system = UMS_LIMIT; if(status == NULL || U_FAILURE(*status)){ return system; } measurement = measurementTypeBundleForLocale(localeID, MEASUREMENT_SYSTEM, status); system = (UMeasurementSystem) ures_getInt(measurement, status); ures_close(measurement); return system; }