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