The Tor Browser / file comparison

comparison: intl/icu/source/i18n/region.cpp

intl/icu/source/i18n/region.cpp

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

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial