The Tor Browser / file comparison

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

intl/icu/source/i18n/ucal.cpp

branch
TOR_BUG_3246
changeset 4
fc2d59ddac77
equal deleted inserted replaced
-1:000000000000 0:cdae8d2182fa
1 /*
2 *******************************************************************************
3 * Copyright (C) 1996-2013, International Business Machines
4 * Corporation and others. All Rights Reserved.
5 *******************************************************************************
6 */
7
8 #include "utypeinfo.h" // for 'typeid' to work
9
10 #include "unicode/utypes.h"
11
12 #if !UCONFIG_NO_FORMATTING
13
14 #include "unicode/ucal.h"
15 #include "unicode/uloc.h"
16 #include "unicode/calendar.h"
17 #include "unicode/timezone.h"
18 #include "unicode/gregocal.h"
19 #include "unicode/simpletz.h"
20 #include "unicode/ustring.h"
21 #include "unicode/strenum.h"
22 #include "unicode/localpointer.h"
23 #include "cmemory.h"
24 #include "cstring.h"
25 #include "ustrenum.h"
26 #include "uenumimp.h"
27 #include "ulist.h"
28
29 U_NAMESPACE_USE
30
31 static TimeZone*
32 _createTimeZone(const UChar* zoneID, int32_t len, UErrorCode* ec) {
33 TimeZone* zone = NULL;
34 if (ec!=NULL && U_SUCCESS(*ec)) {
35 // Note that if zoneID is invalid, we get back GMT. This odd
36 // behavior is by design and goes back to the JDK. The only
37 // failure we will see is a memory allocation failure.
38 int32_t l = (len<0 ? u_strlen(zoneID) : len);
39 UnicodeString zoneStrID;
40 zoneStrID.setTo((UBool)(len < 0), zoneID, l); /* temporary read-only alias */
41 zone = TimeZone::createTimeZone(zoneStrID);
42 if (zone == NULL) {
43 *ec = U_MEMORY_ALLOCATION_ERROR;
44 }
45 }
46 return zone;
47 }
48
49 U_CAPI UEnumeration* U_EXPORT2
50 ucal_openTimeZoneIDEnumeration(USystemTimeZoneType zoneType, const char* region,
51 const int32_t* rawOffset, UErrorCode* ec) {
52 return uenum_openFromStringEnumeration(TimeZone::createTimeZoneIDEnumeration(
53 zoneType, region, rawOffset, *ec), ec);
54 }
55
56 U_CAPI UEnumeration* U_EXPORT2
57 ucal_openTimeZones(UErrorCode* ec) {
58 return uenum_openFromStringEnumeration(TimeZone::createEnumeration(), ec);
59 }
60
61 U_CAPI UEnumeration* U_EXPORT2
62 ucal_openCountryTimeZones(const char* country, UErrorCode* ec) {
63 return uenum_openFromStringEnumeration(TimeZone::createEnumeration(country), ec);
64 }
65
66 U_CAPI int32_t U_EXPORT2
67 ucal_getDefaultTimeZone(UChar* result, int32_t resultCapacity, UErrorCode* ec) {
68 int32_t len = 0;
69 if (ec!=NULL && U_SUCCESS(*ec)) {
70 TimeZone* zone = TimeZone::createDefault();
71 if (zone == NULL) {
72 *ec = U_MEMORY_ALLOCATION_ERROR;
73 } else {
74 UnicodeString id;
75 zone->getID(id);
76 delete zone;
77 len = id.extract(result, resultCapacity, *ec);
78 }
79 }
80 return len;
81 }
82
83 U_CAPI void U_EXPORT2
84 ucal_setDefaultTimeZone(const UChar* zoneID, UErrorCode* ec) {
85 TimeZone* zone = _createTimeZone(zoneID, -1, ec);
86 if (zone != NULL) {
87 TimeZone::adoptDefault(zone);
88 }
89 }
90
91 U_CAPI int32_t U_EXPORT2
92 ucal_getDSTSavings(const UChar* zoneID, UErrorCode* ec) {
93 int32_t result = 0;
94 TimeZone* zone = _createTimeZone(zoneID, -1, ec);
95 if (U_SUCCESS(*ec)) {
96 SimpleTimeZone* stz = dynamic_cast<SimpleTimeZone*>(zone);
97 if (stz != NULL) {
98 result = stz->getDSTSavings();
99 } else {
100 // Since there is no getDSTSavings on TimeZone, we use a
101 // heuristic: Starting with the current time, march
102 // forwards for one year, looking for DST savings.
103 // Stepping by weeks is sufficient.
104 UDate d = Calendar::getNow();
105 for (int32_t i=0; i<53; ++i, d+=U_MILLIS_PER_DAY*7.0) {
106 int32_t raw, dst;
107 zone->getOffset(d, FALSE, raw, dst, *ec);
108 if (U_FAILURE(*ec)) {
109 break;
110 } else if (dst != 0) {
111 result = dst;
112 break;
113 }
114 }
115 }
116 }
117 delete zone;
118 return result;
119 }
120
121 U_CAPI UDate U_EXPORT2
122 ucal_getNow()
123 {
124
125 return Calendar::getNow();
126 }
127
128 #define ULOC_LOCALE_IDENTIFIER_CAPACITY (ULOC_FULLNAME_CAPACITY + 1 + ULOC_KEYWORD_AND_VALUES_CAPACITY)
129
130 U_CAPI UCalendar* U_EXPORT2
131 ucal_open( const UChar* zoneID,
132 int32_t len,
133 const char* locale,
134 UCalendarType caltype,
135 UErrorCode* status)
136 {
137
138 if(U_FAILURE(*status)) return 0;
139
140 TimeZone* zone = (zoneID==NULL) ? TimeZone::createDefault()
141 : _createTimeZone(zoneID, len, status);
142
143 if (U_FAILURE(*status)) {
144 return NULL;
145 }
146
147 if ( caltype == UCAL_GREGORIAN ) {
148 char localeBuf[ULOC_LOCALE_IDENTIFIER_CAPACITY];
149 if ( locale == NULL ) {
150 locale = uloc_getDefault();
151 }
152 uprv_strncpy(localeBuf, locale, ULOC_LOCALE_IDENTIFIER_CAPACITY);
153 uloc_setKeywordValue("calendar", "gregorian", localeBuf, ULOC_LOCALE_IDENTIFIER_CAPACITY, status);
154 if (U_FAILURE(*status)) {
155 return NULL;
156 }
157 return (UCalendar*)Calendar::createInstance(zone, Locale(localeBuf), *status);
158 }
159 return (UCalendar*)Calendar::createInstance(zone, Locale(locale), *status);
160 }
161
162 U_CAPI void U_EXPORT2
163 ucal_close(UCalendar *cal)
164 {
165
166 delete (Calendar*) cal;
167 }
168
169 U_CAPI UCalendar* U_EXPORT2
170 ucal_clone(const UCalendar* cal,
171 UErrorCode* status)
172 {
173 if(U_FAILURE(*status)) return 0;
174
175 Calendar* res = ((Calendar*)cal)->clone();
176
177 if(res == 0) {
178 *status = U_MEMORY_ALLOCATION_ERROR;
179 return 0;
180 }
181
182 return (UCalendar*) res;
183 }
184
185 U_CAPI void U_EXPORT2
186 ucal_setTimeZone( UCalendar* cal,
187 const UChar* zoneID,
188 int32_t len,
189 UErrorCode *status)
190 {
191
192 if(U_FAILURE(*status))
193 return;
194
195 TimeZone* zone = (zoneID==NULL) ? TimeZone::createDefault()
196 : _createTimeZone(zoneID, len, status);
197
198 if (zone != NULL) {
199 ((Calendar*)cal)->adoptTimeZone(zone);
200 }
201 }
202
203 U_CAPI int32_t U_EXPORT2
204 ucal_getTimeZoneID(const UCalendar *cal,
205 UChar *result,
206 int32_t resultLength,
207 UErrorCode *status)
208 {
209 if (U_FAILURE(*status)) {
210 return 0;
211 }
212 const TimeZone& tz = ((Calendar*)cal)->getTimeZone();
213 UnicodeString id;
214 tz.getID(id);
215 return id.extract(result, resultLength, *status);
216 }
217
218 U_CAPI int32_t U_EXPORT2
219 ucal_getTimeZoneDisplayName(const UCalendar* cal,
220 UCalendarDisplayNameType type,
221 const char *locale,
222 UChar* result,
223 int32_t resultLength,
224 UErrorCode* status)
225 {
226
227 if(U_FAILURE(*status)) return -1;
228
229 const TimeZone& tz = ((Calendar*)cal)->getTimeZone();
230 UnicodeString id;
231 if(!(result==NULL && resultLength==0)) {
232 // NULL destination for pure preflighting: empty dummy string
233 // otherwise, alias the destination buffer
234 id.setTo(result, 0, resultLength);
235 }
236
237 switch(type) {
238 case UCAL_STANDARD:
239 tz.getDisplayName(FALSE, TimeZone::LONG, Locale(locale), id);
240 break;
241
242 case UCAL_SHORT_STANDARD:
243 tz.getDisplayName(FALSE, TimeZone::SHORT, Locale(locale), id);
244 break;
245
246 case UCAL_DST:
247 tz.getDisplayName(TRUE, TimeZone::LONG, Locale(locale), id);
248 break;
249
250 case UCAL_SHORT_DST:
251 tz.getDisplayName(TRUE, TimeZone::SHORT, Locale(locale), id);
252 break;
253 }
254
255 return id.extract(result, resultLength, *status);
256 }
257
258 U_CAPI UBool U_EXPORT2
259 ucal_inDaylightTime( const UCalendar* cal,
260 UErrorCode* status )
261 {
262
263 if(U_FAILURE(*status)) return (UBool) -1;
264 return ((Calendar*)cal)->inDaylightTime(*status);
265 }
266
267 U_CAPI void U_EXPORT2
268 ucal_setGregorianChange(UCalendar *cal, UDate date, UErrorCode *pErrorCode) {
269 if(U_FAILURE(*pErrorCode)) {
270 return;
271 }
272 Calendar *cpp_cal = (Calendar *)cal;
273 GregorianCalendar *gregocal = dynamic_cast<GregorianCalendar *>(cpp_cal);
274 // Not if(gregocal == NULL) {
275 // because we really want to work only with a GregorianCalendar, not with
276 // its subclasses like BuddhistCalendar.
277 if (cpp_cal == NULL) {
278 // We normally don't check "this" pointers for NULL, but this here avoids
279 // compiler-generated exception-throwing code in case cal == NULL.
280 *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
281 return;
282 }
283 if(typeid(*cpp_cal) != typeid(GregorianCalendar)) {
284 *pErrorCode = U_UNSUPPORTED_ERROR;
285 return;
286 }
287 gregocal->setGregorianChange(date, *pErrorCode);
288 }
289
290 U_CAPI UDate U_EXPORT2
291 ucal_getGregorianChange(const UCalendar *cal, UErrorCode *pErrorCode) {
292 if(U_FAILURE(*pErrorCode)) {
293 return (UDate)0;
294 }
295 const Calendar *cpp_cal = (const Calendar *)cal;
296 const GregorianCalendar *gregocal = dynamic_cast<const GregorianCalendar *>(cpp_cal);
297 // Not if(gregocal == NULL) {
298 // see comments in ucal_setGregorianChange().
299 if (cpp_cal == NULL) {
300 // We normally don't check "this" pointers for NULL, but this here avoids
301 // compiler-generated exception-throwing code in case cal == NULL.
302 *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
303 return (UDate)0;
304 }
305 if(typeid(*cpp_cal) != typeid(GregorianCalendar)) {
306 *pErrorCode = U_UNSUPPORTED_ERROR;
307 return (UDate)0;
308 }
309 return gregocal->getGregorianChange();
310 }
311
312 U_CAPI int32_t U_EXPORT2
313 ucal_getAttribute( const UCalendar* cal,
314 UCalendarAttribute attr)
315 {
316
317 switch(attr) {
318 case UCAL_LENIENT:
319 return ((Calendar*)cal)->isLenient();
320
321 case UCAL_FIRST_DAY_OF_WEEK:
322 return ((Calendar*)cal)->getFirstDayOfWeek();
323
324 case UCAL_MINIMAL_DAYS_IN_FIRST_WEEK:
325 return ((Calendar*)cal)->getMinimalDaysInFirstWeek();
326
327 case UCAL_REPEATED_WALL_TIME:
328 return ((Calendar*)cal)->getRepeatedWallTimeOption();
329
330 case UCAL_SKIPPED_WALL_TIME:
331 return ((Calendar*)cal)->getSkippedWallTimeOption();
332
333 default:
334 break;
335 }
336 return -1;
337 }
338
339 U_CAPI void U_EXPORT2
340 ucal_setAttribute( UCalendar* cal,
341 UCalendarAttribute attr,
342 int32_t newValue)
343 {
344
345 switch(attr) {
346 case UCAL_LENIENT:
347 ((Calendar*)cal)->setLenient((UBool)newValue);
348 break;
349
350 case UCAL_FIRST_DAY_OF_WEEK:
351 ((Calendar*)cal)->setFirstDayOfWeek((UCalendarDaysOfWeek)newValue);
352 break;
353
354 case UCAL_MINIMAL_DAYS_IN_FIRST_WEEK:
355 ((Calendar*)cal)->setMinimalDaysInFirstWeek((uint8_t)newValue);
356 break;
357
358 case UCAL_REPEATED_WALL_TIME:
359 ((Calendar*)cal)->setRepeatedWallTimeOption((UCalendarWallTimeOption)newValue);
360 break;
361
362 case UCAL_SKIPPED_WALL_TIME:
363 ((Calendar*)cal)->setSkippedWallTimeOption((UCalendarWallTimeOption)newValue);
364 break;
365 }
366 }
367
368 U_CAPI const char* U_EXPORT2
369 ucal_getAvailable(int32_t index)
370 {
371
372 return uloc_getAvailable(index);
373 }
374
375 U_CAPI int32_t U_EXPORT2
376 ucal_countAvailable()
377 {
378
379 return uloc_countAvailable();
380 }
381
382 U_CAPI UDate U_EXPORT2
383 ucal_getMillis( const UCalendar* cal,
384 UErrorCode* status)
385 {
386
387 if(U_FAILURE(*status)) return (UDate) 0;
388
389 return ((Calendar*)cal)->getTime(*status);
390 }
391
392 U_CAPI void U_EXPORT2
393 ucal_setMillis( UCalendar* cal,
394 UDate dateTime,
395 UErrorCode* status )
396 {
397 if(U_FAILURE(*status)) return;
398
399 ((Calendar*)cal)->setTime(dateTime, *status);
400 }
401
402 // TBD: why does this take an UErrorCode?
403 U_CAPI void U_EXPORT2
404 ucal_setDate( UCalendar* cal,
405 int32_t year,
406 int32_t month,
407 int32_t date,
408 UErrorCode *status)
409 {
410
411 if(U_FAILURE(*status)) return;
412
413 ((Calendar*)cal)->set(year, month, date);
414 }
415
416 // TBD: why does this take an UErrorCode?
417 U_CAPI void U_EXPORT2
418 ucal_setDateTime( UCalendar* cal,
419 int32_t year,
420 int32_t month,
421 int32_t date,
422 int32_t hour,
423 int32_t minute,
424 int32_t second,
425 UErrorCode *status)
426 {
427 if(U_FAILURE(*status)) return;
428
429 ((Calendar*)cal)->set(year, month, date, hour, minute, second);
430 }
431
432 U_CAPI UBool U_EXPORT2
433 ucal_equivalentTo( const UCalendar* cal1,
434 const UCalendar* cal2)
435 {
436
437 return ((Calendar*)cal1)->isEquivalentTo(*((Calendar*)cal2));
438 }
439
440 U_CAPI void U_EXPORT2
441 ucal_add( UCalendar* cal,
442 UCalendarDateFields field,
443 int32_t amount,
444 UErrorCode* status)
445 {
446
447 if(U_FAILURE(*status)) return;
448
449 ((Calendar*)cal)->add(field, amount, *status);
450 }
451
452 U_CAPI void U_EXPORT2
453 ucal_roll( UCalendar* cal,
454 UCalendarDateFields field,
455 int32_t amount,
456 UErrorCode* status)
457 {
458
459 if(U_FAILURE(*status)) return;
460
461 ((Calendar*)cal)->roll(field, amount, *status);
462 }
463
464 U_CAPI int32_t U_EXPORT2
465 ucal_get( const UCalendar* cal,
466 UCalendarDateFields field,
467 UErrorCode* status )
468 {
469
470 if(U_FAILURE(*status)) return -1;
471
472 return ((Calendar*)cal)->get(field, *status);
473 }
474
475 U_CAPI void U_EXPORT2
476 ucal_set( UCalendar* cal,
477 UCalendarDateFields field,
478 int32_t value)
479 {
480
481 ((Calendar*)cal)->set(field, value);
482 }
483
484 U_CAPI UBool U_EXPORT2
485 ucal_isSet( const UCalendar* cal,
486 UCalendarDateFields field)
487 {
488
489 return ((Calendar*)cal)->isSet(field);
490 }
491
492 U_CAPI void U_EXPORT2
493 ucal_clearField( UCalendar* cal,
494 UCalendarDateFields field)
495 {
496
497 ((Calendar*)cal)->clear(field);
498 }
499
500 U_CAPI void U_EXPORT2
501 ucal_clear(UCalendar* calendar)
502 {
503
504 ((Calendar*)calendar)->clear();
505 }
506
507 U_CAPI int32_t U_EXPORT2
508 ucal_getLimit( const UCalendar* cal,
509 UCalendarDateFields field,
510 UCalendarLimitType type,
511 UErrorCode *status)
512 {
513
514 if(status==0 || U_FAILURE(*status)) {
515 return -1;
516 }
517
518 switch(type) {
519 case UCAL_MINIMUM:
520 return ((Calendar*)cal)->getMinimum(field);
521
522 case UCAL_MAXIMUM:
523 return ((Calendar*)cal)->getMaximum(field);
524
525 case UCAL_GREATEST_MINIMUM:
526 return ((Calendar*)cal)->getGreatestMinimum(field);
527
528 case UCAL_LEAST_MAXIMUM:
529 return ((Calendar*)cal)->getLeastMaximum(field);
530
531 case UCAL_ACTUAL_MINIMUM:
532 return ((Calendar*)cal)->getActualMinimum(field,
533 *status);
534
535 case UCAL_ACTUAL_MAXIMUM:
536 return ((Calendar*)cal)->getActualMaximum(field,
537 *status);
538
539 default:
540 break;
541 }
542 return -1;
543 }
544
545 U_CAPI const char * U_EXPORT2
546 ucal_getLocaleByType(const UCalendar *cal, ULocDataLocaleType type, UErrorCode* status)
547 {
548 if (cal == NULL) {
549 if (U_SUCCESS(*status)) {
550 *status = U_ILLEGAL_ARGUMENT_ERROR;
551 }
552 return NULL;
553 }
554 return ((Calendar*)cal)->getLocaleID(type, *status);
555 }
556
557 U_CAPI const char * U_EXPORT2
558 ucal_getTZDataVersion(UErrorCode* status)
559 {
560 return TimeZone::getTZDataVersion(*status);
561 }
562
563 U_CAPI int32_t U_EXPORT2
564 ucal_getCanonicalTimeZoneID(const UChar* id, int32_t len,
565 UChar* result, int32_t resultCapacity, UBool *isSystemID, UErrorCode* status) {
566 if(status == 0 || U_FAILURE(*status)) {
567 return 0;
568 }
569 if (isSystemID) {
570 *isSystemID = FALSE;
571 }
572 if (id == 0 || len == 0 || result == 0 || resultCapacity <= 0) {
573 *status = U_ILLEGAL_ARGUMENT_ERROR;
574 return 0;
575 }
576 int32_t reslen = 0;
577 UnicodeString canonical;
578 UBool systemID = FALSE;
579 TimeZone::getCanonicalID(UnicodeString(id, len), canonical, systemID, *status);
580 if (U_SUCCESS(*status)) {
581 if (isSystemID) {
582 *isSystemID = systemID;
583 }
584 reslen = canonical.extract(result, resultCapacity, *status);
585 }
586 return reslen;
587 }
588
589 U_CAPI const char * U_EXPORT2
590 ucal_getType(const UCalendar *cal, UErrorCode* status)
591 {
592 if (U_FAILURE(*status)) {
593 return NULL;
594 }
595 return ((Calendar*)cal)->getType();
596 }
597
598 U_CAPI UCalendarWeekdayType U_EXPORT2
599 ucal_getDayOfWeekType(const UCalendar *cal, UCalendarDaysOfWeek dayOfWeek, UErrorCode* status)
600 {
601 if (U_FAILURE(*status)) {
602 return UCAL_WEEKDAY;
603 }
604 return ((Calendar*)cal)->getDayOfWeekType(dayOfWeek, *status);
605 }
606
607 U_CAPI int32_t U_EXPORT2
608 ucal_getWeekendTransition(const UCalendar *cal, UCalendarDaysOfWeek dayOfWeek, UErrorCode *status)
609 {
610 if (U_FAILURE(*status)) {
611 return 0;
612 }
613 return ((Calendar*)cal)->getWeekendTransition(dayOfWeek, *status);
614 }
615
616 U_CAPI UBool U_EXPORT2
617 ucal_isWeekend(const UCalendar *cal, UDate date, UErrorCode *status)
618 {
619 if (U_FAILURE(*status)) {
620 return FALSE;
621 }
622 return ((Calendar*)cal)->isWeekend(date, *status);
623 }
624
625 U_CAPI int32_t U_EXPORT2
626 ucal_getFieldDifference(UCalendar* cal, UDate target,
627 UCalendarDateFields field,
628 UErrorCode* status )
629 {
630 if (U_FAILURE(*status)) {
631 return 0;
632 }
633 return ((Calendar*)cal)->fieldDifference(target, field, *status);
634 }
635
636
637 static const UEnumeration defaultKeywordValues = {
638 NULL,
639 NULL,
640 ulist_close_keyword_values_iterator,
641 ulist_count_keyword_values,
642 uenum_unextDefault,
643 ulist_next_keyword_value,
644 ulist_reset_keyword_values_iterator
645 };
646
647 static const char * const CAL_TYPES[] = {
648 "gregorian",
649 "japanese",
650 "buddhist",
651 "roc",
652 "persian",
653 "islamic-civil",
654 "islamic",
655 "hebrew",
656 "chinese",
657 "indian",
658 "coptic",
659 "ethiopic",
660 "ethiopic-amete-alem",
661 "iso8601",
662 "dangi",
663 "islamic-umalqura",
664 "islamic-tbla",
665 "islamic-rgsa",
666 NULL
667 };
668
669 U_CAPI UEnumeration* U_EXPORT2
670 ucal_getKeywordValuesForLocale(const char * /* key */, const char* locale, UBool commonlyUsed, UErrorCode *status) {
671 // Resolve region
672 char prefRegion[ULOC_FULLNAME_CAPACITY] = "";
673 int32_t prefRegionLength = 0;
674 prefRegionLength = uloc_getCountry(locale, prefRegion, sizeof(prefRegion), status);
675 if (prefRegionLength == 0) {
676 char loc[ULOC_FULLNAME_CAPACITY] = "";
677 uloc_addLikelySubtags(locale, loc, sizeof(loc), status);
678
679 prefRegionLength = uloc_getCountry(loc, prefRegion, sizeof(prefRegion), status);
680 }
681
682 // Read preferred calendar values from supplementalData calendarPreference
683 UResourceBundle *rb = ures_openDirect(NULL, "supplementalData", status);
684 ures_getByKey(rb, "calendarPreferenceData", rb, status);
685 UResourceBundle *order = ures_getByKey(rb, prefRegion, NULL, status);
686 if (*status == U_MISSING_RESOURCE_ERROR && rb != NULL) {
687 *status = U_ZERO_ERROR;
688 order = ures_getByKey(rb, "001", NULL, status);
689 }
690
691 // Create a list of calendar type strings
692 UList *values = NULL;
693 if (U_SUCCESS(*status)) {
694 values = ulist_createEmptyList(status);
695 if (U_SUCCESS(*status)) {
696 for (int i = 0; i < ures_getSize(order); i++) {
697 int32_t len;
698 const UChar *type = ures_getStringByIndex(order, i, &len, status);
699 char *caltype = (char*)uprv_malloc(len + 1);
700 if (caltype == NULL) {
701 *status = U_MEMORY_ALLOCATION_ERROR;
702 break;
703 }
704 u_UCharsToChars(type, caltype, len);
705 *(caltype + len) = 0;
706
707 ulist_addItemEndList(values, caltype, TRUE, status);
708 if (U_FAILURE(*status)) {
709 break;
710 }
711 }
712
713 if (U_SUCCESS(*status) && !commonlyUsed) {
714 // If not commonlyUsed, add other available values
715 for (int32_t i = 0; CAL_TYPES[i] != NULL; i++) {
716 if (!ulist_containsString(values, CAL_TYPES[i], (int32_t)uprv_strlen(CAL_TYPES[i]))) {
717 ulist_addItemEndList(values, CAL_TYPES[i], FALSE, status);
718 if (U_FAILURE(*status)) {
719 break;
720 }
721 }
722 }
723 }
724 if (U_FAILURE(*status)) {
725 ulist_deleteList(values);
726 values = NULL;
727 }
728 }
729 }
730
731 ures_close(order);
732 ures_close(rb);
733
734 if (U_FAILURE(*status) || values == NULL) {
735 return NULL;
736 }
737
738 // Create string enumeration
739 UEnumeration *en = (UEnumeration*)uprv_malloc(sizeof(UEnumeration));
740 if (en == NULL) {
741 *status = U_MEMORY_ALLOCATION_ERROR;
742 ulist_deleteList(values);
743 return NULL;
744 }
745 ulist_resetList(values);
746 memcpy(en, &defaultKeywordValues, sizeof(UEnumeration));
747 en->context = values;
748 return en;
749 }
750
751 U_CAPI UBool U_EXPORT2
752 ucal_getTimeZoneTransitionDate(const UCalendar* cal, UTimeZoneTransitionType type,
753 UDate* transition, UErrorCode* status)
754 {
755 if (U_FAILURE(*status)) {
756 return FALSE;
757 }
758 UDate base = ((Calendar*)cal)->getTime(*status);
759 const TimeZone& tz = ((Calendar*)cal)->getTimeZone();
760 const BasicTimeZone * btz = dynamic_cast<const BasicTimeZone *>(&tz);
761 if (btz != NULL && U_SUCCESS(*status)) {
762 TimeZoneTransition tzt;
763 UBool inclusive = (type == UCAL_TZ_TRANSITION_NEXT_INCLUSIVE || type == UCAL_TZ_TRANSITION_PREVIOUS_INCLUSIVE);
764 UBool result = (type == UCAL_TZ_TRANSITION_NEXT || type == UCAL_TZ_TRANSITION_NEXT_INCLUSIVE)?
765 btz->getNextTransition(base, inclusive, tzt):
766 btz->getPreviousTransition(base, inclusive, tzt);
767 if (result) {
768 *transition = tzt.getTime();
769 return TRUE;
770 }
771 }
772 return FALSE;
773 }
774
775 #ifndef U_HIDE_DRAFT_API
776 U_CAPI int32_t U_EXPORT2
777 ucal_getWindowsTimeZoneID(const UChar* id, int32_t len, UChar* winid, int32_t winidCapacity, UErrorCode* status) {
778 if (U_FAILURE(*status)) {
779 return 0;
780 }
781
782 int32_t resultLen = 0;
783 UnicodeString resultWinID;
784
785 TimeZone::getWindowsID(UnicodeString(id, len), resultWinID, *status);
786 if (U_SUCCESS(*status) && resultWinID.length() > 0) {
787 resultLen = resultWinID.length();
788 resultWinID.extract(winid, winidCapacity, *status);
789 }
790
791 return resultLen;
792 }
793
794 U_CAPI int32_t U_EXPORT2
795 ucal_getTimeZoneIDForWindowsID(const UChar* winid, int32_t len, const char* region, UChar* id, int32_t idCapacity, UErrorCode* status) {
796 if (U_FAILURE(*status)) {
797 return 0;
798 }
799
800 int32_t resultLen = 0;
801 UnicodeString resultID;
802
803 TimeZone::getIDForWindowsID(UnicodeString(winid, len), region, resultID, *status);
804 if (U_SUCCESS(*status) && resultID.length() > 0) {
805 resultLen = resultID.length();
806 resultID.extract(id, idCapacity, *status);
807 }
808
809 return resultLen;
810 }
811
812 #endif /* U_HIDE_DRAFT_API */
813
814 #endif /* #if !UCONFIG_NO_FORMATTING */

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial