icuSources/i18n/ucal.cpp

   1 /*
   2 *******************************************************************************
   3 *   Copyright (C) 1996-2016, 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 <stdlib.h> // Apple addition for uacal_getDayPeriod
  15
  16 #include "unicode/ucal.h"
  17 #include "unicode/uloc.h"
  18 #include "unicode/calendar.h"
  19 #include "unicode/timezone.h"
  20 #include "unicode/gregocal.h"
  21 #include "unicode/simpletz.h"
  22 #include "unicode/ustring.h"
  23 #include "unicode/strenum.h"
  24 #include "unicode/localpointer.h"
  25 #include "cmemory.h"
  26 #include "cstring.h"
  27 #include "ustrenum.h"
  28 #include "uenumimp.h"
  29 #include "ulist.h"
  30 #include "ulocimp.h"
  31
  32 U_NAMESPACE_USE
  33
  34 static TimeZone*
  35 _createTimeZone(const UChar* zoneID, int32_t len, UErrorCode* ec) {
  36     TimeZone* zone = NULL;
  37     if (ec!=NULL && U_SUCCESS(*ec)) {
  38         // Note that if zoneID is invalid, we get back GMT. This odd
  39         // behavior is by design and goes back to the JDK. The only
  40         // failure we will see is a memory allocation failure.
  41         int32_t l = (len<0 ? u_strlen(zoneID) : len);
  42         UnicodeString zoneStrID;
  43         zoneStrID.setTo((UBool)(len < 0), zoneID, l); /* temporary read-only alias */
  44         zone = TimeZone::createTimeZone(zoneStrID);
  45         if (zone == NULL) {
  46             *ec = U_MEMORY_ALLOCATION_ERROR;
  47         }
  48     }
  49     return zone;
  50 }
  51
  52 U_CAPI UEnumeration* U_EXPORT2
  53 ucal_openTimeZoneIDEnumeration(USystemTimeZoneType zoneType, const char* region,
  54                                 const int32_t* rawOffset, UErrorCode* ec) {
  55     return uenum_openFromStringEnumeration(TimeZone::createTimeZoneIDEnumeration(
  56         zoneType, region, rawOffset, *ec), ec);
  57 }
  58
  59 U_CAPI UEnumeration* U_EXPORT2
  60 ucal_openTimeZones(UErrorCode* ec) {
  61     return uenum_openFromStringEnumeration(TimeZone::createEnumeration(), ec);
  62 }
  63
  64 U_CAPI UEnumeration* U_EXPORT2
  65 ucal_openCountryTimeZones(const char* country, UErrorCode* ec) {
  66     return uenum_openFromStringEnumeration(TimeZone::createEnumeration(country), ec);
  67 }
  68
  69 U_CAPI int32_t U_EXPORT2
  70 ucal_getDefaultTimeZone(UChar* result, int32_t resultCapacity, UErrorCode* ec) {
  71     int32_t len = 0;
  72     if (ec!=NULL && U_SUCCESS(*ec)) {
  73         TimeZone* zone = TimeZone::createDefault();
  74         if (zone == NULL) {
  75             *ec = U_MEMORY_ALLOCATION_ERROR;
  76         } else {
  77             UnicodeString id;
  78             zone->getID(id);
  79             delete zone;
  80             len = id.extract(result, resultCapacity, *ec);
  81         }
  82     }
  83     return len;
  84 }
  85
  86 U_CAPI void U_EXPORT2
  87 ucal_setDefaultTimeZone(const UChar* zoneID, UErrorCode* ec) {
  88     TimeZone* zone = _createTimeZone(zoneID, -1, ec);
  89     if (zone != NULL) {
  90         TimeZone::adoptDefault(zone);
  91     }
  92 }
  93
  94 U_CAPI int32_t U_EXPORT2
  95 ucal_getDSTSavings(const UChar* zoneID, UErrorCode* ec) {
  96     int32_t result = 0;
  97     TimeZone* zone = _createTimeZone(zoneID, -1, ec);
  98     if (U_SUCCESS(*ec)) {
  99         SimpleTimeZone* stz = dynamic_cast<SimpleTimeZone*>(zone);
 100         if (stz != NULL) {
 101             result = stz->getDSTSavings();
 102         } else {
 103             // Since there is no getDSTSavings on TimeZone, we use a
 104             // heuristic: Starting with the current time, march
 105             // forwards for one year, looking for DST savings.
 106             // Stepping by weeks is sufficient.
 107             UDate d = Calendar::getNow();
 108             for (int32_t i=0; i<53; ++i, d+=U_MILLIS_PER_DAY*7.0) {
 109                 int32_t raw, dst;
 110                 zone->getOffset(d, FALSE, raw, dst, *ec);
 111                 if (U_FAILURE(*ec)) {
 112                     break;
 113                 } else if (dst != 0) {
 114                     result = dst;
 115                     break;
 116                 }
 117             }
 118         }
 119     }
 120     delete zone;
 121     return result;
 122 }
 123
 124 U_CAPI UDate  U_EXPORT2
 125 ucal_getNow()
 126 {
 127
 128   return Calendar::getNow();
 129 }
 130
 131 #define ULOC_LOCALE_IDENTIFIER_CAPACITY (ULOC_FULLNAME_CAPACITY + 1 + ULOC_KEYWORD_AND_VALUES_CAPACITY)
 132
 133 U_CAPI UCalendar*  U_EXPORT2
 134 ucal_open(  const UChar*  zoneID,
 135             int32_t       len,
 136             const char*   locale,
 137             UCalendarType caltype,
 138             UErrorCode*   status)
 139 {
 140
 141   if(U_FAILURE(*status)) return 0;
 142
 143   TimeZone* zone = (zoneID==NULL) ? TimeZone::createDefault()
 144       : _createTimeZone(zoneID, len, status);
 145
 146   if (U_FAILURE(*status)) {
 147       return NULL;
 148   }
 149
 150   if ( caltype == UCAL_GREGORIAN ) {
 151       char  localeBuf[ULOC_LOCALE_IDENTIFIER_CAPACITY];
 152       if ( locale == NULL ) {
 153           locale = uloc_getDefault();
 154       }
 155       uprv_strncpy(localeBuf, locale, ULOC_LOCALE_IDENTIFIER_CAPACITY);
 156       uloc_setKeywordValue("calendar", "gregorian", localeBuf, ULOC_LOCALE_IDENTIFIER_CAPACITY, status);
 157       if (U_FAILURE(*status)) {
 158           return NULL;
 159       }
 160       return (UCalendar*)Calendar::createInstance(zone, Locale(localeBuf), *status);
 161   }
 162   return (UCalendar*)Calendar::createInstance(zone, Locale(locale), *status);
 163 }
 164
 165 U_CAPI void U_EXPORT2
 166 ucal_close(UCalendar *cal)
 167 {
 168
 169   delete (Calendar*) cal;
 170 }
 171
 172 U_CAPI UCalendar* U_EXPORT2
 173 ucal_clone(const UCalendar* cal,
 174            UErrorCode*      status)
 175 {
 176   if(U_FAILURE(*status)) return 0;
 177
 178   Calendar* res = ((Calendar*)cal)->clone();
 179
 180   if(res == 0) {
 181     *status = U_MEMORY_ALLOCATION_ERROR;
 182     return 0;
 183   }
 184
 185   return (UCalendar*) res;
 186 }
 187
 188 U_CAPI void  U_EXPORT2
 189 ucal_setTimeZone(    UCalendar*      cal,
 190             const    UChar*            zoneID,
 191             int32_t        len,
 192             UErrorCode *status)
 193 {
 194
 195   if(U_FAILURE(*status))
 196     return;
 197
 198   TimeZone* zone = (zoneID==NULL) ? TimeZone::createDefault()
 199       : _createTimeZone(zoneID, len, status);
 200
 201   if (zone != NULL) {
 202       ((Calendar*)cal)->adoptTimeZone(zone);
 203   }
 204 }
 205
 206 U_CAPI int32_t U_EXPORT2
 207 ucal_getTimeZoneID(const UCalendar *cal,
 208                    UChar *result,
 209                    int32_t resultLength,
 210                    UErrorCode *status)
 211 {
 212     if (U_FAILURE(*status)) {
 213         return 0;
 214     }
 215     const TimeZone& tz = ((Calendar*)cal)->getTimeZone();
 216     UnicodeString id;
 217     tz.getID(id);
 218     return id.extract(result, resultLength, *status);
 219 }
 220
 221 U_CAPI int32_t U_EXPORT2
 222 ucal_getTimeZoneDisplayName(const     UCalendar*                 cal,
 223                     UCalendarDisplayNameType     type,
 224                     const char             *locale,
 225                     UChar*                  result,
 226                     int32_t                 resultLength,
 227                     UErrorCode*             status)
 228 {
 229
 230     if(U_FAILURE(*status)) return -1;
 231
 232     const TimeZone& tz = ((Calendar*)cal)->getTimeZone();
 233     UnicodeString id;
 234     if(!(result==NULL && resultLength==0)) {
 235         // NULL destination for pure preflighting: empty dummy string
 236         // otherwise, alias the destination buffer
 237         id.setTo(result, 0, resultLength);
 238     }
 239
 240     switch(type) {
 241   case UCAL_STANDARD:
 242       tz.getDisplayName(FALSE, TimeZone::LONG, Locale(locale), id);
 243       break;
 244
 245   case UCAL_SHORT_STANDARD:
 246       tz.getDisplayName(FALSE, TimeZone::SHORT, Locale(locale), id);
 247       break;
 248
 249   case UCAL_DST:
 250       tz.getDisplayName(TRUE, TimeZone::LONG, Locale(locale), id);
 251       break;
 252
 253   case UCAL_SHORT_DST:
 254       tz.getDisplayName(TRUE, TimeZone::SHORT, Locale(locale), id);
 255       break;
 256     }
 257
 258     return id.extract(result, resultLength, *status);
 259 }
 260
 261 U_CAPI UBool  U_EXPORT2
 262 ucal_inDaylightTime(    const    UCalendar*      cal,
 263                     UErrorCode*     status )
 264 {
 265
 266     if(U_FAILURE(*status)) return (UBool) -1;
 267     return ((Calendar*)cal)->inDaylightTime(*status);
 268 }
 269
 270 U_CAPI void U_EXPORT2
 271 ucal_setGregorianChange(UCalendar *cal, UDate date, UErrorCode *pErrorCode) {
 272     if(U_FAILURE(*pErrorCode)) {
 273         return;
 274     }
 275     Calendar *cpp_cal = (Calendar *)cal;
 276     GregorianCalendar *gregocal = dynamic_cast<GregorianCalendar *>(cpp_cal);
 277     // Not if(gregocal == NULL) {
 278     // because we really want to work only with a GregorianCalendar, not with
 279     // its subclasses like BuddhistCalendar.
 280     if (cpp_cal == NULL) {
 281         // We normally don't check "this" pointers for NULL, but this here avoids
 282         // compiler-generated exception-throwing code in case cal == NULL.
 283         *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
 284         return;
 285     }
 286     if(typeid(*cpp_cal) != typeid(GregorianCalendar)) {
 287         *pErrorCode = U_UNSUPPORTED_ERROR;
 288         return;
 289     }
 290     gregocal->setGregorianChange(date, *pErrorCode);
 291 }
 292
 293 U_CAPI UDate U_EXPORT2
 294 ucal_getGregorianChange(const UCalendar *cal, UErrorCode *pErrorCode) {
 295     if(U_FAILURE(*pErrorCode)) {
 296         return (UDate)0;
 297     }
 298     const Calendar *cpp_cal = (const Calendar *)cal;
 299     const GregorianCalendar *gregocal = dynamic_cast<const GregorianCalendar *>(cpp_cal);
 300     // Not if(gregocal == NULL) {
 301     // see comments in ucal_setGregorianChange().
 302     if (cpp_cal == NULL) {
 303         // We normally don't check "this" pointers for NULL, but this here avoids
 304         // compiler-generated exception-throwing code in case cal == NULL.
 305         *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
 306         return (UDate)0;
 307     }
 308     if(typeid(*cpp_cal) != typeid(GregorianCalendar)) {
 309         *pErrorCode = U_UNSUPPORTED_ERROR;
 310         return (UDate)0;
 311     }
 312     return gregocal->getGregorianChange();
 313 }
 314
 315 U_CAPI int32_t U_EXPORT2
 316 ucal_getAttribute(    const    UCalendar*              cal,
 317                   UCalendarAttribute      attr)
 318 {
 319
 320     switch(attr) {
 321   case UCAL_LENIENT:
 322       return ((Calendar*)cal)->isLenient();
 323
 324   case UCAL_FIRST_DAY_OF_WEEK:
 325       return ((Calendar*)cal)->getFirstDayOfWeek();
 326
 327   case UCAL_MINIMAL_DAYS_IN_FIRST_WEEK:
 328       return ((Calendar*)cal)->getMinimalDaysInFirstWeek();
 329
 330   case UCAL_REPEATED_WALL_TIME:
 331       return ((Calendar*)cal)->getRepeatedWallTimeOption();
 332
 333   case UCAL_SKIPPED_WALL_TIME:
 334       return ((Calendar*)cal)->getSkippedWallTimeOption();
 335
 336   default:
 337       break;
 338     }
 339     return -1;
 340 }
 341
 342 U_CAPI void U_EXPORT2
 343 ucal_setAttribute(      UCalendar*              cal,
 344                   UCalendarAttribute      attr,
 345                   int32_t                 newValue)
 346 {
 347
 348     switch(attr) {
 349   case UCAL_LENIENT:
 350       ((Calendar*)cal)->setLenient((UBool)newValue);
 351       break;
 352
 353   case UCAL_FIRST_DAY_OF_WEEK:
 354       ((Calendar*)cal)->setFirstDayOfWeek((UCalendarDaysOfWeek)newValue);
 355       break;
 356
 357   case UCAL_MINIMAL_DAYS_IN_FIRST_WEEK:
 358       ((Calendar*)cal)->setMinimalDaysInFirstWeek((uint8_t)newValue);
 359       break;
 360
 361   case UCAL_REPEATED_WALL_TIME:
 362       ((Calendar*)cal)->setRepeatedWallTimeOption((UCalendarWallTimeOption)newValue);
 363       break;
 364
 365   case UCAL_SKIPPED_WALL_TIME:
 366       ((Calendar*)cal)->setSkippedWallTimeOption((UCalendarWallTimeOption)newValue);
 367       break;
 368     }
 369 }
 370
 371 U_CAPI const char* U_EXPORT2
 372 ucal_getAvailable(int32_t index)
 373 {
 374
 375     return uloc_getAvailable(index);
 376 }
 377
 378 U_CAPI int32_t U_EXPORT2
 379 ucal_countAvailable()
 380 {
 381
 382     return uloc_countAvailable();
 383 }
 384
 385 U_CAPI UDate  U_EXPORT2
 386 ucal_getMillis(    const    UCalendar*      cal,
 387                UErrorCode*     status)
 388 {
 389
 390     if(U_FAILURE(*status)) return (UDate) 0;
 391
 392     return ((Calendar*)cal)->getTime(*status);
 393 }
 394
 395 U_CAPI void  U_EXPORT2
 396 ucal_setMillis(        UCalendar*      cal,
 397                UDate           dateTime,
 398                UErrorCode*     status )
 399 {
 400     if(U_FAILURE(*status)) return;
 401
 402     ((Calendar*)cal)->setTime(dateTime, *status);
 403 }
 404
 405 // TBD: why does this take an UErrorCode?
 406 U_CAPI void  U_EXPORT2
 407 ucal_setDate(        UCalendar*        cal,
 408              int32_t            year,
 409              int32_t            month,
 410              int32_t            date,
 411              UErrorCode        *status)
 412 {
 413
 414     if(U_FAILURE(*status)) return;
 415
 416     ((Calendar*)cal)->set(year, month, date);
 417 }
 418
 419 // TBD: why does this take an UErrorCode?
 420 U_CAPI void  U_EXPORT2
 421 ucal_setDateTime(    UCalendar*        cal,
 422                  int32_t            year,
 423                  int32_t            month,
 424                  int32_t            date,
 425                  int32_t            hour,
 426                  int32_t            minute,
 427                  int32_t            second,
 428                  UErrorCode        *status)
 429 {
 430     if(U_FAILURE(*status)) return;
 431
 432     ((Calendar*)cal)->set(year, month, date, hour, minute, second);
 433 }
 434
 435 U_CAPI UBool  U_EXPORT2
 436 ucal_equivalentTo(    const UCalendar*      cal1,
 437                   const UCalendar*      cal2)
 438 {
 439
 440     return ((Calendar*)cal1)->isEquivalentTo(*((Calendar*)cal2));
 441 }
 442
 443 U_CAPI void  U_EXPORT2
 444 ucal_add(    UCalendar*                cal,
 445          UCalendarDateFields        field,
 446          int32_t                    amount,
 447          UErrorCode*                status)
 448 {
 449
 450     if(U_FAILURE(*status)) return;
 451
 452     ((Calendar*)cal)->add(field, amount, *status);
 453 }
 454
 455 U_CAPI void  U_EXPORT2
 456 ucal_roll(        UCalendar*            cal,
 457           UCalendarDateFields field,
 458           int32_t                amount,
 459           UErrorCode*            status)
 460 {
 461
 462     if(U_FAILURE(*status)) return;
 463
 464     ((Calendar*)cal)->roll(field, amount, *status);
 465 }
 466
 467 U_CAPI int32_t  U_EXPORT2
 468 ucal_get(    const    UCalendar*                cal,
 469          UCalendarDateFields        field,
 470          UErrorCode*                status )
 471 {
 472
 473     if(U_FAILURE(*status)) return -1;
 474
 475     return ((Calendar*)cal)->get(field, *status);
 476 }
 477
 478 U_CAPI void  U_EXPORT2
 479 ucal_set(    UCalendar*                cal,
 480          UCalendarDateFields        field,
 481          int32_t                    value)
 482 {
 483
 484     ((Calendar*)cal)->set(field, value);
 485 }
 486
 487 U_CAPI UBool  U_EXPORT2
 488 ucal_isSet(    const    UCalendar*                cal,
 489            UCalendarDateFields        field)
 490 {
 491
 492     return ((Calendar*)cal)->isSet(field);
 493 }
 494
 495 U_CAPI void  U_EXPORT2
 496 ucal_clearField(    UCalendar*            cal,
 497                 UCalendarDateFields field)
 498 {
 499
 500     ((Calendar*)cal)->clear(field);
 501 }
 502
 503 U_CAPI void  U_EXPORT2
 504 ucal_clear(UCalendar* calendar)
 505 {
 506
 507     ((Calendar*)calendar)->clear();
 508 }
 509
 510 U_CAPI int32_t  U_EXPORT2
 511 ucal_getLimit(    const    UCalendar*              cal,
 512               UCalendarDateFields     field,
 513               UCalendarLimitType      type,
 514               UErrorCode        *status)
 515 {
 516
 517     if(status==0 || U_FAILURE(*status)) {
 518         return -1;
 519     }
 520
 521     switch(type) {
 522   case UCAL_MINIMUM:
 523       return ((Calendar*)cal)->getMinimum(field);
 524
 525   case UCAL_MAXIMUM:
 526       return ((Calendar*)cal)->getMaximum(field);
 527
 528   case UCAL_GREATEST_MINIMUM:
 529       return ((Calendar*)cal)->getGreatestMinimum(field);
 530
 531   case UCAL_LEAST_MAXIMUM:
 532       return ((Calendar*)cal)->getLeastMaximum(field);
 533
 534   case UCAL_ACTUAL_MINIMUM:
 535       return ((Calendar*)cal)->getActualMinimum(field,
 536           *status);
 537
 538   case UCAL_ACTUAL_MAXIMUM:
 539       return ((Calendar*)cal)->getActualMaximum(field,
 540           *status);
 541
 542   default:
 543       break;
 544     }
 545     return -1;
 546 }
 547
 548 U_CAPI const char * U_EXPORT2
 549 ucal_getLocaleByType(const UCalendar *cal, ULocDataLocaleType type, UErrorCode* status)
 550 {
 551     if (cal == NULL) {
 552         if (U_SUCCESS(*status)) {
 553             *status = U_ILLEGAL_ARGUMENT_ERROR;
 554         }
 555         return NULL;
 556     }
 557     return ((Calendar*)cal)->getLocaleID(type, *status);
 558 }
 559
 560 U_CAPI const char * U_EXPORT2
 561 ucal_getTZDataVersion(UErrorCode* status)
 562 {
 563     return TimeZone::getTZDataVersion(*status);
 564 }
 565
 566 U_CAPI int32_t U_EXPORT2
 567 ucal_getCanonicalTimeZoneID(const UChar* id, int32_t len,
 568                             UChar* result, int32_t resultCapacity, UBool *isSystemID, UErrorCode* status) {
 569     if(status == 0 || U_FAILURE(*status)) {
 570         return 0;
 571     }
 572     if (isSystemID) {
 573         *isSystemID = FALSE;
 574     }
 575     if (id == 0 || len == 0 || result == 0 || resultCapacity <= 0) {
 576         *status = U_ILLEGAL_ARGUMENT_ERROR;
 577         return 0;
 578     }
 579     int32_t reslen = 0;
 580     UnicodeString canonical;
 581     UBool systemID = FALSE;
 582     TimeZone::getCanonicalID(UnicodeString(id, len), canonical, systemID, *status);
 583     if (U_SUCCESS(*status)) {
 584         if (isSystemID) {
 585             *isSystemID = systemID;
 586         }
 587         reslen = canonical.extract(result, resultCapacity, *status);
 588     }
 589     return reslen;
 590 }
 591
 592 U_CAPI const char * U_EXPORT2
 593 ucal_getType(const UCalendar *cal, UErrorCode* status)
 594 {
 595     if (U_FAILURE(*status)) {
 596         return NULL;
 597     }
 598     return ((Calendar*)cal)->getType();
 599 }
 600
 601 U_CAPI UCalendarWeekdayType U_EXPORT2
 602 ucal_getDayOfWeekType(const UCalendar *cal, UCalendarDaysOfWeek dayOfWeek, UErrorCode* status)
 603 {
 604     if (U_FAILURE(*status)) {
 605         return UCAL_WEEKDAY;
 606     }
 607     return ((Calendar*)cal)->getDayOfWeekType(dayOfWeek, *status);
 608 }
 609
 610 U_CAPI int32_t U_EXPORT2
 611 ucal_getWeekendTransition(const UCalendar *cal, UCalendarDaysOfWeek dayOfWeek, UErrorCode *status)
 612 {
 613     if (U_FAILURE(*status)) {
 614         return 0;
 615     }
 616     return ((Calendar*)cal)->getWeekendTransition(dayOfWeek, *status);
 617 }
 618
 619 U_CAPI UBool U_EXPORT2
 620 ucal_isWeekend(const UCalendar *cal, UDate date, UErrorCode *status)
 621 {
 622     if (U_FAILURE(*status)) {
 623         return FALSE;
 624     }
 625     return ((Calendar*)cal)->isWeekend(date, *status);
 626 }
 627
 628 U_CAPI int32_t  U_EXPORT2
 629 ucal_getFieldDifference(UCalendar* cal, UDate target,
 630                         UCalendarDateFields field,
 631                         UErrorCode* status )
 632 {
 633     if (U_FAILURE(*status)) {
 634         return 0;
 635     }
 636     return ((Calendar*)cal)->fieldDifference(target, field, *status);
 637 }
 638
 639
 640 static const UEnumeration defaultKeywordValues = {
 641     NULL,
 642     NULL,
 643     ulist_close_keyword_values_iterator,
 644     ulist_count_keyword_values,
 645     uenum_unextDefault,
 646     ulist_next_keyword_value,
 647     ulist_reset_keyword_values_iterator
 648 };
 649
 650 static const char * const CAL_TYPES[] = {
 651         "gregorian",
 652         "japanese",
 653         "buddhist",
 654         "roc",
 655         "persian",
 656         "islamic-civil",
 657         "islamic",
 658         "hebrew",
 659         "chinese",
 660         "indian",
 661         "coptic",
 662         "ethiopic",
 663         "ethiopic-amete-alem",
 664         "iso8601",
 665         "dangi",
 666         "islamic-umalqura",
 667         "islamic-tbla",
 668         "islamic-rgsa",
 669         NULL
 670 };
 671
 672 U_CAPI UEnumeration* U_EXPORT2
 673 ucal_getKeywordValuesForLocale(const char * /* key */, const char* locale, UBool commonlyUsed, UErrorCode *status) {
 674     // Resolve region
 675     char prefRegion[ULOC_COUNTRY_CAPACITY];
 676     (void)ulocimp_getRegionForSupplementalData(locale, TRUE, prefRegion, sizeof(prefRegion), status);
 677
 678     // Read preferred calendar values from supplementalData calendarPreference
 679     UResourceBundle *rb = ures_openDirect(NULL, "supplementalData", status);
 680     ures_getByKey(rb, "calendarPreferenceData", rb, status);
 681     UResourceBundle *order = ures_getByKey(rb, prefRegion, NULL, status);
 682     if (*status == U_MISSING_RESOURCE_ERROR && rb != NULL) {
 683         *status = U_ZERO_ERROR;
 684         order = ures_getByKey(rb, "001", NULL, status);
 685     }
 686
 687     // Create a list of calendar type strings
 688     UList *values = NULL;
 689     if (U_SUCCESS(*status)) {
 690         values = ulist_createEmptyList(status);
 691         if (U_SUCCESS(*status)) {
 692             for (int i = 0; i < ures_getSize(order); i++) {
 693                 int32_t len;
 694                 const UChar *type = ures_getStringByIndex(order, i, &len, status);
 695                 char *caltype = (char*)uprv_malloc(len + 1);
 696                 if (caltype == NULL) {
 697                     *status = U_MEMORY_ALLOCATION_ERROR;
 698                     break;
 699                 }
 700                 u_UCharsToChars(type, caltype, len);
 701                 *(caltype + len) = 0;
 702
 703                 ulist_addItemEndList(values, caltype, TRUE, status);
 704                 if (U_FAILURE(*status)) {
 705                     break;
 706                 }
 707             }
 708
 709             if (U_SUCCESS(*status) && !commonlyUsed) {
 710                 // If not commonlyUsed, add other available values
 711                 for (int32_t i = 0; CAL_TYPES[i] != NULL; i++) {
 712                     if (!ulist_containsString(values, CAL_TYPES[i], (int32_t)uprv_strlen(CAL_TYPES[i]))) {
 713                         ulist_addItemEndList(values, CAL_TYPES[i], FALSE, status);
 714                         if (U_FAILURE(*status)) {
 715                             break;
 716                         }
 717                     }
 718                 }
 719             }
 720             if (U_FAILURE(*status)) {
 721                 ulist_deleteList(values);
 722                 values = NULL;
 723             }
 724         }
 725     }
 726
 727     ures_close(order);
 728     ures_close(rb);
 729
 730     if (U_FAILURE(*status) || values == NULL) {
 731         return NULL;
 732     }
 733
 734     // Create string enumeration
 735     UEnumeration *en = (UEnumeration*)uprv_malloc(sizeof(UEnumeration));
 736     if (en == NULL) {
 737         *status = U_MEMORY_ALLOCATION_ERROR;
 738         ulist_deleteList(values);
 739         return NULL;
 740     }
 741     ulist_resetList(values);
 742     memcpy(en, &defaultKeywordValues, sizeof(UEnumeration));
 743     en->context = values;
 744     return en;
 745 }
 746
 747 U_CAPI UBool U_EXPORT2
 748 ucal_getTimeZoneTransitionDate(const UCalendar* cal, UTimeZoneTransitionType type,
 749                                UDate* transition, UErrorCode* status)
 750 {
 751     if (U_FAILURE(*status)) {
 752         return FALSE;
 753     }
 754     UDate base = ((Calendar*)cal)->getTime(*status);
 755     const TimeZone& tz = ((Calendar*)cal)->getTimeZone();
 756     const BasicTimeZone * btz = dynamic_cast<const BasicTimeZone *>(&tz);
 757     if (btz != NULL && U_SUCCESS(*status)) {
 758         TimeZoneTransition tzt;
 759         UBool inclusive = (type == UCAL_TZ_TRANSITION_NEXT_INCLUSIVE || type == UCAL_TZ_TRANSITION_PREVIOUS_INCLUSIVE);
 760         UBool result = (type == UCAL_TZ_TRANSITION_NEXT || type == UCAL_TZ_TRANSITION_NEXT_INCLUSIVE)?
 761                         btz->getNextTransition(base, inclusive, tzt):
 762                         btz->getPreviousTransition(base, inclusive, tzt);
 763         if (result) {
 764             *transition = tzt.getTime();
 765             return TRUE;
 766         }
 767     }
 768     return FALSE;
 769 }
 770
 771 U_CAPI int32_t U_EXPORT2
 772 ucal_getWindowsTimeZoneID(const UChar* id, int32_t len, UChar* winid, int32_t winidCapacity, UErrorCode* status) {
 773     if (U_FAILURE(*status)) {
 774         return 0;
 775     }
 776
 777     int32_t resultLen = 0;
 778     UnicodeString resultWinID;
 779
 780     TimeZone::getWindowsID(UnicodeString(id, len), resultWinID, *status);
 781     if (U_SUCCESS(*status) && resultWinID.length() > 0) {
 782         resultLen = resultWinID.length();
 783         resultWinID.extract(winid, winidCapacity, *status);
 784     }
 785
 786     return resultLen;
 787 }
 788
 789 U_CAPI int32_t U_EXPORT2
 790 ucal_getTimeZoneIDForWindowsID(const UChar* winid, int32_t len, const char* region, UChar* id, int32_t idCapacity, UErrorCode* status) {
 791     if (U_FAILURE(*status)) {
 792         return 0;
 793     }
 794
 795     int32_t resultLen = 0;
 796     UnicodeString resultID;
 797
 798     TimeZone::getIDForWindowsID(UnicodeString(winid, len), region, resultID, *status);
 799     if (U_SUCCESS(*status) && resultID.length() > 0) {
 800         resultLen = resultID.length();
 801         resultID.extract(id, idCapacity, *status);
 802     }
 803
 804     return resultLen;
 805 }
 806
 807 // Apple-specific function uacal_getDayPeriod and helper functions/data
 808 typedef struct {
 809     const char* name;
 810     UADayPeriod value;
 811 } DayPeriodNameToValue;
 812
 813 static const DayPeriodNameToValue dpNameToValue[] = {
 814     { "afternoon1", UADAYPERIOD_AFTERNOON1 },
 815     { "afternoon2", UADAYPERIOD_AFTERNOON2 },
 816     { "evening1",   UADAYPERIOD_EVENING1   },
 817     { "evening2",   UADAYPERIOD_EVENING2   },
 818     { "midnight",   UADAYPERIOD_MIDNIGHT   },
 819     { "morning1",   UADAYPERIOD_MORNING1   },
 820     { "morning2",   UADAYPERIOD_MORNING2   },
 821     { "night1",     UADAYPERIOD_NIGHT1     },
 822     { "night2",     UADAYPERIOD_NIGHT2     },
 823     { "noon",       UADAYPERIOD_NOON       },
 824 };
 825
 826 static UADayPeriod dayPeriodFromName(const char* name) {
 827     const DayPeriodNameToValue * dpNameToValuePtr = dpNameToValue;
 828     const DayPeriodNameToValue * dpNameToValueLim = dpNameToValue +  UPRV_LENGTHOF(dpNameToValue);
 829     // simple linear search, dpNameToValue is small enough
 830     for (; dpNameToValuePtr < dpNameToValueLim; dpNameToValuePtr++) {
 831         if (uprv_strcmp(name, dpNameToValuePtr->name) == 0) {
 832             return dpNameToValuePtr->value;
 833         }
 834     }
 835     return UADAYPERIOD_UNKNOWN;
 836 }
 837
 838 typedef struct {
 839     int32_t startHour;
 840     int32_t startMin;
 841     UADayPeriod value;
 842 } DayPeriodEntry;
 843
 844 int CompareDayPeriodEntries(const void* entry1Ptr, const void* entry2Ptr) {
 845     const DayPeriodEntry * dpEntry1Ptr = (const DayPeriodEntry *)entry1Ptr;
 846     const DayPeriodEntry * dpEntry2Ptr = (const DayPeriodEntry *)entry2Ptr;
 847     if (dpEntry1Ptr->startHour < dpEntry2Ptr->startHour) return -1;
 848     if (dpEntry1Ptr->startHour > dpEntry2Ptr->startHour) return 1;
 849     // here hours are equal
 850     if (dpEntry1Ptr->startMin < dpEntry2Ptr->startMin) return -1;
 851     if (dpEntry1Ptr->startMin > dpEntry2Ptr->startMin) return 1;
 852     return 0;
 853 }
 854
 855 enum { kSetNameMaxLen = 8, kBoundaryTimeMaxLen = 6, kDayPeriodEntriesMax = 12 };
 856
 857 U_CAPI UADayPeriod U_EXPORT2
 858 uacal_getDayPeriod( const char* locale,
 859                     int32_t     hour,
 860                     int32_t     minute,
 861                     UBool       formatStyle,
 862                     UErrorCode* status ) {
 863     UADayPeriod dayPeriod = UADAYPERIOD_UNKNOWN;
 864     DayPeriodEntry dpEntries[kDayPeriodEntriesMax];
 865     int32_t dpEntriesCount = 0;
 866
 867     if (U_FAILURE(*status)) {
 868         return dayPeriod;
 869     }
 870     if (hour < 0 || hour > 23 || minute < 0 || minute > 59) {
 871         *status = U_ILLEGAL_ARGUMENT_ERROR;
 872         return dayPeriod;
 873     }
 874     // get dayPeriods bundle
 875     LocalUResourceBundlePointer rb(ures_openDirect(NULL, "dayPeriods", status));
 876     if (U_FAILURE(*status)) {
 877         return dayPeriod;
 878     }
 879     // get locales/locales_selection subbundle
 880     LocalUResourceBundlePointer rbSub(ures_getByKey(rb.getAlias(), formatStyle? "locales": "locales_selection", NULL, status));
 881     if (U_FAILURE(*status)) {
 882         return dayPeriod;
 883     }
 884     // get bundle for language (maps to setName)
 885     char lang[ULOC_LANG_CAPACITY] = {0};
 886     if (locale != NULL) {
 887         UErrorCode tempStatus = U_ZERO_ERROR;
 888         uloc_getLanguage(locale, lang, ULOC_LANG_CAPACITY, &tempStatus);
 889         if (U_FAILURE(*status) || *status == U_STRING_NOT_TERMINATED_WARNING) {
 890             lang[0] = 0;
 891         }
 892     }
 893     if (lang[0] == 0) {
 894         uprv_strcpy(lang, "en"); // should be "root" but the data for root was missing
 895     }
 896     LocalUResourceBundlePointer rbLang(ures_getByKey(rbSub.getAlias(), lang, NULL, status));
 897     if (U_FAILURE(*status)) {
 898         // should only happen if lang was not [root] en
 899         // fallback should be "root" but the data for root was missing, use "en"
 900         *status = U_ZERO_ERROR;
 901         rbLang.adoptInstead(ures_getByKey(rbSub.getAlias(), "en", rbLang.orphan(), status));
 902     }
 903     if (U_FAILURE(*status)) {
 904         return dayPeriod;
 905     }
 906     // get setName from language bundle
 907     char setName[kSetNameMaxLen] = {0};
 908     int32_t setNameLen = kSetNameMaxLen;
 909     ures_getUTF8String(rbLang.getAlias(), setName, &setNameLen, TRUE, status);
 910     if (U_FAILURE(*status)) {
 911         return dayPeriod;
 912     }
 913     // get rules subbundle
 914     rbSub.adoptInstead(ures_getByKey(rb.getAlias(), "rules", rbSub.orphan(), status));
 915     if (U_FAILURE(*status)) {
 916         return dayPeriod;
 917     }
 918     // get ruleset from rules subbundle
 919     rb.adoptInstead(ures_getByKey(rbSub.getAlias(), setName, rb.orphan(), status));
 920     if (U_FAILURE(*status)) {
 921         return dayPeriod;
 922     }
 923     // OK, we should finally have a ruleset (works to here).
 924     // Iterate over it to collect entries
 925     LocalUResourceBundlePointer rbBound;
 926     while (ures_hasNext(rb.getAlias())) {
 927         rbSub.adoptInstead(ures_getNextResource(rb.getAlias(), rbSub.orphan(), status));
 928         if (U_FAILURE(*status)) {
 929             return dayPeriod;
 930         }
 931         // rbSub now has the bundle for a particular dayPeriod such as morning1, afternoon2, noon
 932         UADayPeriod dpForBundle = dayPeriodFromName(ures_getKey(rbSub.getAlias()));
 933         int32_t dpLimit = 24;
 934         while (ures_hasNext(rbSub.getAlias())) {
 935             rbBound.adoptInstead(ures_getNextResource(rbSub.getAlias(), rbBound.orphan(), status));
 936             if (U_FAILURE(*status)) {
 937                 return dayPeriod;
 938             }
 939             // rbBound now has the bundle for a particular time period boundary such as at, from, before.
 940             // This is either of type URES_STRING (size=1) or of type URES_ARRAY (size > 1)
 941             const char *boundaryType = ures_getKey(rbBound.getAlias());
 942             char boundaryTimeStr[kBoundaryTimeMaxLen];
 943             int32_t boundaryTimeStrLen = kBoundaryTimeMaxLen;
 944             ures_getUTF8String(rbBound.getAlias(), boundaryTimeStr, &boundaryTimeStrLen, TRUE, status);
 945             if (U_FAILURE(*status)) {
 946                 return dayPeriod;
 947             }
 948             int32_t startHour = atoi(boundaryTimeStr); // can depend on POSIX locale (fortunately no decimal sep here)
 949             if (uprv_strcmp(boundaryType, "before") == 0) {
 950                 dpLimit = startHour;
 951                 continue;
 952             }
 953             int32_t startMinute = 0;
 954             if (uprv_strcmp(boundaryType, "from") == 0) {
 955                 startMinute = 1;
 956                 if (startHour > dpLimit && dpEntriesCount < kDayPeriodEntriesMax) {
 957                     dpEntries[dpEntriesCount].startHour = 0;
 958                     dpEntries[dpEntriesCount].startMin = startMinute;
 959                     dpEntries[dpEntriesCount].value = dpForBundle;
 960                     dpEntriesCount++;
 961                 }
 962             }
 963             if (dpEntriesCount < kDayPeriodEntriesMax) {
 964                 dpEntries[dpEntriesCount].startHour = startHour;
 965                 dpEntries[dpEntriesCount].startMin = startMinute;
 966                 dpEntries[dpEntriesCount].value = dpForBundle;
 967                 dpEntriesCount++;
 968             }
 969         }
 970     }
 971     if (dpEntriesCount < kDayPeriodEntriesMax) {
 972         dpEntries[dpEntriesCount].startHour = 24;
 973         dpEntries[dpEntriesCount].startMin = 0;
 974         dpEntries[dpEntriesCount].value = UADAYPERIOD_UNKNOWN;
 975         dpEntriesCount++;
 976     }
 977     // We have collected all of the rule data, now sort by time
 978     qsort(dpEntries, dpEntriesCount, sizeof(DayPeriodEntry), CompareDayPeriodEntries);
 979
 980     // now fix start minute for the non-"at" entries
 981     int32_t dpIndex;
 982     for (dpIndex = 0; dpIndex < dpEntriesCount; dpIndex++) {
 983         if (dpIndex == 0 || (dpEntries[dpIndex-1].value != UADAYPERIOD_MIDNIGHT && dpEntries[dpIndex-1].value != UADAYPERIOD_NOON)) {
 984             dpEntries[dpIndex].startMin = 0;
 985         }
 986     }
 987
 988     // OK, all of the above is what we would do in an "open" function if we were using an
 989     // open/use/close model for this; the object would just have the sorted array above.
 990
 991     // Now we use the sorted array to find the dayPeriod matching the supplied time.
 992     // Only a few entries, linear search OK
 993     DayPeriodEntry entryToMatch = { hour, minute, UADAYPERIOD_UNKNOWN };
 994     dpIndex = 0;
 995     while (dpIndex < dpEntriesCount - 1 && CompareDayPeriodEntries(&entryToMatch, &dpEntries[dpIndex + 1]) >= 0) {
 996         dpIndex++;
 997     }
 998     if (CompareDayPeriodEntries(&entryToMatch, &dpEntries[dpIndex]) >= 0) {
 999         dayPeriod = dpEntries[dpIndex].value;
1000     }
1001
1002     return dayPeriod;
1003 }
1004
1005
1006
1007 #endif /* #if !UCONFIG_NO_FORMATTING */