1// © 2016 and later: Unicode, Inc. and others. 2// License & terms of use: http://www.unicode.org/copyright.html 3/* 4******************************************************************************* 5* Copyright (C) 2014-2016, International Business Machines Corporation and 6* others. All Rights Reserved. 7******************************************************************************* 8* 9* 10* File REGION.CPP 11* 12* Modification History:* 13* Date Name Description 14* 01/15/13 Emmons Original Port from ICU4J 15******************************************************************************** 16*/ 17 18/** 19 * \file 20 * \brief C++ API: Region classes (territory containment) 21 */ 22 23#include "unicode/region.h" 24#include "unicode/utypes.h" 25#include "unicode/uobject.h" 26#include "unicode/unistr.h" 27#include "unicode/ures.h" 28#include "unicode/decimfmt.h" 29#include "ucln_in.h" 30#include "cstring.h" 31#include "mutex.h" 32#include "uhash.h" 33#include "umutex.h" 34#include "uresimp.h" 35#include "region_impl.h" 36 37#if !UCONFIG_NO_FORMATTING 38 39 40U_CDECL_BEGIN 41 42static void U_CALLCONV 43deleteRegion(void *obj) { 44 delete (icu::Region *)obj; 45} 46 47/** 48 * Cleanup callback func 49 */ 50static UBool U_CALLCONV region_cleanup(void) 51{ 52 icu::Region::cleanupRegionData(); 53 54 return TRUE; 55} 56 57U_CDECL_END 58 59U_NAMESPACE_BEGIN 60 61static UInitOnce gRegionDataInitOnce = U_INITONCE_INITIALIZER; 62static UVector* availableRegions[URGN_LIMIT]; 63 64static UHashtable *regionAliases = NULL; 65static UHashtable *regionIDMap = NULL; 66static UHashtable *numericCodeMap = NULL; 67static UVector *allRegions = NULL; 68 69static const UChar UNKNOWN_REGION_ID [] = { 0x5A, 0x5A, 0 }; /* "ZZ" */ 70static const UChar OUTLYING_OCEANIA_REGION_ID [] = { 0x51, 0x4F, 0 }; /* "QO" */ 71static const UChar WORLD_ID [] = { 0x30, 0x30, 0x31, 0 }; /* "001" */ 72static const UChar RANGE_MARKER = 0x7E; /* '~' */ 73 74UOBJECT_DEFINE_RTTI_IMPLEMENTATION(RegionNameEnumeration) 75 76/* 77 * Initializes the region data from the ICU resource bundles. The region data 78 * contains the basic relationships such as which regions are known, what the numeric 79 * codes are, any known aliases, and the territory containment data. 80 * 81 * If the region data has already loaded, then this method simply returns without doing 82 * anything meaningful. 83 */ 84void U_CALLCONV Region::loadRegionData(UErrorCode &status) { 85 86 // Construct service objs first 87 LocalUHashtablePointer newRegionIDMap(uhash_open(uhash_hashUnicodeString, uhash_compareUnicodeString, NULL, &status)); 88 LocalUHashtablePointer newNumericCodeMap(uhash_open(uhash_hashLong,uhash_compareLong,NULL,&status)); 89 LocalUHashtablePointer newRegionAliases(uhash_open(uhash_hashUnicodeString,uhash_compareUnicodeString,NULL,&status)); 90 LocalPointer<DecimalFormat> df(new DecimalFormat(status), status); 91 92 LocalPointer<UVector> continents(new UVector(uprv_deleteUObject, uhash_compareUnicodeString, status), status); 93 LocalPointer<UVector> groupings(new UVector(uprv_deleteUObject, uhash_compareUnicodeString, status), status); 94 allRegions = new UVector(uprv_deleteUObject, uhash_compareUnicodeString, status); 95 96 LocalUResourceBundlePointer metadata(ures_openDirect(NULL,"metadata",&status)); 97 LocalUResourceBundlePointer metadataAlias(ures_getByKey(metadata.getAlias(),"alias",NULL,&status)); 98 LocalUResourceBundlePointer territoryAlias(ures_getByKey(metadataAlias.getAlias(),"territory",NULL,&status)); 99 100 LocalUResourceBundlePointer supplementalData(ures_openDirect(NULL,"supplementalData",&status)); 101 LocalUResourceBundlePointer codeMappings(ures_getByKey(supplementalData.getAlias(),"codeMappings",NULL,&status)); 102 103 LocalUResourceBundlePointer idValidity(ures_getByKey(supplementalData.getAlias(),"idValidity",NULL,&status)); 104 LocalUResourceBundlePointer regionList(ures_getByKey(idValidity.getAlias(),"region",NULL,&status)); 105 LocalUResourceBundlePointer regionRegular(ures_getByKey(regionList.getAlias(),"regular",NULL,&status)); 106 LocalUResourceBundlePointer regionMacro(ures_getByKey(regionList.getAlias(),"macroregion",NULL,&status)); 107 LocalUResourceBundlePointer regionUnknown(ures_getByKey(regionList.getAlias(),"unknown",NULL,&status)); 108 109 LocalUResourceBundlePointer territoryContainment(ures_getByKey(supplementalData.getAlias(),"territoryContainment",NULL,&status)); 110 LocalUResourceBundlePointer worldContainment(ures_getByKey(territoryContainment.getAlias(),"001",NULL,&status)); 111 LocalUResourceBundlePointer groupingContainment(ures_getByKey(territoryContainment.getAlias(),"grouping",NULL,&status)); 112 113 if (U_FAILURE(status)) { 114 return; 115 } 116 117 // now, initialize 118 df->setParseIntegerOnly(TRUE); 119 uhash_setValueDeleter(newRegionIDMap.getAlias(), deleteRegion); // regionIDMap owns objs 120 uhash_setKeyDeleter(newRegionAliases.getAlias(), uprv_deleteUObject); // regionAliases owns the string keys 121 122 123 while ( ures_hasNext(regionRegular.getAlias()) ) { 124 UnicodeString regionName = ures_getNextUnicodeString(regionRegular.getAlias(),NULL,&status); 125 int32_t rangeMarkerLocation = regionName.indexOf(RANGE_MARKER); 126 UChar buf[6]; 127 regionName.extract(buf,6,status); 128 if ( rangeMarkerLocation > 0 ) { 129 UChar endRange = regionName.charAt(rangeMarkerLocation+1); 130 buf[rangeMarkerLocation] = 0; 131 while ( buf[rangeMarkerLocation-1] <= endRange ) { 132 LocalPointer<UnicodeString> newRegion(new UnicodeString(buf), status); 133 allRegions->addElement(newRegion.orphan(),status); 134 buf[rangeMarkerLocation-1]++; 135 } 136 } else { 137 LocalPointer<UnicodeString> newRegion(new UnicodeString(regionName), status); 138 allRegions->addElement(newRegion.orphan(),status); 139 } 140 } 141 142 while ( ures_hasNext(regionMacro.getAlias()) ) { 143 UnicodeString regionName = ures_getNextUnicodeString(regionMacro.getAlias(),NULL,&status); 144 int32_t rangeMarkerLocation = regionName.indexOf(RANGE_MARKER); 145 UChar buf[6]; 146 regionName.extract(buf,6,status); 147 if ( rangeMarkerLocation > 0 ) { 148 UChar endRange = regionName.charAt(rangeMarkerLocation+1); 149 buf[rangeMarkerLocation] = 0; 150 while ( buf[rangeMarkerLocation-1] <= endRange ) { 151 LocalPointer<UnicodeString> newRegion(new UnicodeString(buf), status); 152 allRegions->addElement(newRegion.orphan(),status); 153 buf[rangeMarkerLocation-1]++; 154 } 155 } else { 156 LocalPointer<UnicodeString> newRegion(new UnicodeString(regionName), status); 157 allRegions->addElement(newRegion.orphan(),status); 158 } 159 } 160 161 while ( ures_hasNext(regionUnknown.getAlias()) ) { 162 LocalPointer<UnicodeString> regionName (new UnicodeString(ures_getNextUnicodeString(regionUnknown.getAlias(),NULL,&status),status)); 163 allRegions->addElement(regionName.orphan(),status); 164 } 165 166 while ( ures_hasNext(worldContainment.getAlias()) ) { 167 UnicodeString *continentName = new UnicodeString(ures_getNextUnicodeString(worldContainment.getAlias(),NULL,&status)); 168 continents->addElement(continentName,status); 169 } 170 171 while ( ures_hasNext(groupingContainment.getAlias()) ) { 172 UnicodeString *groupingName = new UnicodeString(ures_getNextUnicodeString(groupingContainment.getAlias(),NULL,&status)); 173 groupings->addElement(groupingName,status); 174 } 175 176 for ( int32_t i = 0 ; i < allRegions->size() ; i++ ) { 177 LocalPointer<Region> r(new Region(), status); 178 if ( U_FAILURE(status) ) { 179 return; 180 } 181 UnicodeString *regionName = (UnicodeString *)allRegions->elementAt(i); 182 r->idStr = *regionName; 183 184 r->idStr.extract(0,r->idStr.length(),r->id,sizeof(r->id),US_INV); 185 r->type = URGN_TERRITORY; // Only temporary - figure out the real type later once the aliases are known. 186 187 Formattable result; 188 UErrorCode ps = U_ZERO_ERROR; 189 df->parse(r->idStr,result,ps); 190 if ( U_SUCCESS(ps) ) { 191 r->code = result.getLong(); // Convert string to number 192 uhash_iput(newNumericCodeMap.getAlias(),r->code,(void *)(r.getAlias()),&status); 193 r->type = URGN_SUBCONTINENT; 194 } else { 195 r->code = -1; 196 } 197 void* idStrAlias = (void*)&(r->idStr); // about to orphan 'r'. Save this off. 198 uhash_put(newRegionIDMap.getAlias(),idStrAlias,(void *)(r.orphan()),&status); // regionIDMap takes ownership 199 } 200 201 // Process the territory aliases 202 while ( ures_hasNext(territoryAlias.getAlias()) ) { 203 LocalUResourceBundlePointer res(ures_getNextResource(territoryAlias.getAlias(),NULL,&status)); 204 const char *aliasFrom = ures_getKey(res.getAlias()); 205 LocalPointer<UnicodeString> aliasFromStr(new UnicodeString(aliasFrom, -1, US_INV), status); 206 UnicodeString aliasTo = ures_getUnicodeStringByKey(res.getAlias(),"replacement",&status); 207 res.adoptInstead(NULL); 208 209 const Region *aliasToRegion = (Region *) uhash_get(newRegionIDMap.getAlias(),&aliasTo); 210 Region *aliasFromRegion = (Region *)uhash_get(newRegionIDMap.getAlias(),aliasFromStr.getAlias()); 211 212 if ( aliasToRegion != NULL && aliasFromRegion == NULL ) { // This is just an alias from some string to a region 213 uhash_put(newRegionAliases.getAlias(),(void *)aliasFromStr.orphan(), (void *)aliasToRegion,&status); 214 } else { 215 if ( aliasFromRegion == NULL ) { // Deprecated region code not in the master codes list - so need to create a deprecated region for it. 216 LocalPointer<Region> newRgn(new Region, status); 217 if ( U_SUCCESS(status) ) { 218 aliasFromRegion = newRgn.orphan(); 219 } else { 220 return; // error out 221 } 222 aliasFromRegion->idStr.setTo(*aliasFromStr); 223 aliasFromRegion->idStr.extract(0,aliasFromRegion->idStr.length(),aliasFromRegion->id,sizeof(aliasFromRegion->id),US_INV); 224 uhash_put(newRegionIDMap.getAlias(),(void *)&(aliasFromRegion->idStr),(void *)aliasFromRegion,&status); 225 Formattable result; 226 UErrorCode ps = U_ZERO_ERROR; 227 df->parse(aliasFromRegion->idStr,result,ps); 228 if ( U_SUCCESS(ps) ) { 229 aliasFromRegion->code = result.getLong(); // Convert string to number 230 uhash_iput(newNumericCodeMap.getAlias(),aliasFromRegion->code,(void *)aliasFromRegion,&status); 231 } else { 232 aliasFromRegion->code = -1; 233 } 234 aliasFromRegion->type = URGN_DEPRECATED; 235 } else { 236 aliasFromRegion->type = URGN_DEPRECATED; 237 } 238 239 { 240 LocalPointer<UVector> newPreferredValues(new UVector(uprv_deleteUObject, uhash_compareUnicodeString, status), status); 241 aliasFromRegion->preferredValues = newPreferredValues.orphan(); 242 } 243 if( U_FAILURE(status)) { 244 return; 245 } 246 UnicodeString currentRegion; 247 //currentRegion.remove(); TODO: was already 0 length? 248 for (int32_t i = 0 ; i < aliasTo.length() ; i++ ) { 249 if ( aliasTo.charAt(i) != 0x0020 ) { 250 currentRegion.append(aliasTo.charAt(i)); 251 } 252 if ( aliasTo.charAt(i) == 0x0020 || i+1 == aliasTo.length() ) { 253 Region *target = (Region *)uhash_get(newRegionIDMap.getAlias(),(void *)¤tRegion); 254 if (target) { 255 LocalPointer<UnicodeString> preferredValue(new UnicodeString(target->idStr), status); 256 aliasFromRegion->preferredValues->addElement((void *)preferredValue.orphan(),status); // may add null if err 257 } 258 currentRegion.remove(); 259 } 260 } 261 } 262 } 263 264 // Process the code mappings - This will allow us to assign numeric codes to most of the territories. 265 while ( ures_hasNext(codeMappings.getAlias()) ) { 266 UResourceBundle *mapping = ures_getNextResource(codeMappings.getAlias(),NULL,&status); 267 if ( ures_getType(mapping) == URES_ARRAY && ures_getSize(mapping) == 3) { 268 UnicodeString codeMappingID = ures_getUnicodeStringByIndex(mapping,0,&status); 269 UnicodeString codeMappingNumber = ures_getUnicodeStringByIndex(mapping,1,&status); 270 UnicodeString codeMapping3Letter = ures_getUnicodeStringByIndex(mapping,2,&status); 271 272 Region *r = (Region *)uhash_get(newRegionIDMap.getAlias(),(void *)&codeMappingID); 273 if ( r ) { 274 Formattable result; 275 UErrorCode ps = U_ZERO_ERROR; 276 df->parse(codeMappingNumber,result,ps); 277 if ( U_SUCCESS(ps) ) { 278 r->code = result.getLong(); // Convert string to number 279 uhash_iput(newNumericCodeMap.getAlias(),r->code,(void *)r,&status); 280 } 281 LocalPointer<UnicodeString> code3(new UnicodeString(codeMapping3Letter), status); 282 uhash_put(newRegionAliases.getAlias(),(void *)code3.orphan(), (void *)r,&status); 283 } 284 } 285 ures_close(mapping); 286 } 287 288 // Now fill in the special cases for WORLD, UNKNOWN, CONTINENTS, and GROUPINGS 289 Region *r; 290 UnicodeString WORLD_ID_STRING(WORLD_ID); 291 r = (Region *) uhash_get(newRegionIDMap.getAlias(),(void *)&WORLD_ID_STRING); 292 if ( r ) { 293 r->type = URGN_WORLD; 294 } 295 296 UnicodeString UNKNOWN_REGION_ID_STRING(UNKNOWN_REGION_ID); 297 r = (Region *) uhash_get(newRegionIDMap.getAlias(),(void *)&UNKNOWN_REGION_ID_STRING); 298 if ( r ) { 299 r->type = URGN_UNKNOWN; 300 } 301 302 for ( int32_t i = 0 ; i < continents->size() ; i++ ) { 303 r = (Region *) uhash_get(newRegionIDMap.getAlias(),(void *)continents->elementAt(i)); 304 if ( r ) { 305 r->type = URGN_CONTINENT; 306 } 307 } 308 309 for ( int32_t i = 0 ; i < groupings->size() ; i++ ) { 310 r = (Region *) uhash_get(newRegionIDMap.getAlias(),(void *)groupings->elementAt(i)); 311 if ( r ) { 312 r->type = URGN_GROUPING; 313 } 314 } 315 316 // Special case: The region code "QO" (Outlying Oceania) is a subcontinent code added by CLDR 317 // even though it looks like a territory code. Need to handle it here. 318 319 UnicodeString OUTLYING_OCEANIA_REGION_ID_STRING(OUTLYING_OCEANIA_REGION_ID); 320 r = (Region *) uhash_get(newRegionIDMap.getAlias(),(void *)&OUTLYING_OCEANIA_REGION_ID_STRING); 321 if ( r ) { 322 r->type = URGN_SUBCONTINENT; 323 } 324 325 // Load territory containment info from the supplemental data. 326 while ( ures_hasNext(territoryContainment.getAlias()) ) { 327 LocalUResourceBundlePointer mapping(ures_getNextResource(territoryContainment.getAlias(),NULL,&status)); 328 if( U_FAILURE(status) ) { 329 return; // error out 330 } 331 const char *parent = ures_getKey(mapping.getAlias()); 332 if (uprv_strcmp(parent, "containedGroupings") == 0 || uprv_strcmp(parent, "deprecated") == 0) { 333 continue; // handle new pseudo-parent types added in ICU data per cldrbug 7808; for now just skip. 334 // #11232 is to do something useful with these. 335 } 336 UnicodeString parentStr = UnicodeString(parent, -1 , US_INV); 337 Region *parentRegion = (Region *) uhash_get(newRegionIDMap.getAlias(),(void *)&parentStr); 338 339 for ( int j = 0 ; j < ures_getSize(mapping.getAlias()); j++ ) { 340 UnicodeString child = ures_getUnicodeStringByIndex(mapping.getAlias(),j,&status); 341 Region *childRegion = (Region *) uhash_get(newRegionIDMap.getAlias(),(void *)&child); 342 if ( parentRegion != NULL && childRegion != NULL ) { 343 344 // Add the child region to the set of regions contained by the parent 345 if (parentRegion->containedRegions == NULL) { 346 parentRegion->containedRegions = new UVector(uprv_deleteUObject, uhash_compareUnicodeString, status); 347 } 348 349 LocalPointer<UnicodeString> childStr(new UnicodeString(), status); 350 if( U_FAILURE(status) ) { 351 return; // error out 352 } 353 childStr->fastCopyFrom(childRegion->idStr); 354 parentRegion->containedRegions->addElement((void *)childStr.orphan(),status); 355 356 // Set the parent region to be the containing region of the child. 357 // Regions of type GROUPING can't be set as the parent, since another region 358 // such as a SUBCONTINENT, CONTINENT, or WORLD must always be the parent. 359 if ( parentRegion->type != URGN_GROUPING) { 360 childRegion->containingRegion = parentRegion; 361 } 362 } 363 } 364 } 365 366 // Create the availableRegions lists 367 int32_t pos = UHASH_FIRST; 368 while ( const UHashElement* element = uhash_nextElement(newRegionIDMap.getAlias(),&pos)) { 369 Region *ar = (Region *)element->value.pointer; 370 if ( availableRegions[ar->type] == NULL ) { 371 LocalPointer<UVector> newAr(new UVector(uprv_deleteUObject, uhash_compareUnicodeString, status), status); 372 availableRegions[ar->type] = newAr.orphan(); 373 } 374 LocalPointer<UnicodeString> arString(new UnicodeString(ar->idStr), status); 375 if( U_FAILURE(status) ) { 376 return; // error out 377 } 378 availableRegions[ar->type]->addElement((void *)arString.orphan(),status); 379 } 380 381 ucln_i18n_registerCleanup(UCLN_I18N_REGION, region_cleanup); 382 // copy hashtables 383 numericCodeMap = newNumericCodeMap.orphan(); 384 regionIDMap = newRegionIDMap.orphan(); 385 regionAliases = newRegionAliases.orphan(); 386} 387 388void Region::cleanupRegionData() { 389 for (int32_t i = 0 ; i < URGN_LIMIT ; i++ ) { 390 if ( availableRegions[i] ) { 391 delete availableRegions[i]; 392 } 393 } 394 395 if (regionAliases) { 396 uhash_close(regionAliases); 397 } 398 399 if (numericCodeMap) { 400 uhash_close(numericCodeMap); 401 } 402 403 if (regionIDMap) { 404 uhash_close(regionIDMap); 405 } 406 if (allRegions) { 407 allRegions->removeAllElements(); // Don't need the temporary list anymore. 408 delete allRegions; 409 allRegions = NULL; 410 } 411 412 regionAliases = numericCodeMap = regionIDMap = NULL; 413 414 gRegionDataInitOnce.reset(); 415} 416 417Region::Region () 418 : code(-1), 419 type(URGN_UNKNOWN), 420 containingRegion(NULL), 421 containedRegions(NULL), 422 preferredValues(NULL) { 423 id[0] = 0; 424} 425 426Region::~Region () { 427 if (containedRegions) { 428 delete containedRegions; 429 } 430 if (preferredValues) { 431 delete preferredValues; 432 } 433} 434 435/** 436 * Returns true if the two regions are equal. 437 * Per PMC, just use pointer compare, since we have at most one instance of each Region. 438 */ 439UBool 440Region::operator==(const Region &that) const { 441 return (idStr == that.idStr); 442} 443 444/** 445 * Returns true if the two regions are NOT equal; that is, if operator ==() returns false. 446 * Per PMC, just use pointer compare, since we have at most one instance of each Region. 447 */ 448UBool 449Region::operator!=(const Region &that) const { 450 return (idStr != that.idStr); 451} 452 453/** 454 * Returns a pointer to a Region using the given region code. The region code can be either 2-letter ISO code, 455 * 3-letter ISO code, UNM.49 numeric code, or other valid Unicode Region Code as defined by the LDML specification. 456 * The identifier will be canonicalized internally using the supplemental metadata as defined in the CLDR. 457 * If the region code is NULL or not recognized, the appropriate error code will be set ( U_ILLEGAL_ARGUMENT_ERROR ) 458 */ 459const Region* U_EXPORT2 460Region::getInstance(const char *region_code, UErrorCode &status) { 461 462 umtx_initOnce(gRegionDataInitOnce, &loadRegionData, status); 463 if (U_FAILURE(status)) { 464 return NULL; 465 } 466 467 if ( !region_code ) { 468 status = U_ILLEGAL_ARGUMENT_ERROR; 469 return NULL; 470 } 471 472 UnicodeString regionCodeString = UnicodeString(region_code, -1, US_INV); 473 Region *r = (Region *)uhash_get(regionIDMap,(void *)®ionCodeString); 474 475 if ( !r ) { 476 r = (Region *)uhash_get(regionAliases,(void *)®ionCodeString); 477 } 478 479 if ( !r ) { // Unknown region code 480 status = U_ILLEGAL_ARGUMENT_ERROR; 481 return NULL; 482 } 483 484 if ( r->type == URGN_DEPRECATED && r->preferredValues->size() == 1) { 485 StringEnumeration *pv = r->getPreferredValues(status); 486 pv->reset(status); 487 const UnicodeString *ustr = pv->snext(status); 488 r = (Region *)uhash_get(regionIDMap,(void *)ustr); 489 delete pv; 490 } 491 492 return r; 493 494} 495 496/** 497 * Returns a pointer to a Region using the given numeric region code. If the numeric region code is not recognized, 498 * the appropriate error code will be set ( U_ILLEGAL_ARGUMENT_ERROR ). 499 */ 500const Region* U_EXPORT2 501Region::getInstance (int32_t code, UErrorCode &status) { 502 503 umtx_initOnce(gRegionDataInitOnce, &loadRegionData, status); 504 if (U_FAILURE(status)) { 505 return NULL; 506 } 507 508 Region *r = (Region *)uhash_iget(numericCodeMap,code); 509 510 if ( !r ) { // Just in case there's an alias that's numeric, try to find it. 511 UnicodeString pat = UNICODE_STRING_SIMPLE("0"); 512 LocalPointer<DecimalFormat> df(new DecimalFormat(pat,status), status); 513 if( U_FAILURE(status) ) { 514 return NULL; 515 } 516 UnicodeString id; 517 id.remove(); 518 FieldPosition posIter; 519 df->format(code,id, posIter, status); 520 r = (Region *)uhash_get(regionAliases,&id); 521 } 522 523 if( U_FAILURE(status) ) { 524 return NULL; 525 } 526 527 if ( !r ) { 528 status = U_ILLEGAL_ARGUMENT_ERROR; 529 return NULL; 530 } 531 532 if ( r->type == URGN_DEPRECATED && r->preferredValues->size() == 1) { 533 StringEnumeration *pv = r->getPreferredValues(status); 534 pv->reset(status); 535 const UnicodeString *ustr = pv->snext(status); 536 r = (Region *)uhash_get(regionIDMap,(void *)ustr); 537 delete pv; 538 } 539 540 return r; 541} 542 543 544/** 545 * Returns an enumeration over the IDs of all known regions that match the given type. 546 */ 547StringEnumeration* U_EXPORT2 548Region::getAvailable(URegionType type, UErrorCode &status) { 549 umtx_initOnce(gRegionDataInitOnce, &loadRegionData, status); // returns immediately if U_FAILURE(status) 550 if (U_FAILURE(status)) { 551 return NULL; 552 } 553 return new RegionNameEnumeration(availableRegions[type],status); 554} 555 556/** 557 * Returns a pointer to the region that contains this region. Returns NULL if this region is code "001" (World) 558 * or "ZZ" (Unknown region). For example, calling this method with region "IT" (Italy) returns the 559 * region "039" (Southern Europe). 560 */ 561const Region* 562Region::getContainingRegion() const { 563 UErrorCode status = U_ZERO_ERROR; 564 umtx_initOnce(gRegionDataInitOnce, &loadRegionData, status); 565 return containingRegion; 566} 567 568/** 569 * Return a pointer to the region that geographically contains this region and matches the given type, 570 * moving multiple steps up the containment chain if necessary. Returns NULL if no containing region can be found 571 * that matches the given type. Note: The URegionTypes = "URGN_GROUPING", "URGN_DEPRECATED", or "URGN_UNKNOWN" 572 * are not appropriate for use in this API. NULL will be returned in this case. For example, calling this method 573 * with region "IT" (Italy) for type "URGN_CONTINENT" returns the region "150" ( Europe ). 574 */ 575const Region* 576Region::getContainingRegion(URegionType type) const { 577 UErrorCode status = U_ZERO_ERROR; 578 umtx_initOnce(gRegionDataInitOnce, &loadRegionData, status); 579 if ( containingRegion == NULL ) { 580 return NULL; 581 } 582 583 return ( containingRegion->type == type )? containingRegion: containingRegion->getContainingRegion(type); 584} 585 586/** 587 * Return an enumeration over the IDs of all the regions that are immediate children of this region in the 588 * region hierarchy. These returned regions could be either macro regions, territories, or a mixture of the two, 589 * depending on the containment data as defined in CLDR. This API may return NULL if this region doesn't have 590 * any sub-regions. For example, calling this method with region "150" (Europe) returns an enumeration containing 591 * the various sub regions of Europe - "039" (Southern Europe) - "151" (Eastern Europe) - "154" (Northern Europe) 592 * and "155" (Western Europe). 593 */ 594StringEnumeration* 595Region::getContainedRegions(UErrorCode &status) const { 596 umtx_initOnce(gRegionDataInitOnce, &loadRegionData, status); // returns immediately if U_FAILURE(status) 597 if (U_FAILURE(status)) { 598 return NULL; 599 } 600 return new RegionNameEnumeration(containedRegions,status); 601} 602 603/** 604 * Returns an enumeration over the IDs of all the regions that are children of this region anywhere in the region 605 * hierarchy and match the given type. This API may return an empty enumeration if this region doesn't have any 606 * sub-regions that match the given type. For example, calling this method with region "150" (Europe) and type 607 * "URGN_TERRITORY" returns a set containing all the territories in Europe ( "FR" (France) - "IT" (Italy) - "DE" (Germany) etc. ) 608 */ 609StringEnumeration* 610Region::getContainedRegions( URegionType type, UErrorCode &status ) const { 611 umtx_initOnce(gRegionDataInitOnce, &loadRegionData, status); // returns immediately if U_FAILURE(status) 612 if (U_FAILURE(status)) { 613 return NULL; 614 } 615 616 UVector *result = new UVector(NULL, uhash_compareChars, status); 617 618 StringEnumeration *cr = getContainedRegions(status); 619 620 for ( int32_t i = 0 ; i < cr->count(status) ; i++ ) { 621 const char *id = cr->next(NULL,status); 622 const Region *r = Region::getInstance(id,status); 623 if ( r->getType() == type ) { 624 result->addElement((void *)&r->idStr,status); 625 } else { 626 StringEnumeration *children = r->getContainedRegions(type, status); 627 for ( int32_t j = 0 ; j < children->count(status) ; j++ ) { 628 const char *id2 = children->next(NULL,status); 629 const Region *r2 = Region::getInstance(id2,status); 630 result->addElement((void *)&r2->idStr,status); 631 } 632 delete children; 633 } 634 } 635 delete cr; 636 StringEnumeration* resultEnumeration = new RegionNameEnumeration(result,status); 637 delete result; 638 return resultEnumeration; 639} 640 641/** 642 * Returns true if this region contains the supplied other region anywhere in the region hierarchy. 643 */ 644UBool 645Region::contains(const Region &other) const { 646 UErrorCode status = U_ZERO_ERROR; 647 umtx_initOnce(gRegionDataInitOnce, &loadRegionData, status); 648 649 if (!containedRegions) { 650 return FALSE; 651 } 652 if (containedRegions->contains((void *)&other.idStr)) { 653 return TRUE; 654 } else { 655 for ( int32_t i = 0 ; i < containedRegions->size() ; i++ ) { 656 UnicodeString *crStr = (UnicodeString *)containedRegions->elementAt(i); 657 Region *cr = (Region *) uhash_get(regionIDMap,(void *)crStr); 658 if ( cr && cr->contains(other) ) { 659 return TRUE; 660 } 661 } 662 } 663 664 return FALSE; 665} 666 667/** 668 * For deprecated regions, return an enumeration over the IDs of the regions that are the preferred replacement 669 * regions for this region. Returns NULL for a non-deprecated region. For example, calling this method with region 670 * "SU" (Soviet Union) would return a list of the regions containing "RU" (Russia), "AM" (Armenia), "AZ" (Azerbaijan), etc... 671 */ 672StringEnumeration* 673Region::getPreferredValues(UErrorCode &status) const { 674 umtx_initOnce(gRegionDataInitOnce, &loadRegionData, status); // returns immediately if U_FAILURE(status) 675 if (U_FAILURE(status) || type != URGN_DEPRECATED) { 676 return NULL; 677 } 678 return new RegionNameEnumeration(preferredValues,status); 679} 680 681 682/** 683 * Return this region's canonical region code. 684 */ 685const char* 686Region::getRegionCode() const { 687 return id; 688} 689 690int32_t 691Region::getNumericCode() const { 692 return code; 693} 694 695/** 696 * Returns the region type of this region. 697 */ 698URegionType 699Region::getType() const { 700 return type; 701} 702 703RegionNameEnumeration::RegionNameEnumeration(UVector *fNameList, UErrorCode& status) { 704 pos=0; 705 if (fNameList && U_SUCCESS(status)) { 706 fRegionNames = new UVector(uprv_deleteUObject, uhash_compareUnicodeString, fNameList->size(),status); 707 for ( int32_t i = 0 ; i < fNameList->size() ; i++ ) { 708 UnicodeString* this_region_name = (UnicodeString *)fNameList->elementAt(i); 709 UnicodeString* new_region_name = new UnicodeString(*this_region_name); 710 fRegionNames->addElement((void *)new_region_name,status); 711 } 712 } 713 else { 714 fRegionNames = NULL; 715 } 716} 717 718const UnicodeString* 719RegionNameEnumeration::snext(UErrorCode& status) { 720 if (U_FAILURE(status) || (fRegionNames==NULL)) { 721 return NULL; 722 } 723 const UnicodeString* nextStr = (const UnicodeString *)fRegionNames->elementAt(pos); 724 if (nextStr!=NULL) { 725 pos++; 726 } 727 return nextStr; 728} 729 730void 731RegionNameEnumeration::reset(UErrorCode& /*status*/) { 732 pos=0; 733} 734 735int32_t 736RegionNameEnumeration::count(UErrorCode& /*status*/) const { 737 return (fRegionNames==NULL) ? 0 : fRegionNames->size(); 738} 739 740RegionNameEnumeration::~RegionNameEnumeration() { 741 delete fRegionNames; 742} 743 744U_NAMESPACE_END 745 746#endif /* #if !UCONFIG_NO_FORMATTING */ 747 748//eof 749