The Tor Browser / file comparison

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

intl/icu/source/i18n/tzgnames.cpp

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:939320395401
1 /*
2 *******************************************************************************
3 * Copyright (C) 2011-2013, International Business Machines Corporation and
4 * others. All Rights Reserved.
5 *******************************************************************************
6 */
7
8 #include "unicode/utypes.h"
9
10 #if !UCONFIG_NO_FORMATTING
11
12 #include "tzgnames.h"
13
14 #include "unicode/basictz.h"
15 #include "unicode/locdspnm.h"
16 #include "unicode/msgfmt.h"
17 #include "unicode/rbtz.h"
18 #include "unicode/simpletz.h"
19 #include "unicode/vtzone.h"
20
21 #include "cmemory.h"
22 #include "cstring.h"
23 #include "mutex.h"
24 #include "uhash.h"
25 #include "uassert.h"
26 #include "umutex.h"
27 #include "uresimp.h"
28 #include "ureslocs.h"
29 #include "zonemeta.h"
30 #include "tznames_impl.h"
31 #include "olsontz.h"
32 #include "ucln_in.h"
33
34 U_NAMESPACE_BEGIN
35
36 #define ZID_KEY_MAX 128
37
38 static const char gZoneStrings[] = "zoneStrings";
39
40 static const char gRegionFormatTag[] = "regionFormat";
41 static const char gFallbackFormatTag[] = "fallbackFormat";
42
43 static const UChar gEmpty[] = {0x00};
44
45 static const UChar gDefRegionPattern[] = {0x7B, 0x30, 0x7D, 0x00}; // "{0}"
46 static const UChar gDefFallbackPattern[] = {0x7B, 0x31, 0x7D, 0x20, 0x28, 0x7B, 0x30, 0x7D, 0x29, 0x00}; // "{1} ({0})"
47
48 static const double kDstCheckRange = (double)184*U_MILLIS_PER_DAY;
49
50
51
52 U_CDECL_BEGIN
53
54 typedef struct PartialLocationKey {
55 const UChar* tzID;
56 const UChar* mzID;
57 UBool isLong;
58 } PartialLocationKey;
59
60 /**
61 * Hash function for partial location name hash key
62 */
63 static int32_t U_CALLCONV
64 hashPartialLocationKey(const UHashTok key) {
65 // <tzID>&<mzID>#[L|S]
66 PartialLocationKey *p = (PartialLocationKey *)key.pointer;
67 UnicodeString str(p->tzID);
68 str.append((UChar)0x26)
69 .append(p->mzID, -1)
70 .append((UChar)0x23)
71 .append((UChar)(p->isLong ? 0x4C : 0x53));
72 return str.hashCode();
73 }
74
75 /**
76 * Comparer for partial location name hash key
77 */
78 static UBool U_CALLCONV
79 comparePartialLocationKey(const UHashTok key1, const UHashTok key2) {
80 PartialLocationKey *p1 = (PartialLocationKey *)key1.pointer;
81 PartialLocationKey *p2 = (PartialLocationKey *)key2.pointer;
82
83 if (p1 == p2) {
84 return TRUE;
85 }
86 if (p1 == NULL || p2 == NULL) {
87 return FALSE;
88 }
89 // We just check identity of tzID/mzID
90 return (p1->tzID == p2->tzID && p1->mzID == p2->mzID && p1->isLong == p2->isLong);
91 }
92
93 /**
94 * Deleter for GNameInfo
95 */
96 static void U_CALLCONV
97 deleteGNameInfo(void *obj) {
98 uprv_free(obj);
99 }
100
101 /**
102 * GNameInfo stores zone name information in the local trie
103 */
104 typedef struct GNameInfo {
105 UTimeZoneGenericNameType type;
106 const UChar* tzID;
107 } ZNameInfo;
108
109 /**
110 * GMatchInfo stores zone name match information used by find method
111 */
112 typedef struct GMatchInfo {
113 const GNameInfo* gnameInfo;
114 int32_t matchLength;
115 UTimeZoneFormatTimeType timeType;
116 } ZMatchInfo;
117
118 U_CDECL_END
119
120 // ---------------------------------------------------
121 // The class stores time zone generic name match information
122 // ---------------------------------------------------
123 class TimeZoneGenericNameMatchInfo : public UMemory {
124 public:
125 TimeZoneGenericNameMatchInfo(UVector* matches);
126 ~TimeZoneGenericNameMatchInfo();
127
128 int32_t size() const;
129 UTimeZoneGenericNameType getGenericNameType(int32_t index) const;
130 int32_t getMatchLength(int32_t index) const;
131 UnicodeString& getTimeZoneID(int32_t index, UnicodeString& tzID) const;
132
133 private:
134 UVector* fMatches; // vector of MatchEntry
135 };
136
137 TimeZoneGenericNameMatchInfo::TimeZoneGenericNameMatchInfo(UVector* matches)
138 : fMatches(matches) {
139 }
140
141 TimeZoneGenericNameMatchInfo::~TimeZoneGenericNameMatchInfo() {
142 if (fMatches != NULL) {
143 delete fMatches;
144 }
145 }
146
147 int32_t
148 TimeZoneGenericNameMatchInfo::size() const {
149 if (fMatches == NULL) {
150 return 0;
151 }
152 return fMatches->size();
153 }
154
155 UTimeZoneGenericNameType
156 TimeZoneGenericNameMatchInfo::getGenericNameType(int32_t index) const {
157 GMatchInfo *minfo = (GMatchInfo *)fMatches->elementAt(index);
158 if (minfo != NULL) {
159 return static_cast<UTimeZoneGenericNameType>(minfo->gnameInfo->type);
160 }
161 return UTZGNM_UNKNOWN;
162 }
163
164 int32_t
165 TimeZoneGenericNameMatchInfo::getMatchLength(int32_t index) const {
166 ZMatchInfo *minfo = (ZMatchInfo *)fMatches->elementAt(index);
167 if (minfo != NULL) {
168 return minfo->matchLength;
169 }
170 return -1;
171 }
172
173 UnicodeString&
174 TimeZoneGenericNameMatchInfo::getTimeZoneID(int32_t index, UnicodeString& tzID) const {
175 GMatchInfo *minfo = (GMatchInfo *)fMatches->elementAt(index);
176 if (minfo != NULL && minfo->gnameInfo->tzID != NULL) {
177 tzID.setTo(TRUE, minfo->gnameInfo->tzID, -1);
178 } else {
179 tzID.setToBogus();
180 }
181 return tzID;
182 }
183
184 // ---------------------------------------------------
185 // GNameSearchHandler
186 // ---------------------------------------------------
187 class GNameSearchHandler : public TextTrieMapSearchResultHandler {
188 public:
189 GNameSearchHandler(uint32_t types);
190 virtual ~GNameSearchHandler();
191
192 UBool handleMatch(int32_t matchLength, const CharacterNode *node, UErrorCode &status);
193 UVector* getMatches(int32_t& maxMatchLen);
194
195 private:
196 uint32_t fTypes;
197 UVector* fResults;
198 int32_t fMaxMatchLen;
199 };
200
201 GNameSearchHandler::GNameSearchHandler(uint32_t types)
202 : fTypes(types), fResults(NULL), fMaxMatchLen(0) {
203 }
204
205 GNameSearchHandler::~GNameSearchHandler() {
206 if (fResults != NULL) {
207 delete fResults;
208 }
209 }
210
211 UBool
212 GNameSearchHandler::handleMatch(int32_t matchLength, const CharacterNode *node, UErrorCode &status) {
213 if (U_FAILURE(status)) {
214 return FALSE;
215 }
216 if (node->hasValues()) {
217 int32_t valuesCount = node->countValues();
218 for (int32_t i = 0; i < valuesCount; i++) {
219 GNameInfo *nameinfo = (ZNameInfo *)node->getValue(i);
220 if (nameinfo == NULL) {
221 break;
222 }
223 if ((nameinfo->type & fTypes) != 0) {
224 // matches a requested type
225 if (fResults == NULL) {
226 fResults = new UVector(uprv_free, NULL, status);
227 if (fResults == NULL) {
228 status = U_MEMORY_ALLOCATION_ERROR;
229 }
230 }
231 if (U_SUCCESS(status)) {
232 U_ASSERT(fResults != NULL);
233 GMatchInfo *gmatch = (GMatchInfo *)uprv_malloc(sizeof(GMatchInfo));
234 if (gmatch == NULL) {
235 status = U_MEMORY_ALLOCATION_ERROR;
236 } else {
237 // add the match to the vector
238 gmatch->gnameInfo = nameinfo;
239 gmatch->matchLength = matchLength;
240 gmatch->timeType = UTZFMT_TIME_TYPE_UNKNOWN;
241 fResults->addElement(gmatch, status);
242 if (U_FAILURE(status)) {
243 uprv_free(gmatch);
244 } else {
245 if (matchLength > fMaxMatchLen) {
246 fMaxMatchLen = matchLength;
247 }
248 }
249 }
250 }
251 }
252 }
253 }
254 return TRUE;
255 }
256
257 UVector*
258 GNameSearchHandler::getMatches(int32_t& maxMatchLen) {
259 // give the ownership to the caller
260 UVector *results = fResults;
261 maxMatchLen = fMaxMatchLen;
262
263 // reset
264 fResults = NULL;
265 fMaxMatchLen = 0;
266 return results;
267 }
268
269 static UMutex gLock = U_MUTEX_INITIALIZER;
270
271 class TZGNCore : public UMemory {
272 public:
273 TZGNCore(const Locale& locale, UErrorCode& status);
274 virtual ~TZGNCore();
275
276 UnicodeString& getDisplayName(const TimeZone& tz, UTimeZoneGenericNameType type,
277 UDate date, UnicodeString& name) const;
278
279 UnicodeString& getGenericLocationName(const UnicodeString& tzCanonicalID, UnicodeString& name) const;
280
281 int32_t findBestMatch(const UnicodeString& text, int32_t start, uint32_t types,
282 UnicodeString& tzID, UTimeZoneFormatTimeType& timeType, UErrorCode& status) const;
283
284 private:
285 Locale fLocale;
286 const TimeZoneNames* fTimeZoneNames;
287 UHashtable* fLocationNamesMap;
288 UHashtable* fPartialLocationNamesMap;
289
290 MessageFormat* fRegionFormat;
291 MessageFormat* fFallbackFormat;
292
293 LocaleDisplayNames* fLocaleDisplayNames;
294 ZNStringPool fStringPool;
295
296 TextTrieMap fGNamesTrie;
297 UBool fGNamesTrieFullyLoaded;
298
299 char fTargetRegion[ULOC_COUNTRY_CAPACITY];
300
301 void initialize(const Locale& locale, UErrorCode& status);
302 void cleanup();
303
304 void loadStrings(const UnicodeString& tzCanonicalID);
305
306 const UChar* getGenericLocationName(const UnicodeString& tzCanonicalID);
307
308 UnicodeString& formatGenericNonLocationName(const TimeZone& tz, UTimeZoneGenericNameType type,
309 UDate date, UnicodeString& name) const;
310
311 UnicodeString& getPartialLocationName(const UnicodeString& tzCanonicalID,
312 const UnicodeString& mzID, UBool isLong, const UnicodeString& mzDisplayName,
313 UnicodeString& name) const;
314
315 const UChar* getPartialLocationName(const UnicodeString& tzCanonicalID,
316 const UnicodeString& mzID, UBool isLong, const UnicodeString& mzDisplayName);
317
318 TimeZoneGenericNameMatchInfo* findLocal(const UnicodeString& text, int32_t start, uint32_t types, UErrorCode& status) const;
319
320 TimeZoneNames::MatchInfoCollection* findTimeZoneNames(const UnicodeString& text, int32_t start, uint32_t types, UErrorCode& status) const;
321 };
322
323
324 // ---------------------------------------------------
325 // TZGNCore - core implmentation of TimeZoneGenericNames
326 //
327 // TimeZoneGenericNames is parallel to TimeZoneNames,
328 // but handles run-time generated time zone names.
329 // This is the main part of this module.
330 // ---------------------------------------------------
331 TZGNCore::TZGNCore(const Locale& locale, UErrorCode& status)
332 : fLocale(locale),
333 fTimeZoneNames(NULL),
334 fLocationNamesMap(NULL),
335 fPartialLocationNamesMap(NULL),
336 fRegionFormat(NULL),
337 fFallbackFormat(NULL),
338 fLocaleDisplayNames(NULL),
339 fStringPool(status),
340 fGNamesTrie(TRUE, deleteGNameInfo),
341 fGNamesTrieFullyLoaded(FALSE) {
342 initialize(locale, status);
343 }
344
345 TZGNCore::~TZGNCore() {
346 cleanup();
347 }
348
349 void
350 TZGNCore::initialize(const Locale& locale, UErrorCode& status) {
351 if (U_FAILURE(status)) {
352 return;
353 }
354
355 // TimeZoneNames
356 fTimeZoneNames = TimeZoneNames::createInstance(locale, status);
357 if (U_FAILURE(status)) {
358 return;
359 }
360
361 // Initialize format patterns
362 UnicodeString rpat(TRUE, gDefRegionPattern, -1);
363 UnicodeString fpat(TRUE, gDefFallbackPattern, -1);
364
365 UErrorCode tmpsts = U_ZERO_ERROR; // OK with fallback warning..
366 UResourceBundle *zoneStrings = ures_open(U_ICUDATA_ZONE, locale.getName(), &tmpsts);
367 zoneStrings = ures_getByKeyWithFallback(zoneStrings, gZoneStrings, zoneStrings, &tmpsts);
368
369 if (U_SUCCESS(tmpsts)) {
370 const UChar *regionPattern = ures_getStringByKeyWithFallback(zoneStrings, gRegionFormatTag, NULL, &tmpsts);
371 if (U_SUCCESS(tmpsts) && u_strlen(regionPattern) > 0) {
372 rpat.setTo(regionPattern, -1);
373 }
374 tmpsts = U_ZERO_ERROR;
375 const UChar *fallbackPattern = ures_getStringByKeyWithFallback(zoneStrings, gFallbackFormatTag, NULL, &tmpsts);
376 if (U_SUCCESS(tmpsts) && u_strlen(fallbackPattern) > 0) {
377 fpat.setTo(fallbackPattern, -1);
378 }
379 }
380 ures_close(zoneStrings);
381
382 fRegionFormat = new MessageFormat(rpat, status);
383 if (fRegionFormat == NULL) {
384 status = U_MEMORY_ALLOCATION_ERROR;
385 }
386 fFallbackFormat = new MessageFormat(fpat, status);
387 if (fFallbackFormat == NULL) {
388 status = U_MEMORY_ALLOCATION_ERROR;
389 }
390 if (U_FAILURE(status)) {
391 cleanup();
392 return;
393 }
394
395 // locale display names
396 fLocaleDisplayNames = LocaleDisplayNames::createInstance(locale);
397
398 // hash table for names - no key/value deleters
399 fLocationNamesMap = uhash_open(uhash_hashUChars, uhash_compareUChars, NULL, &status);
400 if (U_FAILURE(status)) {
401 cleanup();
402 return;
403 }
404
405 fPartialLocationNamesMap = uhash_open(hashPartialLocationKey, comparePartialLocationKey, NULL, &status);
406 if (U_FAILURE(status)) {
407 cleanup();
408 return;
409 }
410 uhash_setKeyDeleter(fPartialLocationNamesMap, uprv_free);
411 // no value deleter
412
413 // target region
414 const char* region = fLocale.getCountry();
415 int32_t regionLen = uprv_strlen(region);
416 if (regionLen == 0) {
417 char loc[ULOC_FULLNAME_CAPACITY];
418 uloc_addLikelySubtags(fLocale.getName(), loc, sizeof(loc), &status);
419
420 regionLen = uloc_getCountry(loc, fTargetRegion, sizeof(fTargetRegion), &status);
421 if (U_SUCCESS(status)) {
422 fTargetRegion[regionLen] = 0;
423 } else {
424 cleanup();
425 return;
426 }
427 } else if (regionLen < (int32_t)sizeof(fTargetRegion)) {
428 uprv_strcpy(fTargetRegion, region);
429 } else {
430 fTargetRegion[0] = 0;
431 }
432
433 // preload generic names for the default zone
434 TimeZone *tz = TimeZone::createDefault();
435 const UChar *tzID = ZoneMeta::getCanonicalCLDRID(*tz);
436 if (tzID != NULL) {
437 loadStrings(UnicodeString(tzID));
438 }
439 delete tz;
440 }
441
442 void
443 TZGNCore::cleanup() {
444 if (fRegionFormat != NULL) {
445 delete fRegionFormat;
446 }
447 if (fFallbackFormat != NULL) {
448 delete fFallbackFormat;
449 }
450 if (fLocaleDisplayNames != NULL) {
451 delete fLocaleDisplayNames;
452 }
453 if (fTimeZoneNames != NULL) {
454 delete fTimeZoneNames;
455 }
456
457 uhash_close(fLocationNamesMap);
458 uhash_close(fPartialLocationNamesMap);
459 }
460
461
462 UnicodeString&
463 TZGNCore::getDisplayName(const TimeZone& tz, UTimeZoneGenericNameType type, UDate date, UnicodeString& name) const {
464 name.setToBogus();
465 switch (type) {
466 case UTZGNM_LOCATION:
467 {
468 const UChar* tzCanonicalID = ZoneMeta::getCanonicalCLDRID(tz);
469 if (tzCanonicalID != NULL) {
470 getGenericLocationName(UnicodeString(tzCanonicalID), name);
471 }
472 }
473 break;
474 case UTZGNM_LONG:
475 case UTZGNM_SHORT:
476 formatGenericNonLocationName(tz, type, date, name);
477 if (name.isEmpty()) {
478 const UChar* tzCanonicalID = ZoneMeta::getCanonicalCLDRID(tz);
479 if (tzCanonicalID != NULL) {
480 getGenericLocationName(UnicodeString(tzCanonicalID), name);
481 }
482 }
483 break;
484 default:
485 break;
486 }
487 return name;
488 }
489
490 UnicodeString&
491 TZGNCore::getGenericLocationName(const UnicodeString& tzCanonicalID, UnicodeString& name) const {
492 if (tzCanonicalID.isEmpty()) {
493 name.setToBogus();
494 return name;
495 }
496
497 const UChar *locname = NULL;
498 TZGNCore *nonConstThis = const_cast<TZGNCore *>(this);
499 umtx_lock(&gLock);
500 {
501 locname = nonConstThis->getGenericLocationName(tzCanonicalID);
502 }
503 umtx_unlock(&gLock);
504
505 if (locname == NULL) {
506 name.setToBogus();
507 } else {
508 name.setTo(locname, u_strlen(locname));
509 }
510
511 return name;
512 }
513
514 /*
515 * This method updates the cache and must be called with a lock
516 */
517 const UChar*
518 TZGNCore::getGenericLocationName(const UnicodeString& tzCanonicalID) {
519 U_ASSERT(!tzCanonicalID.isEmpty());
520 if (tzCanonicalID.length() > ZID_KEY_MAX) {
521 return NULL;
522 }
523
524 UErrorCode status = U_ZERO_ERROR;
525 UChar tzIDKey[ZID_KEY_MAX + 1];
526 int32_t tzIDKeyLen = tzCanonicalID.extract(tzIDKey, ZID_KEY_MAX + 1, status);
527 U_ASSERT(status == U_ZERO_ERROR); // already checked length above
528 tzIDKey[tzIDKeyLen] = 0;
529
530 const UChar *locname = (const UChar *)uhash_get(fLocationNamesMap, tzIDKey);
531
532 if (locname != NULL) {
533 // gEmpty indicate the name is not available
534 if (locname == gEmpty) {
535 return NULL;
536 }
537 return locname;
538 }
539
540 // Construct location name
541 UnicodeString name;
542 UnicodeString usCountryCode;
543 UBool isPrimary = FALSE;
544
545 ZoneMeta::getCanonicalCountry(tzCanonicalID, usCountryCode, &isPrimary);
546
547 if (!usCountryCode.isEmpty()) {
548 FieldPosition fpos;
549
550 if (isPrimary) {
551 // If this is the primary zone in the country, use the country name.
552 char countryCode[ULOC_COUNTRY_CAPACITY];
553 U_ASSERT(usCountryCode.length() < ULOC_COUNTRY_CAPACITY);
554 int32_t ccLen = usCountryCode.extract(0, usCountryCode.length(), countryCode, sizeof(countryCode), US_INV);
555 countryCode[ccLen] = 0;
556
557 UnicodeString country;
558 fLocaleDisplayNames->regionDisplayName(countryCode, country);
559
560 Formattable param[] = {
561 Formattable(country)
562 };
563
564 fRegionFormat->format(param, 1, name, fpos, status);
565 } else {
566 // If this is not the primary zone in the country,
567 // use the exemplar city name.
568
569 // getExemplarLocationName should retur non-empty string
570 // if the time zone is associated with a region
571
572 UnicodeString city;
573 fTimeZoneNames->getExemplarLocationName(tzCanonicalID, city);
574
575 Formattable param[] = {
576 Formattable(city),
577 };
578
579 fRegionFormat->format(param, 1, name, fpos, status);
580 }
581 if (U_FAILURE(status)) {
582 return NULL;
583 }
584 }
585
586 locname = name.isEmpty() ? NULL : fStringPool.get(name, status);
587 if (U_SUCCESS(status)) {
588 // Cache the result
589 const UChar* cacheID = ZoneMeta::findTimeZoneID(tzCanonicalID);
590 U_ASSERT(cacheID != NULL);
591 if (locname == NULL) {
592 // gEmpty to indicate - no location name available
593 uhash_put(fLocationNamesMap, (void *)cacheID, (void *)gEmpty, &status);
594 } else {
595 uhash_put(fLocationNamesMap, (void *)cacheID, (void *)locname, &status);
596 if (U_FAILURE(status)) {
597 locname = NULL;
598 } else {
599 // put the name info into the trie
600 GNameInfo *nameinfo = (ZNameInfo *)uprv_malloc(sizeof(GNameInfo));
601 if (nameinfo != NULL) {
602 nameinfo->type = UTZGNM_LOCATION;
603 nameinfo->tzID = cacheID;
604 fGNamesTrie.put(locname, nameinfo, status);
605 }
606 }
607 }
608 }
609
610 return locname;
611 }
612
613 UnicodeString&
614 TZGNCore::formatGenericNonLocationName(const TimeZone& tz, UTimeZoneGenericNameType type, UDate date, UnicodeString& name) const {
615 U_ASSERT(type == UTZGNM_LONG || type == UTZGNM_SHORT);
616 name.setToBogus();
617
618 const UChar* uID = ZoneMeta::getCanonicalCLDRID(tz);
619 if (uID == NULL) {
620 return name;
621 }
622
623 UnicodeString tzID(uID);
624
625 // Try to get a name from time zone first
626 UTimeZoneNameType nameType = (type == UTZGNM_LONG) ? UTZNM_LONG_GENERIC : UTZNM_SHORT_GENERIC;
627 fTimeZoneNames->getTimeZoneDisplayName(tzID, nameType, name);
628
629 if (!name.isEmpty()) {
630 return name;
631 }
632
633 // Try meta zone
634 UnicodeString mzID;
635 fTimeZoneNames->getMetaZoneID(tzID, date, mzID);
636 if (!mzID.isEmpty()) {
637 UErrorCode status = U_ZERO_ERROR;
638 UBool useStandard = FALSE;
639 int32_t raw, sav;
640
641 tz.getOffset(date, FALSE, raw, sav, status);
642 if (U_FAILURE(status)) {
643 return name;
644 }
645
646 if (sav == 0) {
647 useStandard = TRUE;
648
649 TimeZone *tmptz = tz.clone();
650 // Check if the zone actually uses daylight saving time around the time
651 BasicTimeZone *btz = NULL;
652 if (dynamic_cast<OlsonTimeZone *>(tmptz) != NULL
653 || dynamic_cast<SimpleTimeZone *>(tmptz) != NULL
654 || dynamic_cast<RuleBasedTimeZone *>(tmptz) != NULL
655 || dynamic_cast<VTimeZone *>(tmptz) != NULL) {
656 btz = (BasicTimeZone*)tmptz;
657 }
658
659 if (btz != NULL) {
660 TimeZoneTransition before;
661 UBool beforTrs = btz->getPreviousTransition(date, TRUE, before);
662 if (beforTrs
663 && (date - before.getTime() < kDstCheckRange)
664 && before.getFrom()->getDSTSavings() != 0) {
665 useStandard = FALSE;
666 } else {
667 TimeZoneTransition after;
668 UBool afterTrs = btz->getNextTransition(date, FALSE, after);
669 if (afterTrs
670 && (after.getTime() - date < kDstCheckRange)
671 && after.getTo()->getDSTSavings() != 0) {
672 useStandard = FALSE;
673 }
674 }
675 } else {
676 // If not BasicTimeZone... only if the instance is not an ICU's implementation.
677 // We may get a wrong answer in edge case, but it should practically work OK.
678 tmptz->getOffset(date - kDstCheckRange, FALSE, raw, sav, status);
679 if (sav != 0) {
680 useStandard = FALSE;
681 } else {
682 tmptz->getOffset(date + kDstCheckRange, FALSE, raw, sav, status);
683 if (sav != 0){
684 useStandard = FALSE;
685 }
686 }
687 if (U_FAILURE(status)) {
688 delete tmptz;
689 return name;
690 }
691 }
692 delete tmptz;
693 }
694 if (useStandard) {
695 UTimeZoneNameType stdNameType = (nameType == UTZNM_LONG_GENERIC)
696 ? UTZNM_LONG_STANDARD : UTZNM_SHORT_STANDARD;
697 UnicodeString stdName;
698 fTimeZoneNames->getDisplayName(tzID, stdNameType, date, stdName);
699 if (!stdName.isEmpty()) {
700 name.setTo(stdName);
701
702 // TODO: revisit this issue later
703 // In CLDR, a same display name is used for both generic and standard
704 // for some meta zones in some locales. This looks like a data bugs.
705 // For now, we check if the standard name is different from its generic
706 // name below.
707 UnicodeString mzGenericName;
708 fTimeZoneNames->getMetaZoneDisplayName(mzID, nameType, mzGenericName);
709 if (stdName.caseCompare(mzGenericName, 0) == 0) {
710 name.setToBogus();
711 }
712 }
713 }
714 if (name.isEmpty()) {
715 // Get a name from meta zone
716 UnicodeString mzName;
717 fTimeZoneNames->getMetaZoneDisplayName(mzID, nameType, mzName);
718 if (!mzName.isEmpty()) {
719 // Check if we need to use a partial location format.
720 // This check is done by comparing offset with the meta zone's
721 // golden zone at the given date.
722 UnicodeString goldenID;
723 fTimeZoneNames->getReferenceZoneID(mzID, fTargetRegion, goldenID);
724 if (!goldenID.isEmpty() && goldenID != tzID) {
725 TimeZone *goldenZone = TimeZone::createTimeZone(goldenID);
726 int32_t raw1, sav1;
727
728 // Check offset in the golden zone with wall time.
729 // With getOffset(date, false, offsets1),
730 // you may get incorrect results because of time overlap at DST->STD
731 // transition.
732 goldenZone->getOffset(date + raw + sav, TRUE, raw1, sav1, status);
733 delete goldenZone;
734 if (U_SUCCESS(status)) {
735 if (raw != raw1 || sav != sav1) {
736 // Now we need to use a partial location format
737 getPartialLocationName(tzID, mzID, (nameType == UTZNM_LONG_GENERIC), mzName, name);
738 } else {
739 name.setTo(mzName);
740 }
741 }
742 } else {
743 name.setTo(mzName);
744 }
745 }
746 }
747 }
748 return name;
749 }
750
751 UnicodeString&
752 TZGNCore::getPartialLocationName(const UnicodeString& tzCanonicalID,
753 const UnicodeString& mzID, UBool isLong, const UnicodeString& mzDisplayName,
754 UnicodeString& name) const {
755 name.setToBogus();
756 if (tzCanonicalID.isEmpty() || mzID.isEmpty() || mzDisplayName.isEmpty()) {
757 return name;
758 }
759
760 const UChar *uplname = NULL;
761 TZGNCore *nonConstThis = const_cast<TZGNCore *>(this);
762 umtx_lock(&gLock);
763 {
764 uplname = nonConstThis->getPartialLocationName(tzCanonicalID, mzID, isLong, mzDisplayName);
765 }
766 umtx_unlock(&gLock);
767
768 if (uplname == NULL) {
769 name.setToBogus();
770 } else {
771 name.setTo(TRUE, uplname, -1);
772 }
773 return name;
774 }
775
776 /*
777 * This method updates the cache and must be called with a lock
778 */
779 const UChar*
780 TZGNCore::getPartialLocationName(const UnicodeString& tzCanonicalID,
781 const UnicodeString& mzID, UBool isLong, const UnicodeString& mzDisplayName) {
782 U_ASSERT(!tzCanonicalID.isEmpty());
783 U_ASSERT(!mzID.isEmpty());
784 U_ASSERT(!mzDisplayName.isEmpty());
785
786 PartialLocationKey key;
787 key.tzID = ZoneMeta::findTimeZoneID(tzCanonicalID);
788 key.mzID = ZoneMeta::findMetaZoneID(mzID);
789 key.isLong = isLong;
790 U_ASSERT(key.tzID != NULL && key.mzID != NULL);
791
792 const UChar* uplname = (const UChar*)uhash_get(fPartialLocationNamesMap, (void *)&key);
793 if (uplname != NULL) {
794 return uplname;
795 }
796
797 UnicodeString location;
798 UnicodeString usCountryCode;
799 ZoneMeta::getCanonicalCountry(tzCanonicalID, usCountryCode);
800 if (!usCountryCode.isEmpty()) {
801 char countryCode[ULOC_COUNTRY_CAPACITY];
802 U_ASSERT(usCountryCode.length() < ULOC_COUNTRY_CAPACITY);
803 int32_t ccLen = usCountryCode.extract(0, usCountryCode.length(), countryCode, sizeof(countryCode), US_INV);
804 countryCode[ccLen] = 0;
805
806 UnicodeString regionalGolden;
807 fTimeZoneNames->getReferenceZoneID(mzID, countryCode, regionalGolden);
808 if (tzCanonicalID == regionalGolden) {
809 // Use country name
810 fLocaleDisplayNames->regionDisplayName(countryCode, location);
811 } else {
812 // Otherwise, use exemplar city name
813 fTimeZoneNames->getExemplarLocationName(tzCanonicalID, location);
814 }
815 } else {
816 fTimeZoneNames->getExemplarLocationName(tzCanonicalID, location);
817 if (location.isEmpty()) {
818 // This could happen when the time zone is not associated with a country,
819 // and its ID is not hierarchical, for example, CST6CDT.
820 // We use the canonical ID itself as the location for this case.
821 location.setTo(tzCanonicalID);
822 }
823 }
824
825 UErrorCode status = U_ZERO_ERROR;
826 UnicodeString name;
827
828 FieldPosition fpos;
829 Formattable param[] = {
830 Formattable(location),
831 Formattable(mzDisplayName)
832 };
833 fFallbackFormat->format(param, 2, name, fpos, status);
834 if (U_FAILURE(status)) {
835 return NULL;
836 }
837
838 uplname = fStringPool.get(name, status);
839 if (U_SUCCESS(status)) {
840 // Add the name to cache
841 PartialLocationKey* cacheKey = (PartialLocationKey *)uprv_malloc(sizeof(PartialLocationKey));
842 if (cacheKey != NULL) {
843 cacheKey->tzID = key.tzID;
844 cacheKey->mzID = key.mzID;
845 cacheKey->isLong = key.isLong;
846 uhash_put(fPartialLocationNamesMap, (void *)cacheKey, (void *)uplname, &status);
847 if (U_FAILURE(status)) {
848 uprv_free(cacheKey);
849 } else {
850 // put the name to the local trie as well
851 GNameInfo *nameinfo = (ZNameInfo *)uprv_malloc(sizeof(GNameInfo));
852 if (nameinfo != NULL) {
853 nameinfo->type = isLong ? UTZGNM_LONG : UTZGNM_SHORT;
854 nameinfo->tzID = key.tzID;
855 fGNamesTrie.put(uplname, nameinfo, status);
856 }
857 }
858 }
859 }
860 return uplname;
861 }
862
863 /*
864 * This method updates the cache and must be called with a lock,
865 * except initializer.
866 */
867 void
868 TZGNCore::loadStrings(const UnicodeString& tzCanonicalID) {
869 // load the generic location name
870 getGenericLocationName(tzCanonicalID);
871
872 // partial location names
873 UErrorCode status = U_ZERO_ERROR;
874
875 const UnicodeString *mzID;
876 UnicodeString goldenID;
877 UnicodeString mzGenName;
878 UTimeZoneNameType genNonLocTypes[] = {
879 UTZNM_LONG_GENERIC, UTZNM_SHORT_GENERIC,
880 UTZNM_UNKNOWN /*terminator*/
881 };
882
883 StringEnumeration *mzIDs = fTimeZoneNames->getAvailableMetaZoneIDs(tzCanonicalID, status);
884 while ((mzID = mzIDs->snext(status))) {
885 if (U_FAILURE(status)) {
886 break;
887 }
888 // if this time zone is not the golden zone of the meta zone,
889 // partial location name (such as "PT (Los Angeles)") might be
890 // available.
891 fTimeZoneNames->getReferenceZoneID(*mzID, fTargetRegion, goldenID);
892 if (tzCanonicalID != goldenID) {
893 for (int32_t i = 0; genNonLocTypes[i] != UTZNM_UNKNOWN; i++) {
894 fTimeZoneNames->getMetaZoneDisplayName(*mzID, genNonLocTypes[i], mzGenName);
895 if (!mzGenName.isEmpty()) {
896 // getPartialLocationName formats a name and put it into the trie
897 getPartialLocationName(tzCanonicalID, *mzID,
898 (genNonLocTypes[i] == UTZNM_LONG_GENERIC), mzGenName);
899 }
900 }
901 }
902 }
903 if (mzIDs != NULL) {
904 delete mzIDs;
905 }
906 }
907
908 int32_t
909 TZGNCore::findBestMatch(const UnicodeString& text, int32_t start, uint32_t types,
910 UnicodeString& tzID, UTimeZoneFormatTimeType& timeType, UErrorCode& status) const {
911 timeType = UTZFMT_TIME_TYPE_UNKNOWN;
912 tzID.setToBogus();
913
914 if (U_FAILURE(status)) {
915 return 0;
916 }
917
918 // Find matches in the TimeZoneNames first
919 TimeZoneNames::MatchInfoCollection *tznamesMatches = findTimeZoneNames(text, start, types, status);
920 if (U_FAILURE(status)) {
921 return 0;
922 }
923
924 int32_t bestMatchLen = 0;
925 UTimeZoneFormatTimeType bestMatchTimeType = UTZFMT_TIME_TYPE_UNKNOWN;
926 UnicodeString bestMatchTzID;
927 // UBool isLongStandard = FALSE; // workaround - see the comments below
928 UBool isStandard = FALSE; // TODO: Temporary hack (on hack) for short standard name/location name conflict (found in zh_Hant), should be removed after CLDR 21m1 integration
929
930 if (tznamesMatches != NULL) {
931 UnicodeString mzID;
932 for (int32_t i = 0; i < tznamesMatches->size(); i++) {
933 int32_t len = tznamesMatches->getMatchLengthAt(i);
934 if (len > bestMatchLen) {
935 bestMatchLen = len;
936 if (!tznamesMatches->getTimeZoneIDAt(i, bestMatchTzID)) {
937 // name for a meta zone
938 if (tznamesMatches->getMetaZoneIDAt(i, mzID)) {
939 fTimeZoneNames->getReferenceZoneID(mzID, fTargetRegion, bestMatchTzID);
940 }
941 }
942 UTimeZoneNameType nameType = tznamesMatches->getNameTypeAt(i);
943 if (U_FAILURE(status)) {
944 break;
945 }
946 switch (nameType) {
947 case UTZNM_LONG_STANDARD:
948 // isLongStandard = TRUE;
949 case UTZNM_SHORT_STANDARD: // this one is never used for generic, but just in case
950 isStandard = TRUE; // TODO: Remove this later, see the comments above.
951 bestMatchTimeType = UTZFMT_TIME_TYPE_STANDARD;
952 break;
953 case UTZNM_LONG_DAYLIGHT:
954 case UTZNM_SHORT_DAYLIGHT: // this one is never used for generic, but just in case
955 bestMatchTimeType = UTZFMT_TIME_TYPE_DAYLIGHT;
956 break;
957 default:
958 bestMatchTimeType = UTZFMT_TIME_TYPE_UNKNOWN;
959 }
960 }
961 }
962 delete tznamesMatches;
963 if (U_FAILURE(status)) {
964 return 0;
965 }
966
967 if (bestMatchLen == (text.length() - start)) {
968 // Full match
969
970 //tzID.setTo(bestMatchTzID);
971 //timeType = bestMatchTimeType;
972 //return bestMatchLen;
973
974 // TODO Some time zone uses a same name for the long standard name
975 // and the location name. When the match is a long standard name,
976 // then we need to check if the name is same with the location name.
977 // This is probably a data error or a design bug.
978 /*
979 if (!isLongStandard) {
980 tzID.setTo(bestMatchTzID);
981 timeType = bestMatchTimeType;
982 return bestMatchLen;
983 }
984 */
985 // TODO The deprecation of commonlyUsed flag introduced the name
986 // conflict not only for long standard names, but short standard names too.
987 // These short names (found in zh_Hant) should be gone once we clean
988 // up CLDR time zone display name data. Once the short name conflict
989 // problem (with location name) is resolved, we should change the condition
990 // below back to the original one above. -Yoshito (2011-09-14)
991 if (!isStandard) {
992 tzID.setTo(bestMatchTzID);
993 timeType = bestMatchTimeType;
994 return bestMatchLen;
995 }
996 }
997 }
998
999 // Find matches in the local trie
1000 TimeZoneGenericNameMatchInfo *localMatches = findLocal(text, start, types, status);
1001 if (U_FAILURE(status)) {
1002 return 0;
1003 }
1004 if (localMatches != NULL) {
1005 for (int32_t i = 0; i < localMatches->size(); i++) {
1006 int32_t len = localMatches->getMatchLength(i);
1007
1008 // TODO See the above TODO. We use len >= bestMatchLen
1009 // because of the long standard/location name collision
1010 // problem. If it is also a location name, carrying
1011 // timeType = UTZFMT_TIME_TYPE_STANDARD will cause a
1012 // problem in SimpleDateFormat
1013 if (len >= bestMatchLen) {
1014 bestMatchLen = localMatches->getMatchLength(i);
1015 bestMatchTimeType = UTZFMT_TIME_TYPE_UNKNOWN; // because generic
1016 localMatches->getTimeZoneID(i, bestMatchTzID);
1017 }
1018 }
1019 delete localMatches;
1020 }
1021
1022 if (bestMatchLen > 0) {
1023 timeType = bestMatchTimeType;
1024 tzID.setTo(bestMatchTzID);
1025 }
1026 return bestMatchLen;
1027 }
1028
1029 TimeZoneGenericNameMatchInfo*
1030 TZGNCore::findLocal(const UnicodeString& text, int32_t start, uint32_t types, UErrorCode& status) const {
1031 GNameSearchHandler handler(types);
1032
1033 TZGNCore *nonConstThis = const_cast<TZGNCore *>(this);
1034
1035 umtx_lock(&gLock);
1036 {
1037 fGNamesTrie.search(text, start, (TextTrieMapSearchResultHandler *)&handler, status);
1038 }
1039 umtx_unlock(&gLock);
1040
1041 if (U_FAILURE(status)) {
1042 return NULL;
1043 }
1044
1045 TimeZoneGenericNameMatchInfo *gmatchInfo = NULL;
1046
1047 int32_t maxLen = 0;
1048 UVector *results = handler.getMatches(maxLen);
1049 if (results != NULL && ((maxLen == (text.length() - start)) || fGNamesTrieFullyLoaded)) {
1050 // perfect match
1051 gmatchInfo = new TimeZoneGenericNameMatchInfo(results);
1052 if (gmatchInfo == NULL) {
1053 status = U_MEMORY_ALLOCATION_ERROR;
1054 delete results;
1055 return NULL;
1056 }
1057 return gmatchInfo;
1058 }
1059
1060 if (results != NULL) {
1061 delete results;
1062 }
1063
1064 // All names are not yet loaded into the local trie.
1065 // Load all available names into the trie. This could be very heavy.
1066 umtx_lock(&gLock);
1067 {
1068 if (!fGNamesTrieFullyLoaded) {
1069 StringEnumeration *tzIDs = TimeZone::createTimeZoneIDEnumeration(UCAL_ZONE_TYPE_CANONICAL, NULL, NULL, status);
1070 if (U_SUCCESS(status)) {
1071 const UnicodeString *tzID;
1072 while ((tzID = tzIDs->snext(status))) {
1073 if (U_FAILURE(status)) {
1074 break;
1075 }
1076 nonConstThis->loadStrings(*tzID);
1077 }
1078 }
1079 if (tzIDs != NULL) {
1080 delete tzIDs;
1081 }
1082
1083 if (U_SUCCESS(status)) {
1084 nonConstThis->fGNamesTrieFullyLoaded = TRUE;
1085 }
1086 }
1087 }
1088 umtx_unlock(&gLock);
1089
1090 if (U_FAILURE(status)) {
1091 return NULL;
1092 }
1093
1094 umtx_lock(&gLock);
1095 {
1096 // now try it again
1097 fGNamesTrie.search(text, start, (TextTrieMapSearchResultHandler *)&handler, status);
1098 }
1099 umtx_unlock(&gLock);
1100
1101 results = handler.getMatches(maxLen);
1102 if (results != NULL && maxLen > 0) {
1103 gmatchInfo = new TimeZoneGenericNameMatchInfo(results);
1104 if (gmatchInfo == NULL) {
1105 status = U_MEMORY_ALLOCATION_ERROR;
1106 delete results;
1107 return NULL;
1108 }
1109 }
1110
1111 return gmatchInfo;
1112 }
1113
1114 TimeZoneNames::MatchInfoCollection*
1115 TZGNCore::findTimeZoneNames(const UnicodeString& text, int32_t start, uint32_t types, UErrorCode& status) const {
1116 // Check if the target name typs is really in the TimeZoneNames
1117 uint32_t nameTypes = 0;
1118 if (types & UTZGNM_LONG) {
1119 nameTypes |= (UTZNM_LONG_GENERIC | UTZNM_LONG_STANDARD);
1120 }
1121 if (types & UTZGNM_SHORT) {
1122 nameTypes |= (UTZNM_SHORT_GENERIC | UTZNM_SHORT_STANDARD);
1123 }
1124
1125 if (types) {
1126 // Find matches in the TimeZoneNames
1127 return fTimeZoneNames->find(text, start, nameTypes, status);
1128 }
1129
1130 return NULL;
1131 }
1132
1133 typedef struct TZGNCoreRef {
1134 TZGNCore* obj;
1135 int32_t refCount;
1136 double lastAccess;
1137 } TZGNCoreRef;
1138
1139 // TZGNCore object cache handling
1140 static UMutex gTZGNLock = U_MUTEX_INITIALIZER;
1141 static UHashtable *gTZGNCoreCache = NULL;
1142 static UBool gTZGNCoreCacheInitialized = FALSE;
1143
1144 // Access count - incremented every time up to SWEEP_INTERVAL,
1145 // then reset to 0
1146 static int32_t gAccessCount = 0;
1147
1148 // Interval for calling the cache sweep function - every 100 times
1149 #define SWEEP_INTERVAL 100
1150
1151 // Cache expiration in millisecond. When a cached entry is no
1152 // longer referenced and exceeding this threshold since last
1153 // access time, then the cache entry will be deleted by the sweep
1154 // function. For now, 3 minutes.
1155 #define CACHE_EXPIRATION 180000.0
1156
1157 U_CDECL_BEGIN
1158 /**
1159 * Cleanup callback func
1160 */
1161 static UBool U_CALLCONV tzgnCore_cleanup(void)
1162 {
1163 if (gTZGNCoreCache != NULL) {
1164 uhash_close(gTZGNCoreCache);
1165 gTZGNCoreCache = NULL;
1166 }
1167 gTZGNCoreCacheInitialized = FALSE;
1168 return TRUE;
1169 }
1170
1171 /**
1172 * Deleter for TZGNCoreRef
1173 */
1174 static void U_CALLCONV
1175 deleteTZGNCoreRef(void *obj) {
1176 icu::TZGNCoreRef *entry = (icu::TZGNCoreRef*)obj;
1177 delete (icu::TZGNCore*) entry->obj;
1178 uprv_free(entry);
1179 }
1180 U_CDECL_END
1181
1182 /**
1183 * Function used for removing unreferrenced cache entries exceeding
1184 * the expiration time. This function must be called with in the mutex
1185 * block.
1186 */
1187 static void sweepCache() {
1188 int32_t pos = -1;
1189 const UHashElement* elem;
1190 double now = (double)uprv_getUTCtime();
1191
1192 while ((elem = uhash_nextElement(gTZGNCoreCache, &pos))) {
1193 TZGNCoreRef *entry = (TZGNCoreRef *)elem->value.pointer;
1194 if (entry->refCount <= 0 && (now - entry->lastAccess) > CACHE_EXPIRATION) {
1195 // delete this entry
1196 uhash_removeElement(gTZGNCoreCache, elem);
1197 }
1198 }
1199 }
1200
1201 TimeZoneGenericNames::TimeZoneGenericNames()
1202 : fRef(0) {
1203 }
1204
1205 TimeZoneGenericNames::~TimeZoneGenericNames() {
1206 umtx_lock(&gTZGNLock);
1207 {
1208 U_ASSERT(fRef->refCount > 0);
1209 // Just decrement the reference count
1210 fRef->refCount--;
1211 }
1212 umtx_unlock(&gTZGNLock);
1213 }
1214
1215 TimeZoneGenericNames*
1216 TimeZoneGenericNames::createInstance(const Locale& locale, UErrorCode& status) {
1217 if (U_FAILURE(status)) {
1218 return NULL;
1219 }
1220 TimeZoneGenericNames* instance = new TimeZoneGenericNames();
1221 if (instance == NULL) {
1222 status = U_MEMORY_ALLOCATION_ERROR;
1223 return NULL;
1224 }
1225
1226 TZGNCoreRef *cacheEntry = NULL;
1227 {
1228 Mutex lock(&gTZGNLock);
1229
1230 if (!gTZGNCoreCacheInitialized) {
1231 // Create empty hashtable
1232 gTZGNCoreCache = uhash_open(uhash_hashChars, uhash_compareChars, NULL, &status);
1233 if (U_SUCCESS(status)) {
1234 uhash_setKeyDeleter(gTZGNCoreCache, uprv_free);
1235 uhash_setValueDeleter(gTZGNCoreCache, deleteTZGNCoreRef);
1236 gTZGNCoreCacheInitialized = TRUE;
1237 ucln_i18n_registerCleanup(UCLN_I18N_TIMEZONEGENERICNAMES, tzgnCore_cleanup);
1238 }
1239 }
1240 if (U_FAILURE(status)) {
1241 return NULL;
1242 }
1243
1244 // Check the cache, if not available, create new one and cache
1245 const char *key = locale.getName();
1246 cacheEntry = (TZGNCoreRef *)uhash_get(gTZGNCoreCache, key);
1247 if (cacheEntry == NULL) {
1248 TZGNCore *tzgnCore = NULL;
1249 char *newKey = NULL;
1250
1251 tzgnCore = new TZGNCore(locale, status);
1252 if (tzgnCore == NULL) {
1253 status = U_MEMORY_ALLOCATION_ERROR;
1254 }
1255 if (U_SUCCESS(status)) {
1256 newKey = (char *)uprv_malloc(uprv_strlen(key) + 1);
1257 if (newKey == NULL) {
1258 status = U_MEMORY_ALLOCATION_ERROR;
1259 } else {
1260 uprv_strcpy(newKey, key);
1261 }
1262 }
1263 if (U_SUCCESS(status)) {
1264 cacheEntry = (TZGNCoreRef *)uprv_malloc(sizeof(TZGNCoreRef));
1265 if (cacheEntry == NULL) {
1266 status = U_MEMORY_ALLOCATION_ERROR;
1267 } else {
1268 cacheEntry->obj = tzgnCore;
1269 cacheEntry->refCount = 1;
1270 cacheEntry->lastAccess = (double)uprv_getUTCtime();
1271
1272 uhash_put(gTZGNCoreCache, newKey, cacheEntry, &status);
1273 }
1274 }
1275 if (U_FAILURE(status)) {
1276 if (tzgnCore != NULL) {
1277 delete tzgnCore;
1278 }
1279 if (newKey != NULL) {
1280 uprv_free(newKey);
1281 }
1282 if (cacheEntry != NULL) {
1283 uprv_free(cacheEntry);
1284 }
1285 cacheEntry = NULL;
1286 }
1287 } else {
1288 // Update the reference count
1289 cacheEntry->refCount++;
1290 cacheEntry->lastAccess = (double)uprv_getUTCtime();
1291 }
1292 gAccessCount++;
1293 if (gAccessCount >= SWEEP_INTERVAL) {
1294 // sweep
1295 sweepCache();
1296 gAccessCount = 0;
1297 }
1298 } // End of mutex locked block
1299
1300 if (cacheEntry == NULL) {
1301 delete instance;
1302 return NULL;
1303 }
1304
1305 instance->fRef = cacheEntry;
1306 return instance;
1307 }
1308
1309 UBool
1310 TimeZoneGenericNames::operator==(const TimeZoneGenericNames& other) const {
1311 // Just compare if the other object also use the same
1312 // ref entry
1313 return fRef == other.fRef;
1314 }
1315
1316 TimeZoneGenericNames*
1317 TimeZoneGenericNames::clone() const {
1318 TimeZoneGenericNames* other = new TimeZoneGenericNames();
1319 if (other) {
1320 umtx_lock(&gTZGNLock);
1321 {
1322 // Just increments the reference count
1323 fRef->refCount++;
1324 other->fRef = fRef;
1325 }
1326 umtx_unlock(&gTZGNLock);
1327 }
1328 return other;
1329 }
1330
1331 UnicodeString&
1332 TimeZoneGenericNames::getDisplayName(const TimeZone& tz, UTimeZoneGenericNameType type,
1333 UDate date, UnicodeString& name) const {
1334 return fRef->obj->getDisplayName(tz, type, date, name);
1335 }
1336
1337 UnicodeString&
1338 TimeZoneGenericNames::getGenericLocationName(const UnicodeString& tzCanonicalID, UnicodeString& name) const {
1339 return fRef->obj->getGenericLocationName(tzCanonicalID, name);
1340 }
1341
1342 int32_t
1343 TimeZoneGenericNames::findBestMatch(const UnicodeString& text, int32_t start, uint32_t types,
1344 UnicodeString& tzID, UTimeZoneFormatTimeType& timeType, UErrorCode& status) const {
1345 return fRef->obj->findBestMatch(text, start, types, tzID, timeType, status);
1346 }
1347
1348 U_NAMESPACE_END
1349 #endif

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial