1 // © 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /*
4 *******************************************************************************
5 * Copyright (C) 2011-2015, International Business Machines Corporation and *
6 * others. All Rights Reserved. *
7 *******************************************************************************
8 */
9
10 #include "unicode/utypes.h"
11
12 #if !UCONFIG_NO_FORMATTING
13
14 #include "unicode/locid.h"
15 #include "unicode/tznames.h"
16 #include "unicode/uenum.h"
17 #include "cmemory.h"
18 #include "cstring.h"
19 #include "mutex.h"
20 #include "putilimp.h"
21 #include "tznames_impl.h"
22 #include "uassert.h"
23 #include "ucln_in.h"
24 #include "uhash.h"
25 #include "umutex.h"
26 #include "uvector.h"
27
28
29 U_NAMESPACE_BEGIN
30
31 // TimeZoneNames object cache handling
32 static UMutex gTimeZoneNamesLock = U_MUTEX_INITIALIZER;
33 static UHashtable *gTimeZoneNamesCache = NULL;
34 static UBool gTimeZoneNamesCacheInitialized = FALSE;
35
36 // Access count - incremented every time up to SWEEP_INTERVAL,
37 // then reset to 0
38 static int32_t gAccessCount = 0;
39
40 // Interval for calling the cache sweep function - every 100 times
41 #define SWEEP_INTERVAL 100
42
43 // Cache expiration in millisecond. When a cached entry is no
44 // longer referenced and exceeding this threshold since last
45 // access time, then the cache entry will be deleted by the sweep
46 // function. For now, 3 minutes.
47 #define CACHE_EXPIRATION 180000.0
48
49 typedef struct TimeZoneNamesCacheEntry {
50 TimeZoneNames* names;
51 int32_t refCount;
52 double lastAccess;
53 } TimeZoneNamesCacheEntry;
54
55 U_CDECL_BEGIN
56 /**
57 * Cleanup callback func
58 */
timeZoneNames_cleanup(void)59 static UBool U_CALLCONV timeZoneNames_cleanup(void)
60 {
61 if (gTimeZoneNamesCache != NULL) {
62 uhash_close(gTimeZoneNamesCache);
63 gTimeZoneNamesCache = NULL;
64 }
65 gTimeZoneNamesCacheInitialized = FALSE;
66 return TRUE;
67 }
68
69 /**
70 * Deleter for TimeZoneNamesCacheEntry
71 */
72 static void U_CALLCONV
deleteTimeZoneNamesCacheEntry(void * obj)73 deleteTimeZoneNamesCacheEntry(void *obj) {
74 icu::TimeZoneNamesCacheEntry *entry = (icu::TimeZoneNamesCacheEntry*)obj;
75 delete (icu::TimeZoneNamesImpl*) entry->names;
76 uprv_free(entry);
77 }
78 U_CDECL_END
79
80 /**
81 * Function used for removing unreferrenced cache entries exceeding
82 * the expiration time. This function must be called with in the mutex
83 * block.
84 */
sweepCache()85 static void sweepCache() {
86 int32_t pos = UHASH_FIRST;
87 const UHashElement* elem;
88 double now = (double)uprv_getUTCtime();
89
90 while ((elem = uhash_nextElement(gTimeZoneNamesCache, &pos)) != 0) {
91 TimeZoneNamesCacheEntry *entry = (TimeZoneNamesCacheEntry *)elem->value.pointer;
92 if (entry->refCount <= 0 && (now - entry->lastAccess) > CACHE_EXPIRATION) {
93 // delete this entry
94 uhash_removeElement(gTimeZoneNamesCache, elem);
95 }
96 }
97 }
98
99 // ---------------------------------------------------
100 // TimeZoneNamesDelegate
101 // ---------------------------------------------------
102 class TimeZoneNamesDelegate : public TimeZoneNames {
103 public:
104 TimeZoneNamesDelegate(const Locale& locale, UErrorCode& status);
105 virtual ~TimeZoneNamesDelegate();
106
107 virtual UBool operator==(const TimeZoneNames& other) const;
operator !=(const TimeZoneNames & other) const108 virtual UBool operator!=(const TimeZoneNames& other) const {return !operator==(other);};
109 virtual TimeZoneNames* clone() const;
110
111 StringEnumeration* getAvailableMetaZoneIDs(UErrorCode& status) const;
112 StringEnumeration* getAvailableMetaZoneIDs(const UnicodeString& tzID, UErrorCode& status) const;
113 UnicodeString& getMetaZoneID(const UnicodeString& tzID, UDate date, UnicodeString& mzID) const;
114 UnicodeString& getReferenceZoneID(const UnicodeString& mzID, const char* region, UnicodeString& tzID) const;
115
116 UnicodeString& getMetaZoneDisplayName(const UnicodeString& mzID, UTimeZoneNameType type, UnicodeString& name) const;
117 UnicodeString& getTimeZoneDisplayName(const UnicodeString& tzID, UTimeZoneNameType type, UnicodeString& name) const;
118
119 UnicodeString& getExemplarLocationName(const UnicodeString& tzID, UnicodeString& name) const;
120
121 void loadAllDisplayNames(UErrorCode& status);
122 void getDisplayNames(const UnicodeString& tzID, const UTimeZoneNameType types[], int32_t numTypes, UDate date, UnicodeString dest[], UErrorCode& status) const;
123
124 MatchInfoCollection* find(const UnicodeString& text, int32_t start, uint32_t types, UErrorCode& status) const;
125 private:
126 TimeZoneNamesDelegate();
127 TimeZoneNamesCacheEntry* fTZnamesCacheEntry;
128 };
129
TimeZoneNamesDelegate()130 TimeZoneNamesDelegate::TimeZoneNamesDelegate()
131 : fTZnamesCacheEntry(0) {
132 }
133
TimeZoneNamesDelegate(const Locale & locale,UErrorCode & status)134 TimeZoneNamesDelegate::TimeZoneNamesDelegate(const Locale& locale, UErrorCode& status) {
135 Mutex lock(&gTimeZoneNamesLock);
136 if (!gTimeZoneNamesCacheInitialized) {
137 // Create empty hashtable if it is not already initialized.
138 gTimeZoneNamesCache = uhash_open(uhash_hashChars, uhash_compareChars, NULL, &status);
139 if (U_SUCCESS(status)) {
140 uhash_setKeyDeleter(gTimeZoneNamesCache, uprv_free);
141 uhash_setValueDeleter(gTimeZoneNamesCache, deleteTimeZoneNamesCacheEntry);
142 gTimeZoneNamesCacheInitialized = TRUE;
143 ucln_i18n_registerCleanup(UCLN_I18N_TIMEZONENAMES, timeZoneNames_cleanup);
144 }
145 }
146
147 if (U_FAILURE(status)) {
148 return;
149 }
150
151 // Check the cache, if not available, create new one and cache
152 TimeZoneNamesCacheEntry *cacheEntry = NULL;
153
154 const char *key = locale.getName();
155 cacheEntry = (TimeZoneNamesCacheEntry *)uhash_get(gTimeZoneNamesCache, key);
156 if (cacheEntry == NULL) {
157 TimeZoneNames *tznames = NULL;
158 char *newKey = NULL;
159
160 tznames = new TimeZoneNamesImpl(locale, status);
161 if (tznames == NULL) {
162 status = U_MEMORY_ALLOCATION_ERROR;
163 }
164 if (U_SUCCESS(status)) {
165 newKey = (char *)uprv_malloc(uprv_strlen(key) + 1);
166 if (newKey == NULL) {
167 status = U_MEMORY_ALLOCATION_ERROR;
168 } else {
169 uprv_strcpy(newKey, key);
170 }
171 }
172 if (U_SUCCESS(status)) {
173 cacheEntry = (TimeZoneNamesCacheEntry *)uprv_malloc(sizeof(TimeZoneNamesCacheEntry));
174 if (cacheEntry == NULL) {
175 status = U_MEMORY_ALLOCATION_ERROR;
176 } else {
177 cacheEntry->names = tznames;
178 cacheEntry->refCount = 1;
179 cacheEntry->lastAccess = (double)uprv_getUTCtime();
180
181 uhash_put(gTimeZoneNamesCache, newKey, cacheEntry, &status);
182 }
183 }
184 if (U_FAILURE(status)) {
185 if (tznames != NULL) {
186 delete tznames;
187 }
188 if (newKey != NULL) {
189 uprv_free(newKey);
190 }
191 if (cacheEntry != NULL) {
192 uprv_free(cacheEntry);
193 }
194 cacheEntry = NULL;
195 }
196 } else {
197 // Update the reference count
198 cacheEntry->refCount++;
199 cacheEntry->lastAccess = (double)uprv_getUTCtime();
200 }
201 gAccessCount++;
202 if (gAccessCount >= SWEEP_INTERVAL) {
203 // sweep
204 sweepCache();
205 gAccessCount = 0;
206 }
207 fTZnamesCacheEntry = cacheEntry;
208 }
209
~TimeZoneNamesDelegate()210 TimeZoneNamesDelegate::~TimeZoneNamesDelegate() {
211 umtx_lock(&gTimeZoneNamesLock);
212 {
213 if (fTZnamesCacheEntry) {
214 U_ASSERT(fTZnamesCacheEntry->refCount > 0);
215 // Just decrement the reference count
216 fTZnamesCacheEntry->refCount--;
217 }
218 }
219 umtx_unlock(&gTimeZoneNamesLock);
220 }
221
222 UBool
operator ==(const TimeZoneNames & other) const223 TimeZoneNamesDelegate::operator==(const TimeZoneNames& other) const {
224 if (this == &other) {
225 return TRUE;
226 }
227 // Just compare if the other object also use the same
228 // cache entry
229 const TimeZoneNamesDelegate* rhs = dynamic_cast<const TimeZoneNamesDelegate*>(&other);
230 if (rhs) {
231 return fTZnamesCacheEntry == rhs->fTZnamesCacheEntry;
232 }
233 return FALSE;
234 }
235
236 TimeZoneNames*
clone() const237 TimeZoneNamesDelegate::clone() const {
238 TimeZoneNamesDelegate* other = new TimeZoneNamesDelegate();
239 if (other != NULL) {
240 umtx_lock(&gTimeZoneNamesLock);
241 {
242 // Just increment the reference count
243 fTZnamesCacheEntry->refCount++;
244 other->fTZnamesCacheEntry = fTZnamesCacheEntry;
245 }
246 umtx_unlock(&gTimeZoneNamesLock);
247 }
248 return other;
249 }
250
251 StringEnumeration*
getAvailableMetaZoneIDs(UErrorCode & status) const252 TimeZoneNamesDelegate::getAvailableMetaZoneIDs(UErrorCode& status) const {
253 return fTZnamesCacheEntry->names->getAvailableMetaZoneIDs(status);
254 }
255
256 StringEnumeration*
getAvailableMetaZoneIDs(const UnicodeString & tzID,UErrorCode & status) const257 TimeZoneNamesDelegate::getAvailableMetaZoneIDs(const UnicodeString& tzID, UErrorCode& status) const {
258 return fTZnamesCacheEntry->names->getAvailableMetaZoneIDs(tzID, status);
259 }
260
261 UnicodeString&
getMetaZoneID(const UnicodeString & tzID,UDate date,UnicodeString & mzID) const262 TimeZoneNamesDelegate::getMetaZoneID(const UnicodeString& tzID, UDate date, UnicodeString& mzID) const {
263 return fTZnamesCacheEntry->names->getMetaZoneID(tzID, date, mzID);
264 }
265
266 UnicodeString&
getReferenceZoneID(const UnicodeString & mzID,const char * region,UnicodeString & tzID) const267 TimeZoneNamesDelegate::getReferenceZoneID(const UnicodeString& mzID, const char* region, UnicodeString& tzID) const {
268 return fTZnamesCacheEntry->names->getReferenceZoneID(mzID, region, tzID);
269 }
270
271 UnicodeString&
getMetaZoneDisplayName(const UnicodeString & mzID,UTimeZoneNameType type,UnicodeString & name) const272 TimeZoneNamesDelegate::getMetaZoneDisplayName(const UnicodeString& mzID, UTimeZoneNameType type, UnicodeString& name) const {
273 return fTZnamesCacheEntry->names->getMetaZoneDisplayName(mzID, type, name);
274 }
275
276 UnicodeString&
getTimeZoneDisplayName(const UnicodeString & tzID,UTimeZoneNameType type,UnicodeString & name) const277 TimeZoneNamesDelegate::getTimeZoneDisplayName(const UnicodeString& tzID, UTimeZoneNameType type, UnicodeString& name) const {
278 return fTZnamesCacheEntry->names->getTimeZoneDisplayName(tzID, type, name);
279 }
280
281 UnicodeString&
getExemplarLocationName(const UnicodeString & tzID,UnicodeString & name) const282 TimeZoneNamesDelegate::getExemplarLocationName(const UnicodeString& tzID, UnicodeString& name) const {
283 return fTZnamesCacheEntry->names->getExemplarLocationName(tzID, name);
284 }
285
286 void
loadAllDisplayNames(UErrorCode & status)287 TimeZoneNamesDelegate::loadAllDisplayNames(UErrorCode& status) {
288 fTZnamesCacheEntry->names->loadAllDisplayNames(status);
289 }
290
291 void
getDisplayNames(const UnicodeString & tzID,const UTimeZoneNameType types[],int32_t numTypes,UDate date,UnicodeString dest[],UErrorCode & status) const292 TimeZoneNamesDelegate::getDisplayNames(const UnicodeString& tzID, const UTimeZoneNameType types[], int32_t numTypes, UDate date, UnicodeString dest[], UErrorCode& status) const {
293 fTZnamesCacheEntry->names->getDisplayNames(tzID, types, numTypes, date, dest, status);
294 }
295
296 TimeZoneNames::MatchInfoCollection*
find(const UnicodeString & text,int32_t start,uint32_t types,UErrorCode & status) const297 TimeZoneNamesDelegate::find(const UnicodeString& text, int32_t start, uint32_t types, UErrorCode& status) const {
298 return fTZnamesCacheEntry->names->find(text, start, types, status);
299 }
300
301 // ---------------------------------------------------
302 // TimeZoneNames base class
303 // ---------------------------------------------------
~TimeZoneNames()304 TimeZoneNames::~TimeZoneNames() {
305 }
306
307 TimeZoneNames*
createInstance(const Locale & locale,UErrorCode & status)308 TimeZoneNames::createInstance(const Locale& locale, UErrorCode& status) {
309 TimeZoneNames *instance = NULL;
310 if (U_SUCCESS(status)) {
311 instance = new TimeZoneNamesDelegate(locale, status);
312 if (instance == NULL && U_SUCCESS(status)) {
313 status = U_MEMORY_ALLOCATION_ERROR;
314 }
315 }
316 return instance;
317 }
318
319 TimeZoneNames*
createTZDBInstance(const Locale & locale,UErrorCode & status)320 TimeZoneNames::createTZDBInstance(const Locale& locale, UErrorCode& status) {
321 TimeZoneNames *instance = NULL;
322 if (U_SUCCESS(status)) {
323 instance = new TZDBTimeZoneNames(locale);
324 if (instance == NULL && U_SUCCESS(status)) {
325 status = U_MEMORY_ALLOCATION_ERROR;
326 }
327 }
328 return instance;
329 }
330
331 UnicodeString&
getExemplarLocationName(const UnicodeString & tzID,UnicodeString & name) const332 TimeZoneNames::getExemplarLocationName(const UnicodeString& tzID, UnicodeString& name) const {
333 return TimeZoneNamesImpl::getDefaultExemplarLocationName(tzID, name);
334 }
335
336 UnicodeString&
getDisplayName(const UnicodeString & tzID,UTimeZoneNameType type,UDate date,UnicodeString & name) const337 TimeZoneNames::getDisplayName(const UnicodeString& tzID, UTimeZoneNameType type, UDate date, UnicodeString& name) const {
338 getTimeZoneDisplayName(tzID, type, name);
339 if (name.isEmpty()) {
340 UChar mzIDBuf[32];
341 UnicodeString mzID(mzIDBuf, 0, UPRV_LENGTHOF(mzIDBuf));
342 getMetaZoneID(tzID, date, mzID);
343 getMetaZoneDisplayName(mzID, type, name);
344 }
345 return name;
346 }
347
348 // Empty default implementation, to be overriden in tznames_impl.cpp.
349 void
loadAllDisplayNames(UErrorCode &)350 TimeZoneNames::loadAllDisplayNames(UErrorCode& /*status*/) {
351 }
352
353 // A default, lightweight implementation of getDisplayNames.
354 // Overridden in tznames_impl.cpp.
355 void
getDisplayNames(const UnicodeString & tzID,const UTimeZoneNameType types[],int32_t numTypes,UDate date,UnicodeString dest[],UErrorCode & status) const356 TimeZoneNames::getDisplayNames(const UnicodeString& tzID, const UTimeZoneNameType types[], int32_t numTypes, UDate date, UnicodeString dest[], UErrorCode& status) const {
357 if (U_FAILURE(status)) { return; }
358 if (tzID.isEmpty()) { return; }
359 UnicodeString mzID;
360 for (int i = 0; i < numTypes; i++) {
361 getTimeZoneDisplayName(tzID, types[i], dest[i]);
362 if (dest[i].isEmpty()) {
363 if (mzID.isEmpty()) {
364 getMetaZoneID(tzID, date, mzID);
365 }
366 getMetaZoneDisplayName(mzID, types[i], dest[i]);
367 }
368 }
369 }
370
371
372 struct MatchInfo : UMemory {
373 UTimeZoneNameType nameType;
374 UnicodeString id;
375 int32_t matchLength;
376 UBool isTZID;
377
MatchInfoMatchInfo378 MatchInfo(UTimeZoneNameType nameType, int32_t matchLength, const UnicodeString* tzID, const UnicodeString* mzID) {
379 this->nameType = nameType;
380 this->matchLength = matchLength;
381 if (tzID != NULL) {
382 this->id.setTo(*tzID);
383 this->isTZID = TRUE;
384 } else {
385 this->id.setTo(*mzID);
386 this->isTZID = FALSE;
387 }
388 }
389 };
390
391 U_CDECL_BEGIN
392 static void U_CALLCONV
deleteMatchInfo(void * obj)393 deleteMatchInfo(void *obj) {
394 delete static_cast<MatchInfo *>(obj);
395 }
396 U_CDECL_END
397
398 // ---------------------------------------------------
399 // MatchInfoCollection class
400 // ---------------------------------------------------
MatchInfoCollection()401 TimeZoneNames::MatchInfoCollection::MatchInfoCollection()
402 : fMatches(NULL) {
403 }
404
~MatchInfoCollection()405 TimeZoneNames::MatchInfoCollection::~MatchInfoCollection() {
406 if (fMatches != NULL) {
407 delete fMatches;
408 }
409 }
410
411 void
addZone(UTimeZoneNameType nameType,int32_t matchLength,const UnicodeString & tzID,UErrorCode & status)412 TimeZoneNames::MatchInfoCollection::addZone(UTimeZoneNameType nameType, int32_t matchLength,
413 const UnicodeString& tzID, UErrorCode& status) {
414 if (U_FAILURE(status)) {
415 return;
416 }
417 MatchInfo* matchInfo = new MatchInfo(nameType, matchLength, &tzID, NULL);
418 if (matchInfo == NULL) {
419 status = U_MEMORY_ALLOCATION_ERROR;
420 return;
421 }
422 matches(status)->addElement(matchInfo, status);
423 if (U_FAILURE(status)) {
424 delete matchInfo;
425 }
426 }
427
428 void
addMetaZone(UTimeZoneNameType nameType,int32_t matchLength,const UnicodeString & mzID,UErrorCode & status)429 TimeZoneNames::MatchInfoCollection::addMetaZone(UTimeZoneNameType nameType, int32_t matchLength,
430 const UnicodeString& mzID, UErrorCode& status) {
431 if (U_FAILURE(status)) {
432 return;
433 }
434 MatchInfo* matchInfo = new MatchInfo(nameType, matchLength, NULL, &mzID);
435 if (matchInfo == NULL) {
436 status = U_MEMORY_ALLOCATION_ERROR;
437 return;
438 }
439 matches(status)->addElement(matchInfo, status);
440 if (U_FAILURE(status)) {
441 delete matchInfo;
442 }
443 }
444
445 int32_t
size() const446 TimeZoneNames::MatchInfoCollection::size() const {
447 if (fMatches == NULL) {
448 return 0;
449 }
450 return fMatches->size();
451 }
452
453 UTimeZoneNameType
getNameTypeAt(int32_t idx) const454 TimeZoneNames::MatchInfoCollection::getNameTypeAt(int32_t idx) const {
455 const MatchInfo* match = (const MatchInfo*)fMatches->elementAt(idx);
456 if (match) {
457 return match->nameType;
458 }
459 return UTZNM_UNKNOWN;
460 }
461
462 int32_t
getMatchLengthAt(int32_t idx) const463 TimeZoneNames::MatchInfoCollection::getMatchLengthAt(int32_t idx) const {
464 const MatchInfo* match = (const MatchInfo*)fMatches->elementAt(idx);
465 if (match) {
466 return match->matchLength;
467 }
468 return 0;
469 }
470
471 UBool
getTimeZoneIDAt(int32_t idx,UnicodeString & tzID) const472 TimeZoneNames::MatchInfoCollection::getTimeZoneIDAt(int32_t idx, UnicodeString& tzID) const {
473 tzID.remove();
474 const MatchInfo* match = (const MatchInfo*)fMatches->elementAt(idx);
475 if (match && match->isTZID) {
476 tzID.setTo(match->id);
477 return TRUE;
478 }
479 return FALSE;
480 }
481
482 UBool
getMetaZoneIDAt(int32_t idx,UnicodeString & mzID) const483 TimeZoneNames::MatchInfoCollection::getMetaZoneIDAt(int32_t idx, UnicodeString& mzID) const {
484 mzID.remove();
485 const MatchInfo* match = (const MatchInfo*)fMatches->elementAt(idx);
486 if (match && !match->isTZID) {
487 mzID.setTo(match->id);
488 return TRUE;
489 }
490 return FALSE;
491 }
492
493 UVector*
matches(UErrorCode & status)494 TimeZoneNames::MatchInfoCollection::matches(UErrorCode& status) {
495 if (U_FAILURE(status)) {
496 return NULL;
497 }
498 if (fMatches != NULL) {
499 return fMatches;
500 }
501 fMatches = new UVector(deleteMatchInfo, NULL, status);
502 if (fMatches == NULL) {
503 status = U_MEMORY_ALLOCATION_ERROR;
504 } else if (U_FAILURE(status)) {
505 delete fMatches;
506 fMatches = NULL;
507 }
508 return fMatches;
509 }
510
511
512 U_NAMESPACE_END
513 #endif
514