| /* | |
| ******************************************************************************* | |
| * Copyright (C) 1996-2015, International Business Machines | |
| * Corporation and others. All Rights Reserved. | |
| ******************************************************************************* | |
| */ | |
| #include "utypeinfo.h" // for 'typeid' to work | |
| #include "unicode/utypes.h" | |
| #if !UCONFIG_NO_FORMATTING | |
| #include "starboard/client_porting/poem/string_poem.h" | |
| #include "unicode/ucal.h" | |
| #include "unicode/uloc.h" | |
| #include "unicode/calendar.h" | |
| #include "unicode/timezone.h" | |
| #include "unicode/gregocal.h" | |
| #include "unicode/simpletz.h" | |
| #include "unicode/ustring.h" | |
| #include "unicode/strenum.h" | |
| #include "unicode/localpointer.h" | |
| #include "cmemory.h" | |
| #include "cstring.h" | |
| #include "ustrenum.h" | |
| #include "uenumimp.h" | |
| #include "ulist.h" | |
| U_NAMESPACE_USE | |
| static TimeZone* | |
| _createTimeZone(const UChar* zoneID, int32_t len, UErrorCode* ec) { | |
| TimeZone* zone = NULL; | |
| if (ec!=NULL && U_SUCCESS(*ec)) { | |
| // Note that if zoneID is invalid, we get back GMT. This odd | |
| // behavior is by design and goes back to the JDK. The only | |
| // failure we will see is a memory allocation failure. | |
| int32_t l = (len<0 ? u_strlen(zoneID) : len); | |
| UnicodeString zoneStrID; | |
| zoneStrID.setTo((UBool)(len < 0), zoneID, l); /* temporary read-only alias */ | |
| zone = TimeZone::createTimeZone(zoneStrID); | |
| if (zone == NULL) { | |
| *ec = U_MEMORY_ALLOCATION_ERROR; | |
| } | |
| } | |
| return zone; | |
| } | |
| U_CAPI UEnumeration* U_EXPORT2 | |
| ucal_openTimeZoneIDEnumeration(USystemTimeZoneType zoneType, const char* region, | |
| const int32_t* rawOffset, UErrorCode* ec) { | |
| return uenum_openFromStringEnumeration(TimeZone::createTimeZoneIDEnumeration( | |
| zoneType, region, rawOffset, *ec), ec); | |
| } | |
| U_CAPI UEnumeration* U_EXPORT2 | |
| ucal_openTimeZones(UErrorCode* ec) { | |
| return uenum_openFromStringEnumeration(TimeZone::createEnumeration(), ec); | |
| } | |
| U_CAPI UEnumeration* U_EXPORT2 | |
| ucal_openCountryTimeZones(const char* country, UErrorCode* ec) { | |
| return uenum_openFromStringEnumeration(TimeZone::createEnumeration(country), ec); | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| ucal_getDefaultTimeZone(UChar* result, int32_t resultCapacity, UErrorCode* ec) { | |
| int32_t len = 0; | |
| if (ec!=NULL && U_SUCCESS(*ec)) { | |
| TimeZone* zone = TimeZone::createDefault(); | |
| if (zone == NULL) { | |
| *ec = U_MEMORY_ALLOCATION_ERROR; | |
| } else { | |
| UnicodeString id; | |
| zone->getID(id); | |
| delete zone; | |
| len = id.extract(result, resultCapacity, *ec); | |
| } | |
| } | |
| return len; | |
| } | |
| U_CAPI void U_EXPORT2 | |
| ucal_setDefaultTimeZone(const UChar* zoneID, UErrorCode* ec) { | |
| TimeZone* zone = _createTimeZone(zoneID, -1, ec); | |
| if (zone != NULL) { | |
| TimeZone::adoptDefault(zone); | |
| } | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| ucal_getDSTSavings(const UChar* zoneID, UErrorCode* ec) { | |
| int32_t result = 0; | |
| TimeZone* zone = _createTimeZone(zoneID, -1, ec); | |
| if (U_SUCCESS(*ec)) { | |
| SimpleTimeZone* stz = dynamic_cast<SimpleTimeZone*>(zone); | |
| if (stz != NULL) { | |
| result = stz->getDSTSavings(); | |
| } else { | |
| // Since there is no getDSTSavings on TimeZone, we use a | |
| // heuristic: Starting with the current time, march | |
| // forwards for one year, looking for DST savings. | |
| // Stepping by weeks is sufficient. | |
| UDate d = Calendar::getNow(); | |
| for (int32_t i=0; i<53; ++i, d+=U_MILLIS_PER_DAY*7.0) { | |
| int32_t raw, dst; | |
| zone->getOffset(d, FALSE, raw, dst, *ec); | |
| if (U_FAILURE(*ec)) { | |
| break; | |
| } else if (dst != 0) { | |
| result = dst; | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| delete zone; | |
| return result; | |
| } | |
| U_CAPI UDate U_EXPORT2 | |
| ucal_getNow() | |
| { | |
| return Calendar::getNow(); | |
| } | |
| #define ULOC_LOCALE_IDENTIFIER_CAPACITY (ULOC_FULLNAME_CAPACITY + 1 + ULOC_KEYWORD_AND_VALUES_CAPACITY) | |
| U_CAPI UCalendar* U_EXPORT2 | |
| ucal_open( const UChar* zoneID, | |
| int32_t len, | |
| const char* locale, | |
| UCalendarType caltype, | |
| UErrorCode* status) | |
| { | |
| if(U_FAILURE(*status)) return 0; | |
| TimeZone* zone = (zoneID==NULL) ? TimeZone::createDefault() | |
| : _createTimeZone(zoneID, len, status); | |
| if (U_FAILURE(*status)) { | |
| return NULL; | |
| } | |
| if ( caltype == UCAL_GREGORIAN ) { | |
| char localeBuf[ULOC_LOCALE_IDENTIFIER_CAPACITY]; | |
| if ( locale == NULL ) { | |
| locale = uloc_getDefault(); | |
| } | |
| uprv_strncpy(localeBuf, locale, ULOC_LOCALE_IDENTIFIER_CAPACITY); | |
| uloc_setKeywordValue("calendar", "gregorian", localeBuf, ULOC_LOCALE_IDENTIFIER_CAPACITY, status); | |
| if (U_FAILURE(*status)) { | |
| return NULL; | |
| } | |
| return (UCalendar*)Calendar::createInstance(zone, Locale(localeBuf), *status); | |
| } | |
| return (UCalendar*)Calendar::createInstance(zone, Locale(locale), *status); | |
| } | |
| U_CAPI void U_EXPORT2 | |
| ucal_close(UCalendar *cal) | |
| { | |
| delete (Calendar*) cal; | |
| } | |
| U_CAPI UCalendar* U_EXPORT2 | |
| ucal_clone(const UCalendar* cal, | |
| UErrorCode* status) | |
| { | |
| if(U_FAILURE(*status)) return 0; | |
| Calendar* res = ((Calendar*)cal)->clone(); | |
| if(res == 0) { | |
| *status = U_MEMORY_ALLOCATION_ERROR; | |
| return 0; | |
| } | |
| return (UCalendar*) res; | |
| } | |
| U_CAPI void U_EXPORT2 | |
| ucal_setTimeZone( UCalendar* cal, | |
| const UChar* zoneID, | |
| int32_t len, | |
| UErrorCode *status) | |
| { | |
| if(U_FAILURE(*status)) | |
| return; | |
| TimeZone* zone = (zoneID==NULL) ? TimeZone::createDefault() | |
| : _createTimeZone(zoneID, len, status); | |
| if (zone != NULL) { | |
| ((Calendar*)cal)->adoptTimeZone(zone); | |
| } | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| ucal_getTimeZoneID(const UCalendar *cal, | |
| UChar *result, | |
| int32_t resultLength, | |
| UErrorCode *status) | |
| { | |
| if (U_FAILURE(*status)) { | |
| return 0; | |
| } | |
| const TimeZone& tz = ((Calendar*)cal)->getTimeZone(); | |
| UnicodeString id; | |
| tz.getID(id); | |
| return id.extract(result, resultLength, *status); | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| ucal_getTimeZoneDisplayName(const UCalendar* cal, | |
| UCalendarDisplayNameType type, | |
| const char *locale, | |
| UChar* result, | |
| int32_t resultLength, | |
| UErrorCode* status) | |
| { | |
| if(U_FAILURE(*status)) return -1; | |
| const TimeZone& tz = ((Calendar*)cal)->getTimeZone(); | |
| UnicodeString id; | |
| if(!(result==NULL && resultLength==0)) { | |
| // NULL destination for pure preflighting: empty dummy string | |
| // otherwise, alias the destination buffer | |
| id.setTo(result, 0, resultLength); | |
| } | |
| switch(type) { | |
| case UCAL_STANDARD: | |
| tz.getDisplayName(FALSE, TimeZone::LONG, Locale(locale), id); | |
| break; | |
| case UCAL_SHORT_STANDARD: | |
| tz.getDisplayName(FALSE, TimeZone::SHORT, Locale(locale), id); | |
| break; | |
| case UCAL_DST: | |
| tz.getDisplayName(TRUE, TimeZone::LONG, Locale(locale), id); | |
| break; | |
| case UCAL_SHORT_DST: | |
| tz.getDisplayName(TRUE, TimeZone::SHORT, Locale(locale), id); | |
| break; | |
| } | |
| return id.extract(result, resultLength, *status); | |
| } | |
| U_CAPI UBool U_EXPORT2 | |
| ucal_inDaylightTime( const UCalendar* cal, | |
| UErrorCode* status ) | |
| { | |
| if(U_FAILURE(*status)) return (UBool) -1; | |
| return ((Calendar*)cal)->inDaylightTime(*status); | |
| } | |
| U_CAPI void U_EXPORT2 | |
| ucal_setGregorianChange(UCalendar *cal, UDate date, UErrorCode *pErrorCode) { | |
| if(U_FAILURE(*pErrorCode)) { | |
| return; | |
| } | |
| Calendar *cpp_cal = (Calendar *)cal; | |
| GregorianCalendar *gregocal = dynamic_cast<GregorianCalendar *>(cpp_cal); | |
| // Not if(gregocal == NULL) { | |
| // because we really want to work only with a GregorianCalendar, not with | |
| // its subclasses like BuddhistCalendar. | |
| if (cpp_cal == NULL) { | |
| // We normally don't check "this" pointers for NULL, but this here avoids | |
| // compiler-generated exception-throwing code in case cal == NULL. | |
| *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR; | |
| return; | |
| } | |
| if(typeid(*cpp_cal) != typeid(GregorianCalendar)) { | |
| *pErrorCode = U_UNSUPPORTED_ERROR; | |
| return; | |
| } | |
| gregocal->setGregorianChange(date, *pErrorCode); | |
| } | |
| U_CAPI UDate U_EXPORT2 | |
| ucal_getGregorianChange(const UCalendar *cal, UErrorCode *pErrorCode) { | |
| if(U_FAILURE(*pErrorCode)) { | |
| return (UDate)0; | |
| } | |
| const Calendar *cpp_cal = (const Calendar *)cal; | |
| const GregorianCalendar *gregocal = dynamic_cast<const GregorianCalendar *>(cpp_cal); | |
| // Not if(gregocal == NULL) { | |
| // see comments in ucal_setGregorianChange(). | |
| if (cpp_cal == NULL) { | |
| // We normally don't check "this" pointers for NULL, but this here avoids | |
| // compiler-generated exception-throwing code in case cal == NULL. | |
| *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR; | |
| return (UDate)0; | |
| } | |
| if(typeid(*cpp_cal) != typeid(GregorianCalendar)) { | |
| *pErrorCode = U_UNSUPPORTED_ERROR; | |
| return (UDate)0; | |
| } | |
| return gregocal->getGregorianChange(); | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| ucal_getAttribute( const UCalendar* cal, | |
| UCalendarAttribute attr) | |
| { | |
| switch(attr) { | |
| case UCAL_LENIENT: | |
| return ((Calendar*)cal)->isLenient(); | |
| case UCAL_FIRST_DAY_OF_WEEK: | |
| return ((Calendar*)cal)->getFirstDayOfWeek(); | |
| case UCAL_MINIMAL_DAYS_IN_FIRST_WEEK: | |
| return ((Calendar*)cal)->getMinimalDaysInFirstWeek(); | |
| case UCAL_REPEATED_WALL_TIME: | |
| return ((Calendar*)cal)->getRepeatedWallTimeOption(); | |
| case UCAL_SKIPPED_WALL_TIME: | |
| return ((Calendar*)cal)->getSkippedWallTimeOption(); | |
| default: | |
| break; | |
| } | |
| return -1; | |
| } | |
| U_CAPI void U_EXPORT2 | |
| ucal_setAttribute( UCalendar* cal, | |
| UCalendarAttribute attr, | |
| int32_t newValue) | |
| { | |
| switch(attr) { | |
| case UCAL_LENIENT: | |
| ((Calendar*)cal)->setLenient((UBool)newValue); | |
| break; | |
| case UCAL_FIRST_DAY_OF_WEEK: | |
| ((Calendar*)cal)->setFirstDayOfWeek((UCalendarDaysOfWeek)newValue); | |
| break; | |
| case UCAL_MINIMAL_DAYS_IN_FIRST_WEEK: | |
| ((Calendar*)cal)->setMinimalDaysInFirstWeek((uint8_t)newValue); | |
| break; | |
| case UCAL_REPEATED_WALL_TIME: | |
| ((Calendar*)cal)->setRepeatedWallTimeOption((UCalendarWallTimeOption)newValue); | |
| break; | |
| case UCAL_SKIPPED_WALL_TIME: | |
| ((Calendar*)cal)->setSkippedWallTimeOption((UCalendarWallTimeOption)newValue); | |
| break; | |
| } | |
| } | |
| U_CAPI const char* U_EXPORT2 | |
| ucal_getAvailable(int32_t index) | |
| { | |
| return uloc_getAvailable(index); | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| ucal_countAvailable() | |
| { | |
| return uloc_countAvailable(); | |
| } | |
| U_CAPI UDate U_EXPORT2 | |
| ucal_getMillis( const UCalendar* cal, | |
| UErrorCode* status) | |
| { | |
| if(U_FAILURE(*status)) return (UDate) 0; | |
| return ((Calendar*)cal)->getTime(*status); | |
| } | |
| U_CAPI void U_EXPORT2 | |
| ucal_setMillis( UCalendar* cal, | |
| UDate dateTime, | |
| UErrorCode* status ) | |
| { | |
| if(U_FAILURE(*status)) return; | |
| ((Calendar*)cal)->setTime(dateTime, *status); | |
| } | |
| // TBD: why does this take an UErrorCode? | |
| U_CAPI void U_EXPORT2 | |
| ucal_setDate( UCalendar* cal, | |
| int32_t year, | |
| int32_t month, | |
| int32_t date, | |
| UErrorCode *status) | |
| { | |
| if(U_FAILURE(*status)) return; | |
| ((Calendar*)cal)->set(year, month, date); | |
| } | |
| // TBD: why does this take an UErrorCode? | |
| U_CAPI void U_EXPORT2 | |
| ucal_setDateTime( UCalendar* cal, | |
| int32_t year, | |
| int32_t month, | |
| int32_t date, | |
| int32_t hour, | |
| int32_t minute, | |
| int32_t second, | |
| UErrorCode *status) | |
| { | |
| if(U_FAILURE(*status)) return; | |
| ((Calendar*)cal)->set(year, month, date, hour, minute, second); | |
| } | |
| U_CAPI UBool U_EXPORT2 | |
| ucal_equivalentTo( const UCalendar* cal1, | |
| const UCalendar* cal2) | |
| { | |
| return ((Calendar*)cal1)->isEquivalentTo(*((Calendar*)cal2)); | |
| } | |
| U_CAPI void U_EXPORT2 | |
| ucal_add( UCalendar* cal, | |
| UCalendarDateFields field, | |
| int32_t amount, | |
| UErrorCode* status) | |
| { | |
| if(U_FAILURE(*status)) return; | |
| ((Calendar*)cal)->add(field, amount, *status); | |
| } | |
| U_CAPI void U_EXPORT2 | |
| ucal_roll( UCalendar* cal, | |
| UCalendarDateFields field, | |
| int32_t amount, | |
| UErrorCode* status) | |
| { | |
| if(U_FAILURE(*status)) return; | |
| ((Calendar*)cal)->roll(field, amount, *status); | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| ucal_get( const UCalendar* cal, | |
| UCalendarDateFields field, | |
| UErrorCode* status ) | |
| { | |
| if(U_FAILURE(*status)) return -1; | |
| return ((Calendar*)cal)->get(field, *status); | |
| } | |
| U_CAPI void U_EXPORT2 | |
| ucal_set( UCalendar* cal, | |
| UCalendarDateFields field, | |
| int32_t value) | |
| { | |
| ((Calendar*)cal)->set(field, value); | |
| } | |
| U_CAPI UBool U_EXPORT2 | |
| ucal_isSet( const UCalendar* cal, | |
| UCalendarDateFields field) | |
| { | |
| return ((Calendar*)cal)->isSet(field); | |
| } | |
| U_CAPI void U_EXPORT2 | |
| ucal_clearField( UCalendar* cal, | |
| UCalendarDateFields field) | |
| { | |
| ((Calendar*)cal)->clear(field); | |
| } | |
| U_CAPI void U_EXPORT2 | |
| ucal_clear(UCalendar* calendar) | |
| { | |
| ((Calendar*)calendar)->clear(); | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| ucal_getLimit( const UCalendar* cal, | |
| UCalendarDateFields field, | |
| UCalendarLimitType type, | |
| UErrorCode *status) | |
| { | |
| if(status==0 || U_FAILURE(*status)) { | |
| return -1; | |
| } | |
| switch(type) { | |
| case UCAL_MINIMUM: | |
| return ((Calendar*)cal)->getMinimum(field); | |
| case UCAL_MAXIMUM: | |
| return ((Calendar*)cal)->getMaximum(field); | |
| case UCAL_GREATEST_MINIMUM: | |
| return ((Calendar*)cal)->getGreatestMinimum(field); | |
| case UCAL_LEAST_MAXIMUM: | |
| return ((Calendar*)cal)->getLeastMaximum(field); | |
| case UCAL_ACTUAL_MINIMUM: | |
| return ((Calendar*)cal)->getActualMinimum(field, | |
| *status); | |
| case UCAL_ACTUAL_MAXIMUM: | |
| return ((Calendar*)cal)->getActualMaximum(field, | |
| *status); | |
| default: | |
| break; | |
| } | |
| return -1; | |
| } | |
| U_CAPI const char * U_EXPORT2 | |
| ucal_getLocaleByType(const UCalendar *cal, ULocDataLocaleType type, UErrorCode* status) | |
| { | |
| if (cal == NULL) { | |
| if (U_SUCCESS(*status)) { | |
| *status = U_ILLEGAL_ARGUMENT_ERROR; | |
| } | |
| return NULL; | |
| } | |
| return ((Calendar*)cal)->getLocaleID(type, *status); | |
| } | |
| U_CAPI const char * U_EXPORT2 | |
| ucal_getTZDataVersion(UErrorCode* status) | |
| { | |
| return TimeZone::getTZDataVersion(*status); | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| ucal_getCanonicalTimeZoneID(const UChar* id, int32_t len, | |
| UChar* result, int32_t resultCapacity, UBool *isSystemID, UErrorCode* status) { | |
| if(status == 0 || U_FAILURE(*status)) { | |
| return 0; | |
| } | |
| if (isSystemID) { | |
| *isSystemID = FALSE; | |
| } | |
| if (id == 0 || len == 0 || result == 0 || resultCapacity <= 0) { | |
| *status = U_ILLEGAL_ARGUMENT_ERROR; | |
| return 0; | |
| } | |
| int32_t reslen = 0; | |
| UnicodeString canonical; | |
| UBool systemID = FALSE; | |
| TimeZone::getCanonicalID(UnicodeString(id, len), canonical, systemID, *status); | |
| if (U_SUCCESS(*status)) { | |
| if (isSystemID) { | |
| *isSystemID = systemID; | |
| } | |
| reslen = canonical.extract(result, resultCapacity, *status); | |
| } | |
| return reslen; | |
| } | |
| U_CAPI const char * U_EXPORT2 | |
| ucal_getType(const UCalendar *cal, UErrorCode* status) | |
| { | |
| if (U_FAILURE(*status)) { | |
| return NULL; | |
| } | |
| return ((Calendar*)cal)->getType(); | |
| } | |
| U_CAPI UCalendarWeekdayType U_EXPORT2 | |
| ucal_getDayOfWeekType(const UCalendar *cal, UCalendarDaysOfWeek dayOfWeek, UErrorCode* status) | |
| { | |
| if (U_FAILURE(*status)) { | |
| return UCAL_WEEKDAY; | |
| } | |
| return ((Calendar*)cal)->getDayOfWeekType(dayOfWeek, *status); | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| ucal_getWeekendTransition(const UCalendar *cal, UCalendarDaysOfWeek dayOfWeek, UErrorCode *status) | |
| { | |
| if (U_FAILURE(*status)) { | |
| return 0; | |
| } | |
| return ((Calendar*)cal)->getWeekendTransition(dayOfWeek, *status); | |
| } | |
| U_CAPI UBool U_EXPORT2 | |
| ucal_isWeekend(const UCalendar *cal, UDate date, UErrorCode *status) | |
| { | |
| if (U_FAILURE(*status)) { | |
| return FALSE; | |
| } | |
| return ((Calendar*)cal)->isWeekend(date, *status); | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| ucal_getFieldDifference(UCalendar* cal, UDate target, | |
| UCalendarDateFields field, | |
| UErrorCode* status ) | |
| { | |
| if (U_FAILURE(*status)) { | |
| return 0; | |
| } | |
| return ((Calendar*)cal)->fieldDifference(target, field, *status); | |
| } | |
| static const UEnumeration defaultKeywordValues = { | |
| NULL, | |
| NULL, | |
| ulist_close_keyword_values_iterator, | |
| ulist_count_keyword_values, | |
| uenum_unextDefault, | |
| ulist_next_keyword_value, | |
| ulist_reset_keyword_values_iterator | |
| }; | |
| static const char * const CAL_TYPES[] = { | |
| "gregorian", | |
| "japanese", | |
| "buddhist", | |
| "roc", | |
| "persian", | |
| "islamic-civil", | |
| "islamic", | |
| "hebrew", | |
| "chinese", | |
| "indian", | |
| "coptic", | |
| "ethiopic", | |
| "ethiopic-amete-alem", | |
| "iso8601", | |
| "dangi", | |
| "islamic-umalqura", | |
| "islamic-tbla", | |
| "islamic-rgsa", | |
| NULL | |
| }; | |
| U_CAPI UEnumeration* U_EXPORT2 | |
| ucal_getKeywordValuesForLocale(const char * /* key */, const char* locale, UBool commonlyUsed, UErrorCode *status) { | |
| // Resolve region | |
| char prefRegion[ULOC_FULLNAME_CAPACITY] = ""; | |
| int32_t prefRegionLength = 0; | |
| prefRegionLength = uloc_getCountry(locale, prefRegion, sizeof(prefRegion), status); | |
| if (prefRegionLength == 0) { | |
| char loc[ULOC_FULLNAME_CAPACITY] = ""; | |
| uloc_addLikelySubtags(locale, loc, sizeof(loc), status); | |
| prefRegionLength = uloc_getCountry(loc, prefRegion, sizeof(prefRegion), status); | |
| } | |
| // Read preferred calendar values from supplementalData calendarPreference | |
| UResourceBundle *rb = ures_openDirect(NULL, "supplementalData", status); | |
| ures_getByKey(rb, "calendarPreferenceData", rb, status); | |
| UResourceBundle *order = ures_getByKey(rb, prefRegion, NULL, status); | |
| if (*status == U_MISSING_RESOURCE_ERROR && rb != NULL) { | |
| *status = U_ZERO_ERROR; | |
| order = ures_getByKey(rb, "001", NULL, status); | |
| } | |
| // Create a list of calendar type strings | |
| UList *values = NULL; | |
| if (U_SUCCESS(*status)) { | |
| values = ulist_createEmptyList(status); | |
| if (U_SUCCESS(*status)) { | |
| for (int i = 0; i < ures_getSize(order); i++) { | |
| int32_t len; | |
| const UChar *type = ures_getStringByIndex(order, i, &len, status); | |
| char *caltype = (char*)uprv_malloc(len + 1); | |
| if (caltype == NULL) { | |
| *status = U_MEMORY_ALLOCATION_ERROR; | |
| break; | |
| } | |
| u_UCharsToChars(type, caltype, len); | |
| *(caltype + len) = 0; | |
| ulist_addItemEndList(values, caltype, TRUE, status); | |
| if (U_FAILURE(*status)) { | |
| break; | |
| } | |
| } | |
| if (U_SUCCESS(*status) && !commonlyUsed) { | |
| // If not commonlyUsed, add other available values | |
| for (int32_t i = 0; CAL_TYPES[i] != NULL; i++) { | |
| if (!ulist_containsString(values, CAL_TYPES[i], (int32_t)uprv_strlen(CAL_TYPES[i]))) { | |
| ulist_addItemEndList(values, CAL_TYPES[i], FALSE, status); | |
| if (U_FAILURE(*status)) { | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| if (U_FAILURE(*status)) { | |
| ulist_deleteList(values); | |
| values = NULL; | |
| } | |
| } | |
| } | |
| ures_close(order); | |
| ures_close(rb); | |
| if (U_FAILURE(*status) || values == NULL) { | |
| return NULL; | |
| } | |
| // Create string enumeration | |
| UEnumeration *en = (UEnumeration*)uprv_malloc(sizeof(UEnumeration)); | |
| if (en == NULL) { | |
| *status = U_MEMORY_ALLOCATION_ERROR; | |
| ulist_deleteList(values); | |
| return NULL; | |
| } | |
| ulist_resetList(values); | |
| memcpy(en, &defaultKeywordValues, sizeof(UEnumeration)); | |
| en->context = values; | |
| return en; | |
| } | |
| U_CAPI UBool U_EXPORT2 | |
| ucal_getTimeZoneTransitionDate(const UCalendar* cal, UTimeZoneTransitionType type, | |
| UDate* transition, UErrorCode* status) | |
| { | |
| if (U_FAILURE(*status)) { | |
| return FALSE; | |
| } | |
| UDate base = ((Calendar*)cal)->getTime(*status); | |
| const TimeZone& tz = ((Calendar*)cal)->getTimeZone(); | |
| const BasicTimeZone * btz = dynamic_cast<const BasicTimeZone *>(&tz); | |
| if (btz != NULL && U_SUCCESS(*status)) { | |
| TimeZoneTransition tzt; | |
| UBool inclusive = (type == UCAL_TZ_TRANSITION_NEXT_INCLUSIVE || type == UCAL_TZ_TRANSITION_PREVIOUS_INCLUSIVE); | |
| UBool result = (type == UCAL_TZ_TRANSITION_NEXT || type == UCAL_TZ_TRANSITION_NEXT_INCLUSIVE)? | |
| btz->getNextTransition(base, inclusive, tzt): | |
| btz->getPreviousTransition(base, inclusive, tzt); | |
| if (result) { | |
| *transition = tzt.getTime(); | |
| return TRUE; | |
| } | |
| } | |
| return FALSE; | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| ucal_getWindowsTimeZoneID(const UChar* id, int32_t len, UChar* winid, int32_t winidCapacity, UErrorCode* status) { | |
| if (U_FAILURE(*status)) { | |
| return 0; | |
| } | |
| int32_t resultLen = 0; | |
| UnicodeString resultWinID; | |
| TimeZone::getWindowsID(UnicodeString(id, len), resultWinID, *status); | |
| if (U_SUCCESS(*status) && resultWinID.length() > 0) { | |
| resultLen = resultWinID.length(); | |
| resultWinID.extract(winid, winidCapacity, *status); | |
| } | |
| return resultLen; | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| ucal_getTimeZoneIDForWindowsID(const UChar* winid, int32_t len, const char* region, UChar* id, int32_t idCapacity, UErrorCode* status) { | |
| if (U_FAILURE(*status)) { | |
| return 0; | |
| } | |
| int32_t resultLen = 0; | |
| UnicodeString resultID; | |
| TimeZone::getIDForWindowsID(UnicodeString(winid, len), region, resultID, *status); | |
| if (U_SUCCESS(*status) && resultID.length() > 0) { | |
| resultLen = resultID.length(); | |
| resultID.extract(id, idCapacity, *status); | |
| } | |
| return resultLen; | |
| } | |
| #endif /* #if !UCONFIG_NO_FORMATTING */ |