/*
*******************************************************************************
-* Copyright (C) 2013, International Business Machines Corporation and
+* Copyright (C) 2014-2015, International Business Machines Corporation and
* others. All Rights Reserved.
*******************************************************************************
*
#include "unicode/decimfmt.h"
#include "ucln_in.h"
#include "cstring.h"
+#include "mutex.h"
#include "uhash.h"
#include "umutex.h"
#include "uresimp.h"
U_NAMESPACE_BEGIN
-static UMutex gRegionDataLock = U_MUTEX_INITIALIZER;
-static UBool regionDataIsLoaded = false;
+static UInitOnce gRegionDataInitOnce = U_INITONCE_INITIALIZER;
static UVector* availableRegions[URGN_LIMIT];
-static UHashtable *regionAliases;
-static UHashtable *regionIDMap;
-static UHashtable *numericCodeMap;
+static UHashtable *regionAliases = NULL;
+static UHashtable *regionIDMap = NULL;
+static UHashtable *numericCodeMap = NULL;
static const UChar UNKNOWN_REGION_ID [] = { 0x5A, 0x5A, 0 }; /* "ZZ" */
static const UChar OUTLYING_OCEANIA_REGION_ID [] = { 0x51, 0x4F, 0 }; /* "QO" */
* If the region data has already loaded, then this method simply returns without doing
* anything meaningful.
*/
-void Region::loadRegionData() {
+void Region::loadRegionData(UErrorCode &status) {
+ // Construct service objs first
+ LocalUHashtablePointer newRegionIDMap(uhash_open(uhash_hashUnicodeString, uhash_compareUnicodeString, NULL, &status));
+ LocalUHashtablePointer newNumericCodeMap(uhash_open(uhash_hashLong,uhash_compareLong,NULL,&status));
+ LocalUHashtablePointer newRegionAliases(uhash_open(uhash_hashUnicodeString,uhash_compareUnicodeString,NULL,&status));
- if (regionDataIsLoaded) {
- return;
- }
+ LocalPointer<DecimalFormat> df(new DecimalFormat(status), status);
- umtx_lock(&gRegionDataLock);
+ LocalPointer<UVector> continents(new UVector(uprv_deleteUObject, uhash_compareUnicodeString, status), status);
+ LocalPointer<UVector> groupings(new UVector(uprv_deleteUObject, uhash_compareUnicodeString, status), status);
- if (regionDataIsLoaded) { // In case another thread gets to it before we do...
- umtx_unlock(&gRegionDataLock);
- return;
- }
+ LocalUResourceBundlePointer metadata(ures_openDirect(NULL,"metadata",&status));
+ LocalUResourceBundlePointer regionCodes(ures_getByKey(metadata.getAlias(),"regionCodes",NULL,&status));
+ LocalUResourceBundlePointer metadataAlias(ures_getByKey(metadata.getAlias(),"alias",NULL,&status));
+ LocalUResourceBundlePointer territoryAlias(ures_getByKey(metadataAlias.getAlias(),"territory",NULL,&status));
+ LocalUResourceBundlePointer supplementalData(ures_openDirect(NULL,"supplementalData",&status));
+ LocalUResourceBundlePointer codeMappings(ures_getByKey(supplementalData.getAlias(),"codeMappings",NULL,&status));
- UErrorCode status = U_ZERO_ERROR;
+ LocalUResourceBundlePointer territoryContainment(ures_getByKey(supplementalData.getAlias(),"territoryContainment",NULL,&status));
+ LocalUResourceBundlePointer worldContainment(ures_getByKey(territoryContainment.getAlias(),"001",NULL,&status));
+ LocalUResourceBundlePointer groupingContainment(ures_getByKey(territoryContainment.getAlias(),"grouping",NULL,&status));
- UResourceBundle* regionCodes = NULL;
- UResourceBundle* territoryAlias = NULL;
- UResourceBundle* codeMappings = NULL;
- UResourceBundle* worldContainment = NULL;
- UResourceBundle* territoryContainment = NULL;
- UResourceBundle* groupingContainment = NULL;
-
- DecimalFormat *df = new DecimalFormat(status);
if (U_FAILURE(status)) {
- umtx_unlock(&gRegionDataLock);
return;
}
- df->setParseIntegerOnly(TRUE);
-
- regionIDMap = uhash_open(uhash_hashUnicodeString,uhash_compareUnicodeString,NULL,&status);
- uhash_setValueDeleter(regionIDMap, deleteRegion);
-
- numericCodeMap = uhash_open(uhash_hashLong,uhash_compareLong,NULL,&status);
- regionAliases = uhash_open(uhash_hashUnicodeString,uhash_compareUnicodeString,NULL,&status);
- uhash_setKeyDeleter(regionAliases,uprv_deleteUObject);
-
- UResourceBundle *rb = ures_openDirect(NULL,"metadata",&status);
- regionCodes = ures_getByKey(rb,"regionCodes",NULL,&status);
- territoryAlias = ures_getByKey(rb,"territoryAlias",NULL,&status);
-
- UResourceBundle *rb2 = ures_openDirect(NULL,"supplementalData",&status);
- codeMappings = ures_getByKey(rb2,"codeMappings",NULL,&status);
-
- territoryContainment = ures_getByKey(rb2,"territoryContainment",NULL,&status);
- worldContainment = ures_getByKey(territoryContainment,"001",NULL,&status);
- groupingContainment = ures_getByKey(territoryContainment,"grouping",NULL,&status);
-
- UVector *continents = new UVector(uprv_deleteUObject, uhash_compareUnicodeString, status);
+ // now, initialize
+ df->setParseIntegerOnly(TRUE);
+ uhash_setValueDeleter(newRegionIDMap.getAlias(), deleteRegion); // regionIDMap owns objs
+ uhash_setKeyDeleter(newRegionAliases.getAlias(), uprv_deleteUObject); // regionAliases owns the string keys
- while ( ures_hasNext(worldContainment) ) {
- UnicodeString *continentName = new UnicodeString(ures_getNextUnicodeString(worldContainment,NULL,&status));
+ while ( ures_hasNext(worldContainment.getAlias()) ) {
+ UnicodeString *continentName = new UnicodeString(ures_getNextUnicodeString(worldContainment.getAlias(),NULL,&status));
continents->addElement(continentName,status);
}
- UVector *groupings = new UVector(uprv_deleteUObject, uhash_compareUnicodeString, status);
- while ( ures_hasNext(groupingContainment) ) {
- UnicodeString *groupingName = new UnicodeString(ures_getNextUnicodeString(groupingContainment,NULL,&status));
+ while ( ures_hasNext(groupingContainment.getAlias()) ) {
+ UnicodeString *groupingName = new UnicodeString(ures_getNextUnicodeString(groupingContainment.getAlias(),NULL,&status));
groupings->addElement(groupingName,status);
}
- while ( ures_hasNext(regionCodes) ) {
- UnicodeString regionID = ures_getNextUnicodeString(regionCodes,NULL,&status);
- Region *r = new Region();
+ while ( ures_hasNext(regionCodes.getAlias()) ) {
+ UnicodeString regionID = ures_getNextUnicodeString(regionCodes.getAlias(), NULL, &status);
+ LocalPointer<Region> r(new Region(), status);
+ if ( U_FAILURE(status) ) {
+ return;
+ }
r->idStr = regionID;
r->idStr.extract(0,r->idStr.length(),r->id,sizeof(r->id),US_INV);
r->type = URGN_TERRITORY; // Only temporary - figure out the real type later once the aliases are known.
- uhash_put(regionIDMap,(void *)&(r->idStr),(void *)r,&status);
Formattable result;
UErrorCode ps = U_ZERO_ERROR;
df->parse(r->idStr,result,ps);
if ( U_SUCCESS(ps) ) {
r->code = result.getLong(); // Convert string to number
- uhash_iput(numericCodeMap,r->code,(void *)r,&status);
+ uhash_iput(newNumericCodeMap.getAlias(),r->code,(void *)(r.getAlias()),&status);
r->type = URGN_SUBCONTINENT;
} else {
r->code = -1;
}
+ void* idStrAlias = (void*)&(r->idStr); // about to orphan 'r'. Save this off.
+ uhash_put(newRegionIDMap.getAlias(),idStrAlias,(void *)(r.orphan()),&status); // regionIDMap takes ownership
}
// Process the territory aliases
- while ( ures_hasNext(territoryAlias) ) {
- UResourceBundle *res = ures_getNextResource(territoryAlias,NULL,&status);
- const char *aliasFrom = ures_getKey(res);
- UnicodeString* aliasFromStr = new UnicodeString(aliasFrom, -1, US_INV);
- UnicodeString aliasTo = ures_getUnicodeString(res,&status);
- ures_close(res);
+ while ( ures_hasNext(territoryAlias.getAlias()) ) {
+ LocalUResourceBundlePointer res(ures_getNextResource(territoryAlias.getAlias(),NULL,&status));
+ const char *aliasFrom = ures_getKey(res.getAlias());
+ LocalPointer<UnicodeString> aliasFromStr(new UnicodeString(aliasFrom, -1, US_INV), status);
+ UnicodeString aliasTo = ures_getUnicodeStringByKey(res.getAlias(),"replacement",&status);
+ res.adoptInstead(NULL);
- Region *aliasToRegion = (Region *) uhash_get(regionIDMap,&aliasTo);
- Region *aliasFromRegion = (Region *)uhash_get(regionIDMap,aliasFromStr);
+ const Region *aliasToRegion = (Region *) uhash_get(newRegionIDMap.getAlias(),&aliasTo);
+ Region *aliasFromRegion = (Region *)uhash_get(newRegionIDMap.getAlias(),aliasFromStr.getAlias());
if ( aliasToRegion != NULL && aliasFromRegion == NULL ) { // This is just an alias from some string to a region
- uhash_put(regionAliases,(void *)aliasFromStr, (void *)aliasToRegion,&status);
+ uhash_put(newRegionAliases.getAlias(),(void *)aliasFromStr.orphan(), (void *)aliasToRegion,&status);
} else {
if ( aliasFromRegion == NULL ) { // Deprecated region code not in the master codes list - so need to create a deprecated region for it.
- aliasFromRegion = new Region();
+ LocalPointer<Region> newRgn(new Region, status);
+ if ( U_SUCCESS(status) ) {
+ aliasFromRegion = newRgn.orphan();
+ } else {
+ return; // error out
+ }
aliasFromRegion->idStr.setTo(*aliasFromStr);
aliasFromRegion->idStr.extract(0,aliasFromRegion->idStr.length(),aliasFromRegion->id,sizeof(aliasFromRegion->id),US_INV);
- uhash_put(regionIDMap,(void *)&(aliasFromRegion->idStr),(void *)aliasFromRegion,&status);
+ uhash_put(newRegionIDMap.getAlias(),(void *)&(aliasFromRegion->idStr),(void *)aliasFromRegion,&status);
Formattable result;
UErrorCode ps = U_ZERO_ERROR;
df->parse(aliasFromRegion->idStr,result,ps);
if ( U_SUCCESS(ps) ) {
aliasFromRegion->code = result.getLong(); // Convert string to number
- uhash_iput(numericCodeMap,aliasFromRegion->code,(void *)aliasFromRegion,&status);
+ uhash_iput(newNumericCodeMap.getAlias(),aliasFromRegion->code,(void *)aliasFromRegion,&status);
} else {
aliasFromRegion->code = -1;
}
} else {
aliasFromRegion->type = URGN_DEPRECATED;
}
- delete aliasFromStr;
- aliasFromRegion->preferredValues = new UVector(uprv_deleteUObject, uhash_compareUnicodeString, status);
+ {
+ LocalPointer<UVector> newPreferredValues(new UVector(uprv_deleteUObject, uhash_compareUnicodeString, status), status);
+ aliasFromRegion->preferredValues = newPreferredValues.orphan();
+ }
+ if( U_FAILURE(status)) {
+ return;
+ }
UnicodeString currentRegion;
- currentRegion.remove();
+ //currentRegion.remove(); TODO: was already 0 length?
for (int32_t i = 0 ; i < aliasTo.length() ; i++ ) {
if ( aliasTo.charAt(i) != 0x0020 ) {
currentRegion.append(aliasTo.charAt(i));
}
if ( aliasTo.charAt(i) == 0x0020 || i+1 == aliasTo.length() ) {
- Region *target = (Region *)uhash_get(regionIDMap,(void *)¤tRegion);
+ Region *target = (Region *)uhash_get(newRegionIDMap.getAlias(),(void *)¤tRegion);
if (target) {
- UnicodeString *preferredValue = new UnicodeString(target->idStr);
- aliasFromRegion->preferredValues->addElement((void *)preferredValue,status);
+ LocalPointer<UnicodeString> preferredValue(new UnicodeString(target->idStr), status);
+ aliasFromRegion->preferredValues->addElement((void *)preferredValue.orphan(),status); // may add null if err
}
currentRegion.remove();
}
}
// Process the code mappings - This will allow us to assign numeric codes to most of the territories.
- while ( ures_hasNext(codeMappings) ) {
- UResourceBundle *mapping = ures_getNextResource(codeMappings,NULL,&status);
+ while ( ures_hasNext(codeMappings.getAlias()) ) {
+ UResourceBundle *mapping = ures_getNextResource(codeMappings.getAlias(),NULL,&status);
if ( ures_getType(mapping) == URES_ARRAY && ures_getSize(mapping) == 3) {
UnicodeString codeMappingID = ures_getUnicodeStringByIndex(mapping,0,&status);
UnicodeString codeMappingNumber = ures_getUnicodeStringByIndex(mapping,1,&status);
UnicodeString codeMapping3Letter = ures_getUnicodeStringByIndex(mapping,2,&status);
- Region *r = (Region *)uhash_get(regionIDMap,(void *)&codeMappingID);
+ Region *r = (Region *)uhash_get(newRegionIDMap.getAlias(),(void *)&codeMappingID);
if ( r ) {
Formattable result;
UErrorCode ps = U_ZERO_ERROR;
df->parse(codeMappingNumber,result,ps);
if ( U_SUCCESS(ps) ) {
r->code = result.getLong(); // Convert string to number
- uhash_iput(numericCodeMap,r->code,(void *)r,&status);
+ uhash_iput(newNumericCodeMap.getAlias(),r->code,(void *)r,&status);
}
- UnicodeString *code3 = new UnicodeString(codeMapping3Letter);
- uhash_put(regionAliases,(void *)code3, (void *)r,&status);
+ LocalPointer<UnicodeString> code3(new UnicodeString(codeMapping3Letter), status);
+ uhash_put(newRegionAliases.getAlias(),(void *)code3.orphan(), (void *)r,&status);
}
}
ures_close(mapping);
// Now fill in the special cases for WORLD, UNKNOWN, CONTINENTS, and GROUPINGS
Region *r;
- UnicodeString WORLD_ID_STRING(WORLD_ID);
- r = (Region *) uhash_get(regionIDMap,(void *)&WORLD_ID_STRING);
+ UnicodeString WORLD_ID_STRING(WORLD_ID);
+ r = (Region *) uhash_get(newRegionIDMap.getAlias(),(void *)&WORLD_ID_STRING);
if ( r ) {
r->type = URGN_WORLD;
}
- UnicodeString UNKNOWN_REGION_ID_STRING(UNKNOWN_REGION_ID);
- r = (Region *) uhash_get(regionIDMap,(void *)&UNKNOWN_REGION_ID_STRING);
+ UnicodeString UNKNOWN_REGION_ID_STRING(UNKNOWN_REGION_ID);
+ r = (Region *) uhash_get(newRegionIDMap.getAlias(),(void *)&UNKNOWN_REGION_ID_STRING);
if ( r ) {
r->type = URGN_UNKNOWN;
}
for ( int32_t i = 0 ; i < continents->size() ; i++ ) {
- r = (Region *) uhash_get(regionIDMap,(void *)continents->elementAt(i));
+ r = (Region *) uhash_get(newRegionIDMap.getAlias(),(void *)continents->elementAt(i));
if ( r ) {
r->type = URGN_CONTINENT;
}
}
- delete continents;
for ( int32_t i = 0 ; i < groupings->size() ; i++ ) {
- r = (Region *) uhash_get(regionIDMap,(void *)groupings->elementAt(i));
+ r = (Region *) uhash_get(newRegionIDMap.getAlias(),(void *)groupings->elementAt(i));
if ( r ) {
r->type = URGN_GROUPING;
}
}
- delete groupings;
// Special case: The region code "QO" (Outlying Oceania) is a subcontinent code added by CLDR
// even though it looks like a territory code. Need to handle it here.
- UnicodeString OUTLYING_OCEANIA_REGION_ID_STRING(OUTLYING_OCEANIA_REGION_ID);
- r = (Region *) uhash_get(regionIDMap,(void *)&OUTLYING_OCEANIA_REGION_ID_STRING);
+ UnicodeString OUTLYING_OCEANIA_REGION_ID_STRING(OUTLYING_OCEANIA_REGION_ID);
+ r = (Region *) uhash_get(newRegionIDMap.getAlias(),(void *)&OUTLYING_OCEANIA_REGION_ID_STRING);
if ( r ) {
r->type = URGN_SUBCONTINENT;
}
// Load territory containment info from the supplemental data.
- while ( ures_hasNext(territoryContainment) ) {
- UResourceBundle *mapping = ures_getNextResource(territoryContainment,NULL,&status);
- const char *parent = ures_getKey(mapping);
+ while ( ures_hasNext(territoryContainment.getAlias()) ) {
+ LocalUResourceBundlePointer mapping(ures_getNextResource(territoryContainment.getAlias(),NULL,&status));
+ if( U_FAILURE(status) ) {
+ return; // error out
+ }
+ const char *parent = ures_getKey(mapping.getAlias());
+ if (uprv_strcmp(parent, "containedGroupings") == 0 || uprv_strcmp(parent, "deprecated") == 0) {
+ continue; // handle new pseudo-parent types added in ICU data per cldrbug 7808; for now just skip.
+ // #11232 is to do something useful with these.
+ }
UnicodeString parentStr = UnicodeString(parent, -1 , US_INV);
- Region *parentRegion = (Region *) uhash_get(regionIDMap,(void *)&parentStr);
+ Region *parentRegion = (Region *) uhash_get(newRegionIDMap.getAlias(),(void *)&parentStr);
- for ( int j = 0 ; j < ures_getSize(mapping); j++ ) {
- UnicodeString child = ures_getUnicodeStringByIndex(mapping,j,&status);
- Region *childRegion = (Region *) uhash_get(regionIDMap,(void *)&child);
+ for ( int j = 0 ; j < ures_getSize(mapping.getAlias()); j++ ) {
+ UnicodeString child = ures_getUnicodeStringByIndex(mapping.getAlias(),j,&status);
+ Region *childRegion = (Region *) uhash_get(newRegionIDMap.getAlias(),(void *)&child);
if ( parentRegion != NULL && childRegion != NULL ) {
// Add the child region to the set of regions contained by the parent
parentRegion->containedRegions = new UVector(uprv_deleteUObject, uhash_compareUnicodeString, status);
}
- UnicodeString *childStr = new UnicodeString();
+ LocalPointer<UnicodeString> childStr(new UnicodeString(), status);
+ if( U_FAILURE(status) ) {
+ return; // error out
+ }
childStr->fastCopyFrom(childRegion->idStr);
- parentRegion->containedRegions->addElement((void *)childStr,status);
+ parentRegion->containedRegions->addElement((void *)childStr.orphan(),status);
// Set the parent region to be the containing region of the child.
// Regions of type GROUPING can't be set as the parent, since another region
}
}
}
- ures_close(mapping);
}
// Create the availableRegions lists
- int32_t pos = -1;
- while ( const UHashElement* element = uhash_nextElement(regionIDMap,&pos)) {
+ int32_t pos = UHASH_FIRST;
+ while ( const UHashElement* element = uhash_nextElement(newRegionIDMap.getAlias(),&pos)) {
Region *ar = (Region *)element->value.pointer;
if ( availableRegions[ar->type] == NULL ) {
- availableRegions[ar->type] = new UVector(uprv_deleteUObject, uhash_compareUnicodeString, status);
+ LocalPointer<UVector> newAr(new UVector(uprv_deleteUObject, uhash_compareUnicodeString, status), status);
+ availableRegions[ar->type] = newAr.orphan();
+ }
+ LocalPointer<UnicodeString> arString(new UnicodeString(ar->idStr), status);
+ if( U_FAILURE(status) ) {
+ return; // error out
}
- UnicodeString *arString = new UnicodeString(ar->idStr);
- availableRegions[ar->type]->addElement((void *)arString,status);
+ availableRegions[ar->type]->addElement((void *)arString.orphan(),status);
}
-
- ures_close(territoryContainment);
- ures_close(worldContainment);
- ures_close(groupingContainment);
-
- ures_close(codeMappings);
- ures_close(rb2);
- ures_close(territoryAlias);
- ures_close(regionCodes);
- ures_close(rb);
-
- delete df;
-
+
ucln_i18n_registerCleanup(UCLN_I18N_REGION, region_cleanup);
-
- regionDataIsLoaded = true;
- umtx_unlock(&gRegionDataLock);
-
+ // copy hashtables
+ numericCodeMap = newNumericCodeMap.orphan();
+ regionIDMap = newRegionIDMap.orphan();
+ regionAliases = newRegionAliases.orphan();
}
void Region::cleanupRegionData() {
-
for (int32_t i = 0 ; i < URGN_LIMIT ; i++ ) {
if ( availableRegions[i] ) {
delete availableRegions[i];
if (regionIDMap) {
uhash_close(regionIDMap);
}
+ regionAliases = numericCodeMap = regionIDMap = NULL;
+
+ gRegionDataInitOnce.reset();
}
Region::Region ()
/**
* Returns true if the two regions are equal.
+ * Per PMC, just use pointer compare, since we have at most one instance of each Region.
*/
UBool
Region::operator==(const Region &that) const {
/**
* Returns true if the two regions are NOT equal; that is, if operator ==() returns false.
+ * Per PMC, just use pointer compare, since we have at most one instance of each Region.
*/
UBool
Region::operator!=(const Region &that) const {
const Region* U_EXPORT2
Region::getInstance(const char *region_code, UErrorCode &status) {
- if ( !region_code ) {
- status = U_ILLEGAL_ARGUMENT_ERROR;
+ umtx_initOnce(gRegionDataInitOnce, &loadRegionData, status);
+ if (U_FAILURE(status)) {
return NULL;
}
- loadRegionData();
-
- if (regionIDMap == NULL) {
+ if ( !region_code ) {
status = U_ILLEGAL_ARGUMENT_ERROR;
return NULL;
}
}
if ( r->type == URGN_DEPRECATED && r->preferredValues->size() == 1) {
- StringEnumeration *pv = r->getPreferredValues();
+ StringEnumeration *pv = r->getPreferredValues(status);
pv->reset(status);
const UnicodeString *ustr = pv->snext(status);
r = (Region *)uhash_get(regionIDMap,(void *)ustr);
const Region* U_EXPORT2
Region::getInstance (int32_t code, UErrorCode &status) {
- loadRegionData();
-
- if (numericCodeMap == NULL) {
- status = U_ILLEGAL_ARGUMENT_ERROR;
+ umtx_initOnce(gRegionDataInitOnce, &loadRegionData, status);
+ if (U_FAILURE(status)) {
return NULL;
}
if ( !r ) { // Just in case there's an alias that's numeric, try to find it.
UErrorCode fs = U_ZERO_ERROR;
UnicodeString pat = UNICODE_STRING_SIMPLE("00#");
- DecimalFormat *df = new DecimalFormat(pat,fs);
-
+ LocalPointer<DecimalFormat> df(new DecimalFormat(pat,fs), status);
+ if( U_FAILURE(status) ) {
+ return NULL;
+ }
UnicodeString id;
id.remove();
- df->format(code,id);
- delete df;
+ 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();
+ StringEnumeration *pv = r->getPreferredValues(status);
pv->reset(status);
const UnicodeString *ustr = pv->snext(status);
r = (Region *)uhash_get(regionIDMap,(void *)ustr);
* Returns an enumeration over the IDs of all known regions that match the given type.
*/
StringEnumeration* U_EXPORT2
-Region::getAvailable(URegionType type) {
-
- loadRegionData();
- UErrorCode status = U_ZERO_ERROR;
+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);
-
- return NULL;
}
/**
*/
const Region*
Region::getContainingRegion() const {
- loadRegionData();
+ UErrorCode status = U_ZERO_ERROR;
+ umtx_initOnce(gRegionDataInitOnce, &loadRegionData, status);
return containingRegion;
}
*/
const Region*
Region::getContainingRegion(URegionType type) const {
- loadRegionData();
+ UErrorCode status = U_ZERO_ERROR;
+ umtx_initOnce(gRegionDataInitOnce, &loadRegionData, status);
if ( containingRegion == NULL ) {
return NULL;
}
- if ( containingRegion->type == type ) {
- return containingRegion;
- } else {
- return containingRegion->getContainingRegion(type);
- }
+ return ( containingRegion->type == type )? containingRegion: containingRegion->getContainingRegion(type);
}
/**
* and "155" (Western Europe).
*/
StringEnumeration*
-Region::getContainedRegions() const {
- loadRegionData();
- UErrorCode status = U_ZERO_ERROR;
+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);
}
* "URGN_TERRITORY" returns a set containing all the territories in Europe ( "FR" (France) - "IT" (Italy) - "DE" (Germany) etc. )
*/
StringEnumeration*
-Region::getContainedRegions( URegionType type ) const {
- loadRegionData();
+Region::getContainedRegions( URegionType type, UErrorCode &status ) const {
+ umtx_initOnce(gRegionDataInitOnce, &loadRegionData, status); // returns immediately if U_FAILURE(status)
+ if (U_FAILURE(status)) {
+ return NULL;
+ }
- UErrorCode status = U_ZERO_ERROR;
UVector *result = new UVector(NULL, uhash_compareChars, status);
- StringEnumeration *cr = getContainedRegions();
+ StringEnumeration *cr = getContainedRegions(status);
for ( int32_t i = 0 ; i < cr->count(status) ; i++ ) {
const char *id = cr->next(NULL,status);
if ( r->getType() == type ) {
result->addElement((void *)&r->idStr,status);
} else {
- StringEnumeration *children = r->getContainedRegions(type);
+ 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);
*/
UBool
Region::contains(const Region &other) const {
- loadRegionData();
+ UErrorCode status = U_ZERO_ERROR;
+ umtx_initOnce(gRegionDataInitOnce, &loadRegionData, status);
if (!containedRegions) {
return FALSE;
* "SU" (Soviet Union) would return a list of the regions containing "RU" (Russia), "AM" (Armenia), "AZ" (Azerbaijan), etc...
*/
StringEnumeration*
-Region::getPreferredValues() const {
- loadRegionData();
- UErrorCode status = U_ZERO_ERROR;
- if ( type == URGN_DEPRECATED ) {
- return new RegionNameEnumeration(preferredValues,status);
- } else {
+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);
}
projects / apple / icu.git / blobdiff