UDate EthiopicCalendar::defaultCenturyStart() const { // lazy-evaluate systemDefaultCenturyStart umtx_initOnce(gSystemDefaultCenturyInit, &initializeSystemDefaultCentury); return gSystemDefaultCenturyStart; }
int32_t CopticCalendar::defaultCenturyStartYear() const { // lazy-evaluate systemDefaultCenturyStart umtx_initOnce(gSystemDefaultCenturyInit, &initializeSystemDefaultCentury); return gSystemDefaultCenturyStartYear; }
int32_t ChineseCalendar::internalGetDefaultCenturyStartYear() const { // lazy-evaluate systemDefaultCenturyStartYear umtx_initOnce(gSystemDefaultCenturyInitOnce, &initializeSystemDefaultCentury); return gSystemDefaultCenturyStartYear; }
U_CDECL_END UnicodeSet *SimpleDateFormatStaticSets::getIgnorables(UDateFormatField fieldIndex) { UErrorCode status = U_ZERO_ERROR; umtx_initOnce(gSimpleDateFormatStaticSetsInitOnce, &smpdtfmt_initSets, status); if (U_FAILURE(status)) { return NULL; } switch (fieldIndex) { case UDAT_YEAR_FIELD: case UDAT_MONTH_FIELD: case UDAT_DATE_FIELD: case UDAT_STANDALONE_DAY_FIELD: case UDAT_STANDALONE_MONTH_FIELD: return gStaticSets->fDateIgnorables; case UDAT_HOUR_OF_DAY1_FIELD: case UDAT_HOUR_OF_DAY0_FIELD: case UDAT_MINUTE_FIELD: case UDAT_SECOND_FIELD: case UDAT_HOUR1_FIELD: case UDAT_HOUR0_FIELD: return gStaticSets->fTimeIgnorables; default: return gStaticSets->fOtherIgnorables; } }
U_CAPI USpoofChecker * U_EXPORT2 uspoof_openFromSerialized(const void *data, int32_t length, int32_t *pActualLength, UErrorCode *status) { if (U_FAILURE(*status)) { return NULL; } umtx_initOnce(gSpoofInitOnce, &initializeStatics, *status); SpoofData *sd = new SpoofData(data, length, *status); SpoofImpl *si = new SpoofImpl(sd, *status); if (U_FAILURE(*status)) { delete sd; delete si; return NULL; } if (sd == NULL || si == NULL) { *status = U_MEMORY_ALLOCATION_ERROR; delete sd; delete si; return NULL; } if (pActualLength != NULL) { *pActualLength = sd->fRawData->fLength; } return reinterpret_cast<USpoofChecker *>(si); }
/** * Register two targets as being inverses of one another. For * example, calling registerSpecialInverse("NFC", "NFD", TRUE) causes * Transliterator to form the following inverse relationships: * * <pre>NFC => NFD * Any-NFC => Any-NFD * NFD => NFC * Any-NFD => Any-NFC</pre> * * (Without the special inverse registration, the inverse of NFC * would be NFC-Any.) Note that NFD is shorthand for Any-NFD, but * that the presence or absence of "Any-" is preserved. * * <p>The relationship is symmetrical; registering (a, b) is * equivalent to registering (b, a). * * <p>The relevant IDs must still be registered separately as * factories or classes. * * <p>Only the targets are specified. Special inverses always * have the form Any-Target1 <=> Any-Target2. The target should * have canonical casing (the casing desired to be produced when * an inverse is formed) and should contain no whitespace or other * extraneous characters. * * @param target the target against which to register the inverse * @param inverseTarget the inverse of target, that is * Any-target.getInverse() => Any-inverseTarget * @param bidirectional if TRUE, register the reverse relation * as well, that is, Any-inverseTarget.getInverse() => Any-target */ void TransliteratorIDParser::registerSpecialInverse(const UnicodeString& target, const UnicodeString& inverseTarget, UBool bidirectional, UErrorCode &status) { umtx_initOnce(gSpecialInversesInitOnce, init, status); if (U_FAILURE(status)) { return; } // If target == inverseTarget then force bidirectional => FALSE if (bidirectional && 0==target.caseCompare(inverseTarget, U_FOLD_CASE_DEFAULT)) { bidirectional = FALSE; } Mutex lock(&LOCK); UnicodeString *tempus = new UnicodeString(inverseTarget); // Used for null pointer check before usage. if (tempus == NULL) { status = U_MEMORY_ALLOCATION_ERROR; return; } SPECIAL_INVERSES->put(target, tempus, status); if (bidirectional) { tempus = new UnicodeString(target); if (tempus == NULL) { status = U_MEMORY_ALLOCATION_ERROR; return; } SPECIAL_INVERSES->put(inverseTarget, tempus, status); } }
/** * Returns an enumeration over the IDs of all the regions that are children of this region anywhere in the region * hierarchy and match the given type. This API may return an empty enumeration if this region doesn't have any * sub-regions that match the given type. For example, calling this method with region "150" (Europe) and type * "URGN_TERRITORY" returns a set containing all the territories in Europe ( "FR" (France) - "IT" (Italy) - "DE" (Germany) etc. ) */ StringEnumeration* Region::getContainedRegions( URegionType type, UErrorCode &status ) const { umtx_initOnce(gRegionDataInitOnce, &loadRegionData, status); // returns immediately if U_FAILURE(status) if (U_FAILURE(status)) { return NULL; } UVector *result = new UVector(NULL, uhash_compareChars, status); StringEnumeration *cr = getContainedRegions(status); for ( int32_t i = 0 ; i < cr->count(status) ; i++ ) { const char *id = cr->next(NULL,status); const Region *r = Region::getInstance(id,status); if ( r->getType() == type ) { result->addElement((void *)&r->idStr,status); } else { StringEnumeration *children = r->getContainedRegions(type, status); for ( int32_t j = 0 ; j < children->count(status) ; j++ ) { const char *id2 = children->next(NULL,status); const Region *r2 = Region::getInstance(id2,status); result->addElement((void *)&r2->idStr,status); } delete children; } } delete cr; StringEnumeration* resultEnumeration = new RegionNameEnumeration(result,status); delete result; return resultEnumeration; }
const UChar* ZoneMeta::findMetaZoneID(const UnicodeString& mzid) { umtx_initOnce(gMetaZoneIDsInitOnce, &initAvailableMetaZoneIDs); if (gMetaZoneIDTable == NULL) { return NULL; } return (const UChar*)uhash_get(gMetaZoneIDTable, &mzid); }
/** * For deprecated regions, return an enumeration over the IDs of the regions that are the preferred replacement * regions for this region. Returns NULL for a non-deprecated region. For example, calling this method with region * "SU" (Soviet Union) would return a list of the regions containing "RU" (Russia), "AM" (Armenia), "AZ" (Azerbaijan), etc... */ StringEnumeration* Region::getPreferredValues(UErrorCode &status) const { umtx_initOnce(gRegionDataInitOnce, &loadRegionData, status); // returns immediately if U_FAILURE(status) if (U_FAILURE(status) || type != URGN_DEPRECATED) { return NULL; } return new RegionNameEnumeration(preferredValues,status); }
UnifiedCache *UnifiedCache::getInstance(UErrorCode &status) { umtx_initOnce(gCacheInitOnce, &cacheInit, status); if (U_FAILURE(status)) { return NULL; } U_ASSERT(gCache != NULL); return gCache; }
/** * Return an enumeration over the IDs of all the regions that are immediate children of this region in the * region hierarchy. These returned regions could be either macro regions, territories, or a mixture of the two, * depending on the containment data as defined in CLDR. This API may return NULL if this region doesn't have * any sub-regions. For example, calling this method with region "150" (Europe) returns an enumeration containing * the various sub regions of Europe - "039" (Southern Europe) - "151" (Eastern Europe) - "154" (Northern Europe) * and "155" (Western Europe). */ StringEnumeration* Region::getContainedRegions(UErrorCode &status) const { umtx_initOnce(gRegionDataInitOnce, &loadRegionData, status); // returns immediately if U_FAILURE(status) if (U_FAILURE(status)) { return NULL; } return new RegionNameEnumeration(containedRegions,status); }
/** * Returns an enumeration over the IDs of all known regions that match the given type. */ StringEnumeration* U_EXPORT2 Region::getAvailable(URegionType type, UErrorCode &status) { umtx_initOnce(gRegionDataInitOnce, &loadRegionData, status); // returns immediately if U_FAILURE(status) if (U_FAILURE(status)) { return NULL; } return new RegionNameEnumeration(availableRegions[type],status); }
U_CDECL_END const Norm2AllModes * Norm2AllModes::getNFKCInstance(UErrorCode &errorCode) { if(U_FAILURE(errorCode)) { return NULL; } umtx_initOnce(nfkcInitOnce, &initSingletons, "nfkc", errorCode); return nfkcSingleton; }
U_CDECL_END #if !NORM2_HARDCODE_NFC_DATA const Norm2AllModes * Norm2AllModes::getNFCInstance(UErrorCode &errorCode) { if(U_FAILURE(errorCode)) { return NULL; } umtx_initOnce(nfcInitOnce, &initSingletons, "nfc", errorCode); return nfcSingleton; }
static UBool init() { UErrorCode sts = U_ZERO_ERROR; umtx_initOnce(gLocExtKeyMapInitOnce, &initFromResourceBundle, sts); if (U_FAILURE(sts)) { return FALSE; } return TRUE; }
U_CAPI void U_EXPORT2 umtx_lock(UMutex *mutex) { if (mutex == NULL) { mutex = &globalMutex; } CRITICAL_SECTION *cs = &mutex->fCS; umtx_initOnce(mutex->fInitOnce, winMutexInit, cs); EnterCriticalSection(cs); }
int32_t EthiopicCalendar::defaultCenturyStartYear() const { // lazy-evaluate systemDefaultCenturyStartYear umtx_initOnce(gSystemDefaultCenturyInit, &initializeSystemDefaultCentury); if (isAmeteAlemEra()) { return gSystemDefaultCenturyStartYear + AMETE_MIHRET_DELTA; } return gSystemDefaultCenturyStartYear; }
/** * Return a pointer to the region that geographically contains this region and matches the given type, * moving multiple steps up the containment chain if necessary. Returns NULL if no containing region can be found * that matches the given type. Note: The URegionTypes = "URGN_GROUPING", "URGN_DEPRECATED", or "URGN_UNKNOWN" * are not appropriate for use in this API. NULL will be returned in this case. For example, calling this method * with region "IT" (Italy) for type "URGN_CONTINENT" returns the region "150" ( Europe ). */ const Region* Region::getContainingRegion(URegionType type) const { UErrorCode status = U_ZERO_ERROR; umtx_initOnce(gRegionDataInitOnce, &loadRegionData, status); if ( containingRegion == NULL ) { return NULL; } return ( containingRegion->type == type )? containingRegion: containingRegion->getContainingRegion(type); }
U_NAMESPACE_END U_NAMESPACE_USE /* * ICU Initialization Function. Need not be called. */ U_CAPI void U_EXPORT2 u_init(UErrorCode *status) { UTRACE_ENTRY_OC(UTRACE_U_INIT); umtx_initOnce(gICUInitOnce, &initData, *status); UTRACE_EXIT_STATUS(*status); }
U_CAPI USpoofChecker * U_EXPORT2 uspoof_open(UErrorCode *status) { if (U_FAILURE(*status)) { return NULL; } umtx_initOnce(gSpoofInitOnce, &initializeStatics, *status); SpoofImpl *si = new SpoofImpl(SpoofData::getDefault(*status), *status); if (U_FAILURE(*status)) { delete si; si = NULL; } return reinterpret_cast<USpoofChecker *>(si); }
const DayPeriodRules *DayPeriodRules::getInstance(const Locale &locale, UErrorCode &errorCode) { umtx_initOnce(initOnce, DayPeriodRules::load, errorCode); // If the entire day period rules data doesn't conform to spec (even if the part we want // does), return NULL. if(U_FAILURE(errorCode)) { return NULL; } const char *localeCode = locale.getName(); char name[ULOC_FULLNAME_CAPACITY]; char parentName[ULOC_FULLNAME_CAPACITY]; if (uprv_strlen(localeCode) < ULOC_FULLNAME_CAPACITY) { uprv_strcpy(name, localeCode); // Treat empty string as root. if (*name == '\0') { uprv_strcpy(name, "root"); } } else { errorCode = U_BUFFER_OVERFLOW_ERROR; return NULL; } int32_t ruleSetNum = 0; // NB there is no rule set 0 and 0 is returned upon lookup failure. while (*name != '\0') { ruleSetNum = uhash_geti(data->localeToRuleSetNumMap, name); if (ruleSetNum == 0) { // name and parentName can't be the same pointer, so fill in parent then copy to child. uloc_getParent(name, parentName, ULOC_FULLNAME_CAPACITY, &errorCode); if (*parentName == '\0') { // Saves a lookup in the hash table. break; } uprv_strcpy(name, parentName); } else { break; } } if (ruleSetNum <= 0 || data->rules[ruleSetNum].getDayPeriodForHour(0) == DAYPERIOD_UNKNOWN) { // If day period for hour 0 is UNKNOWN then day period for all hours are UNKNOWN. // Data doesn't exist even with fallback. return NULL; } else { return &data->rules[ruleSetNum]; } }
U_CAPI USpoofChecker * U_EXPORT2 uspoof_open(UErrorCode *status) { umtx_initOnce(gSpoofInitStaticsOnce, &initializeStatics, *status); if (U_FAILURE(*status)) { return NULL; } SpoofImpl *si = new SpoofImpl(*status); if (si == NULL) { *status = U_MEMORY_ALLOCATION_ERROR; return NULL; } if (U_FAILURE(*status)) { delete si; return NULL; } return si->asUSpoofChecker(); }
U_CAPI USpoofChecker * U_EXPORT2 uspoof_openFromSerialized(const void *data, int32_t length, int32_t *pActualLength, UErrorCode *status) { if (U_FAILURE(*status)) { return NULL; } if (data == NULL) { *status = U_ILLEGAL_ARGUMENT_ERROR; return NULL; } umtx_initOnce(gSpoofInitStaticsOnce, &initializeStatics, *status); if (U_FAILURE(*status)) { return NULL; } SpoofData *sd = new SpoofData(data, length, *status); if (sd == NULL) { *status = U_MEMORY_ALLOCATION_ERROR; return NULL; } if (U_FAILURE(*status)) { delete sd; return NULL; } SpoofImpl *si = new SpoofImpl(sd, *status); if (si == NULL) { *status = U_MEMORY_ALLOCATION_ERROR; delete sd; // explicit delete as the destructor for si won't be called. return NULL; } if (U_FAILURE(*status)) { delete si; // no delete for sd, as the si destructor will delete it. return NULL; } if (pActualLength != NULL) { *pActualLength = sd->size(); } return si->asUSpoofChecker(); }
const UnicodeSet *DecimalFormatStaticSets::getSimilarDecimals(UChar32 decimal, UBool strictParse) { UErrorCode status = U_ZERO_ERROR; umtx_initOnce(gStaticSetsInitOnce, initSets, status); if (U_FAILURE(status)) { return NULL; } if (gStaticSets->fDotEquivalents->contains(decimal)) { return strictParse ? gStaticSets->fStrictDotEquivalents : gStaticSets->fDotEquivalents; } if (gStaticSets->fCommaEquivalents->contains(decimal)) { return strictParse ? gStaticSets->fStrictCommaEquivalents : gStaticSets->fCommaEquivalents; } // if there is no match, return NULL return NULL; }
/** * Returns a pointer to a Region using the given numeric region code. If the numeric region code is not recognized, * the appropriate error code will be set ( U_ILLEGAL_ARGUMENT_ERROR ). */ const Region* U_EXPORT2 Region::getInstance (int32_t code, UErrorCode &status) { umtx_initOnce(gRegionDataInitOnce, &loadRegionData, status); if (U_FAILURE(status)) { return NULL; } Region *r = (Region *)uhash_iget(numericCodeMap,code); if ( !r ) { // Just in case there's an alias that's numeric, try to find it. UnicodeString pat = UNICODE_STRING_SIMPLE("0"); LocalPointer<DecimalFormat> df(new DecimalFormat(pat,status), status); if( U_FAILURE(status) ) { return NULL; } UnicodeString id; id.remove(); FieldPosition posIter; df->format(code,id, posIter, status); r = (Region *)uhash_get(regionAliases,&id); } if( U_FAILURE(status) ) { return NULL; } if ( !r ) { status = U_ILLEGAL_ARGUMENT_ERROR; return NULL; } if ( r->type == URGN_DEPRECATED && r->preferredValues->size() == 1) { StringEnumeration *pv = r->getPreferredValues(status); pv->reset(status); const UnicodeString *ustr = pv->snext(status); r = (Region *)uhash_get(regionIDMap,(void *)ustr); delete pv; } return r; }
U_CDECL_END double DigitList::decimalStrToDouble(char *decstr, char **end) { umtx_initOnce(gCLocaleInitOnce, &initCLocale); #if U_USE_STRTOD_L return strtod_l(decstr, end, gCLocale); #else char *decimalPt = strchr(decstr, '.'); if (decimalPt) { // We need to know the decimal separator character that will be used with strtod(). // Depends on the C runtime global locale. // Most commonly is '.' char rep[MAX_DIGITS]; sprintf(rep, "%+1.1f", 1.0); *decimalPt = rep[2]; } return uprv_strtod(decstr, end); #endif }
/** * Given a Specs object, return a SingleID representing the * special inverse of that ID. If there is no special inverse * then return NULL. * @return a SingleID or NULL. Returned object always has * 'filter' field of NULL. */ TransliteratorIDParser::SingleID* TransliteratorIDParser::specsToSpecialInverse(const Specs& specs, UErrorCode &status) { if (0!=specs.source.caseCompare(ANY, 3, U_FOLD_CASE_DEFAULT)) { return NULL; } umtx_initOnce(gSpecialInversesInitOnce, init, status); if (U_FAILURE(status)) { return NULL; } UnicodeString* inverseTarget; umtx_lock(&LOCK); inverseTarget = (UnicodeString*) SPECIAL_INVERSES->get(specs.target); umtx_unlock(&LOCK); if (inverseTarget != NULL) { // If the original ID contained "Any-" then make the // special inverse "Any-Foo"; otherwise make it "Foo". // So "Any-NFC" => "Any-NFD" but "NFC" => "NFD". UnicodeString buf; if (specs.filter.length() != 0) { buf.append(specs.filter); } if (specs.sawSource) { buf.append(ANY, 3).append(TARGET_SEP); } buf.append(*inverseTarget); UnicodeString basicID(TRUE, ANY, 3); basicID.append(TARGET_SEP).append(*inverseTarget); if (specs.variant.length() != 0) { buf.append(VARIANT_SEP).append(specs.variant); basicID.append(VARIANT_SEP).append(specs.variant); } return new SingleID(buf, basicID); } return NULL; }
const GenderInfo* GenderInfo::getInstance(const Locale& locale, UErrorCode& status) { // Make sure our cache exists. umtx_initOnce(gGenderInitOnce, &GenderInfo_initCache, status); if (U_FAILURE(status)) { return NULL; } const GenderInfo* result = NULL; const char* key = locale.getName(); { Mutex lock(&gGenderMetaLock); result = (const GenderInfo*) uhash_get(gGenderInfoCache, key); } if (result) { return result; } // On cache miss, try to create GenderInfo from CLDR data result = loadInstance(locale, status); if (U_FAILURE(status)) { return NULL; } // Try to put our GenderInfo object in cache. If there is a race condition, // favor the GenderInfo object that is already in the cache. { Mutex lock(&gGenderMetaLock); GenderInfo* temp = (GenderInfo*) uhash_get(gGenderInfoCache, key); if (temp) { result = temp; } else { uhash_put(gGenderInfoCache, uprv_strdup(key), (void*) result, &status); if (U_FAILURE(status)) { return NULL; } } } return result; }
/** * Returns true if this region contains the supplied other region anywhere in the region hierarchy. */ UBool Region::contains(const Region &other) const { UErrorCode status = U_ZERO_ERROR; umtx_initOnce(gRegionDataInitOnce, &loadRegionData, status); if (!containedRegions) { return FALSE; } if (containedRegions->contains((void *)&other.idStr)) { return TRUE; } else { for ( int32_t i = 0 ; i < containedRegions->size() ; i++ ) { UnicodeString *crStr = (UnicodeString *)containedRegions->elementAt(i); Region *cr = (Region *) uhash_get(regionIDMap,(void *)crStr); if ( cr && cr->contains(other) ) { return TRUE; } } } return FALSE; }
U_CDECL_END IdentifierInfo::IdentifierInfo(UErrorCode &status): fIdentifier(NULL), fRequiredScripts(NULL), fScriptSetSet(NULL), fCommonAmongAlternates(NULL), fNumerics(NULL), fIdentifierProfile(NULL) { umtx_initOnce(gIdentifierInfoInitOnce, &IdentifierInfo_init, status); if (U_FAILURE(status)) { return; } fIdentifier = new UnicodeString(); fRequiredScripts = new ScriptSet(); fScriptSetSet = uhash_open(uhash_hashScriptSet, uhash_compareScriptSet, NULL, &status); uhash_setKeyDeleter(fScriptSetSet, uhash_deleteScriptSet); fCommonAmongAlternates = new ScriptSet(); fNumerics = new UnicodeSet(); fIdentifierProfile = new UnicodeSet(0, 0x10FFFF); if (U_SUCCESS(status) && (fIdentifier == NULL || fRequiredScripts == NULL || fScriptSetSet == NULL || fCommonAmongAlternates == NULL || fNumerics == NULL || fIdentifierProfile == NULL)) { status = U_MEMORY_ALLOCATION_ERROR; } }