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