The Tor Browser / file comparison

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

intl/icu/source/i18n/tznames.cpp

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

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial