StringEnumeration* TimeZoneNamesImpl::getAvailableMetaZoneIDs(const UnicodeString& tzID, UErrorCode& status) const { if (U_FAILURE(status)) { return NULL; } const UVector* mappings = ZoneMeta::getMetazoneMappings(tzID); if (mappings == NULL) { return new MetaZoneIDsEnumeration(); } MetaZoneIDsEnumeration *senum = NULL; UVector* mzIDs = new UVector(NULL, uhash_compareUChars, status); if (mzIDs == NULL) { status = U_MEMORY_ALLOCATION_ERROR; } if (U_SUCCESS(status)) { U_ASSERT(mzIDs != NULL); for (int32_t i = 0; U_SUCCESS(status) && i < mappings->size(); i++) { OlsonToMetaMappingEntry *map = (OlsonToMetaMappingEntry *)mappings->elementAt(i); const UChar *mzID = map->mzid; if (!mzIDs->contains((void *)mzID)) { mzIDs->addElement((void *)mzID, status); } } if (U_SUCCESS(status)) { senum = new MetaZoneIDsEnumeration(mzIDs); } else { delete mzIDs; } } return senum; }
/** * Adopt the UnicodeString if not already contained. * Caller no longer owns the pointer in any case. * @return true if adopted successfully, false otherwise (error, or else duplicate) */ inline UBool adopt(UnicodeString *str, UErrorCode &status) { if(U_FAILURE(status) || contains(*str)) { delete str; return false; } else { sortedInsert(str, compareUnicodeString, status); if(U_FAILURE(status)) { delete str; return false; } return true; } }
UObject* create(const ICUServiceKey& key, const ICUService* /* service */, UErrorCode& status) const { if (U_FAILURE(status)) { return NULL; } UnicodeString temp; key.currentID(temp); if (U_SUCCESS(_status)) { if (_ids.contains(&temp)) { return new UnicodeString(_factoryID + temp); } } else { status = _status; } return NULL; }
UnicodeString& getDisplayName(const UnicodeString& id, const Locale& locale, UnicodeString& result) const { if (U_SUCCESS(_status) && _ids.contains((void*)&id)) { char buffer[128]; UErrorCode status = U_ZERO_ERROR; int32_t len = id.extract(buffer, sizeof(buffer), NULL, status); if (U_SUCCESS(status)) { if (len == sizeof(buffer)) { --len; } buffer[len] = 0; Locale loc = Locale::createFromName(buffer); loc.getDisplayName(locale, result); return result; } } result.setToBogus(); // shouldn't happen return result; }
/** * Register a source-target/variant in the specDAG. Variant may be * empty, but source and target must not be. If variant is empty then * the special variant NO_VARIANT is stored in slot zero of the * UVector of variants. */ void TransliteratorRegistry::registerSTV(const UnicodeString& source, const UnicodeString& target, const UnicodeString& variant) { // assert(source.length() > 0); // assert(target.length() > 0); UErrorCode status = U_ZERO_ERROR; Hashtable *targets = (Hashtable*) specDAG.get(source); if (targets == 0) { targets = new Hashtable(TRUE, status); if (U_FAILURE(status) || targets == 0) { return; } targets->setValueDeleter(uprv_deleteUObject); specDAG.put(source, targets, status); } UVector *variants = (UVector*) targets->get(target); if (variants == 0) { variants = new UVector(uprv_deleteUObject, uhash_compareCaselessUnicodeString, status); if (variants == 0) { return; } targets->put(target, variants, status); } // assert(NO_VARIANT == ""); // We add the variant string. If it is the special "no variant" // string, that is, the empty string, we add it at position zero. if (!variants->contains((void*) &variant)) { UnicodeString *tempus; // Used for null pointer check. if (variant.length() > 0) { tempus = new UnicodeString(variant); if (tempus != NULL) { variants->addElement(tempus, status); } } else { tempus = new UnicodeString(); // = NO_VARIANT if (tempus != NULL) { variants->insertElementAt(tempus, 0, status); } } } }
/** * Is this UnicodeSet contained? */ inline UBool contains(const UnicodeString& s) { return contains((void*) &s); }
void TimeUnitFormat::readFromCurrentLocale(UTimeUnitFormatStyle style, const char* key, const UVector& pluralCounts, UErrorCode& err) { if (U_FAILURE(err)) { return; } // fill timeUnitToCountToPatterns from resource file // err is used to indicate wrong status except missing resource. // status is an error code used in resource lookup. // status does not affect "err". UErrorCode status = U_ZERO_ERROR; UResourceBundle *rb, *unitsRes; rb = ures_open(U_ICUDATA_UNIT, getLocaleID(status), &status); unitsRes = ures_getByKey(rb, key, NULL, &status); unitsRes = ures_getByKey(unitsRes, "duration", unitsRes, &status); if (U_FAILURE(status)) { ures_close(unitsRes); ures_close(rb); return; } int32_t size = ures_getSize(unitsRes); for ( int32_t index = 0; index < size; ++index) { // resource of one time unit UResourceBundle* oneTimeUnit = ures_getByIndex(unitsRes, index, NULL, &status); if (U_SUCCESS(status)) { const char* timeUnitName = ures_getKey(oneTimeUnit); if (timeUnitName == NULL) { ures_close(oneTimeUnit); continue; } UResourceBundle* countsToPatternRB = ures_getByKey(unitsRes, timeUnitName, NULL, &status); if (countsToPatternRB == NULL || U_FAILURE(status)) { ures_close(countsToPatternRB); ures_close(oneTimeUnit); continue; } TimeUnit::UTimeUnitFields timeUnitField = TimeUnit::UTIMEUNIT_FIELD_COUNT; if ( uprv_strcmp(timeUnitName, gTimeUnitYear) == 0 ) { timeUnitField = TimeUnit::UTIMEUNIT_YEAR; } else if ( uprv_strcmp(timeUnitName, gTimeUnitMonth) == 0 ) { timeUnitField = TimeUnit::UTIMEUNIT_MONTH; } else if ( uprv_strcmp(timeUnitName, gTimeUnitDay) == 0 ) { timeUnitField = TimeUnit::UTIMEUNIT_DAY; } else if ( uprv_strcmp(timeUnitName, gTimeUnitHour) == 0 ) { timeUnitField = TimeUnit::UTIMEUNIT_HOUR; } else if ( uprv_strcmp(timeUnitName, gTimeUnitMinute) == 0 ) { timeUnitField = TimeUnit::UTIMEUNIT_MINUTE; } else if ( uprv_strcmp(timeUnitName, gTimeUnitSecond) == 0 ) { timeUnitField = TimeUnit::UTIMEUNIT_SECOND; } else if ( uprv_strcmp(timeUnitName, gTimeUnitWeek) == 0 ) { timeUnitField = TimeUnit::UTIMEUNIT_WEEK; } else { ures_close(countsToPatternRB); ures_close(oneTimeUnit); continue; } Hashtable* countToPatterns = fTimeUnitToCountToPatterns[timeUnitField]; if (countToPatterns == NULL) { countToPatterns = initHash(err); if (U_FAILURE(err)) { ures_close(countsToPatternRB); ures_close(oneTimeUnit); delete countToPatterns; break; } } int32_t count = ures_getSize(countsToPatternRB); const char* pluralCount; for ( int32_t pluralIndex = 0; pluralIndex < count; ++pluralIndex) { // resource of count to pattern UnicodeString pattern = ures_getNextUnicodeString(countsToPatternRB, &pluralCount, &status); if (U_FAILURE(status)) { continue; } UnicodeString pluralCountUniStr(pluralCount, -1, US_INV); if (!pluralCounts.contains(&pluralCountUniStr)) { continue; } MessageFormat* messageFormat = new MessageFormat(pattern, getLocale(err), err); if ( U_SUCCESS(err) ) { MessageFormat** formatters = (MessageFormat**)countToPatterns->get(pluralCountUniStr); if (formatters == NULL) { formatters = (MessageFormat**)uprv_malloc(UTMUTFMT_FORMAT_STYLE_COUNT*sizeof(MessageFormat*)); formatters[UTMUTFMT_FULL_STYLE] = NULL; formatters[UTMUTFMT_ABBREVIATED_STYLE] = NULL; countToPatterns->put(pluralCountUniStr, formatters, err); if (U_FAILURE(err)) { uprv_free(formatters); } } if (U_SUCCESS(err)) { //delete formatters[style]; formatters[style] = messageFormat; } } if (U_FAILURE(err)) { ures_close(countsToPatternRB); ures_close(oneTimeUnit); ures_close(unitsRes); ures_close(rb); delete messageFormat; delete countToPatterns; return; } } if (fTimeUnitToCountToPatterns[timeUnitField] == NULL) { fTimeUnitToCountToPatterns[timeUnitField] = countToPatterns; } ures_close(countsToPatternRB); } ures_close(oneTimeUnit); } ures_close(unitsRes); ures_close(rb); }