Update ICU to 54.1 step 1

source/i18n/udat.cpp

 /*
 *******************************************************************************
-*   Copyright (C) 1996-2013, International Business Machines
+*   Copyright (C) 1996-2014, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *******************************************************************************
 */
 
 #include "unicode/utypes.h"
 
 #if !UCONFIG_NO_FORMATTING
 
 #include "unicode/udat.h"
 
@@ skipping 46 matching lines @@
     UCAL_WEEK_OF_MONTH,        // UDAT_WEEK_OF_MONTH_FIELD = 13
     UCAL_AM_PM,                // UDAT_AM_PM_FIELD = 14
     UCAL_HOUR,                 // UDAT_HOUR1_FIELD = 15
     UCAL_HOUR,                 // UDAT_HOUR0_FIELD = 16
     UCAL_ZONE_OFFSET,          // UDAT_TIMEZONE_FIELD = 17
     UCAL_YEAR_WOY,             // UDAT_YEAR_WOY_FIELD = 18
     UCAL_DOW_LOCAL,            // UDAT_DOW_LOCAL_FIELD = 19
     UCAL_EXTENDED_YEAR,        // UDAT_EXTENDED_YEAR_FIELD = 20
     UCAL_JULIAN_DAY,           // UDAT_JULIAN_DAY_FIELD = 21
     UCAL_MILLISECONDS_IN_DAY,  // UDAT_MILLISECONDS_IN_DAY_FIELD = 22
-    UCAL_ZONE_OFFSET,          // UDAT_TIMEZONE_RFC_FIELD = 23
-    // UCAL_DST_OFFSET also
-    UCAL_ZONE_OFFSET,          // UDAT_TIMEZONE_GENERIC_FIELD = 24
+    UCAL_ZONE_OFFSET,          // UDAT_TIMEZONE_RFC_FIELD = 23 (also UCAL_DST_OFFSET)
+    UCAL_ZONE_OFFSET,          // UDAT_TIMEZONE_GENERIC_FIELD = 24 (also UCAL_DST_OFFSET)
     UCAL_DOW_LOCAL,            // UDAT_STANDALONE_DAY_FIELD = 25
     UCAL_MONTH,                // UDAT_STANDALONE_MONTH_FIELD = 26
     UCAL_MONTH,                // UDAT_QUARTER_FIELD = 27
     UCAL_MONTH,                // UDAT_STANDALONE_QUARTER_FIELD = 28
-    UCAL_ZONE_OFFSET,          // UDAT_TIMEZONE_SPECIAL_FIELD = 29
+    UCAL_ZONE_OFFSET,          // UDAT_TIMEZONE_SPECIAL_FIELD = 29 (also UCAL_DST_OFFSET)
     UCAL_YEAR,                 // UDAT_YEAR_NAME_FIELD = 30
-    UCAL_FIELD_COUNT,          // UDAT_FIELD_COUNT = 31
+    UCAL_ZONE_OFFSET,          // UDAT_TIMEZONE_LOCALIZED_GMT_OFFSET_FIELD = 31 (also UCAL_DST_OFFSET)
+    UCAL_ZONE_OFFSET,          // UDAT_TIMEZONE_ISO_FIELD = 32 (also UCAL_DST_OFFSET)
+    UCAL_ZONE_OFFSET,          // UDAT_TIMEZONE_ISO_LOCAL_FIELD = 33 (also UCAL_DST_OFFSET)
+    UCAL_EXTENDED_YEAR,        // UDAT_RELATED_YEAR_FIELD = 34 (not an exact match)
+    UCAL_FIELD_COUNT,          // UDAT_FIELD_COUNT = 35
     // UCAL_IS_LEAP_MONTH is not the target of a mapping
 };
 
 U_CAPI UCalendarDateFields U_EXPORT2
 udat_toCalendarDateField(UDateFormatField field) {
   return gDateFieldMapping[field];
 }
 
 /* For now- one opener. */
 static UDateFormatOpener gOpener = NULL;
@@ skipping 210 matching lines @@
     return ((DateFormat*)fmt)->isLenient();
 }
 
 U_CAPI void U_EXPORT2
 udat_setLenient(    UDateFormat*    fmt,
             UBool          isLenient)
 {
     ((DateFormat*)fmt)->setLenient(isLenient);
 }
 
+U_DRAFT UBool U_EXPORT2
+udat_getBooleanAttribute(const UDateFormat* fmt, 
+                         UDateFormatBooleanAttribute attr, 
+                         UErrorCode* status)
+{
+    if(U_FAILURE(*status)) return FALSE;
+    return ((DateFormat*)fmt)->getBooleanAttribute(attr, *status);
+    //return FALSE;
+}
+
+U_DRAFT void U_EXPORT2
+udat_setBooleanAttribute(UDateFormat *fmt, 
+                         UDateFormatBooleanAttribute attr, 
+                         UBool newValue, 
+                         UErrorCode* status)
+{
+    if(U_FAILURE(*status)) return;
+    ((DateFormat*)fmt)->setBooleanAttribute(attr, newValue, *status);
+}
+
 U_CAPI const UCalendar* U_EXPORT2
 udat_getCalendar(const UDateFormat* fmt)
 {
     return (const UCalendar*) ((DateFormat*)fmt)->getCalendar();
 }
 
 U_CAPI void U_EXPORT2
 udat_setCalendar(UDateFormat*    fmt,
                  const   UCalendar*      calendarToSet)
 {
     ((DateFormat*)fmt)->setCalendar(*((Calendar*)calendarToSet));
 }
 
+U_DRAFT const UNumberFormat* U_EXPORT2 
+udat_getNumberFormatForField(const UDateFormat* fmt, UChar field)
+{
+    UErrorCode status = U_ZERO_ERROR;
+    verifyIsSimpleDateFormat(fmt, &status);
+    if (U_FAILURE(status)) return (const UNumberFormat*) ((DateFormat*)fmt)->getNumberFormat();
+    return (const UNumberFormat*) ((SimpleDateFormat*)fmt)->getNumberFormatForField(field);
+}
+
 U_CAPI const UNumberFormat* U_EXPORT2
 udat_getNumberFormat(const UDateFormat* fmt)
 {
     return (const UNumberFormat*) ((DateFormat*)fmt)->getNumberFormat();
 }
 
+U_DRAFT void U_EXPORT2 
+udat_adoptNumberFormatForFields(           UDateFormat*    fmt,
+                                    const  UChar*          fields,
+                                           UNumberFormat*  numberFormatToSet,
+                                           UErrorCode*     status)
+{
+    verifyIsSimpleDateFormat(fmt, status);
+    if (U_FAILURE(*status)) return;
+    
+    if (fields!=NULL) {
+        UnicodeString overrideFields(fields);
+        ((SimpleDateFormat*)fmt)->adoptNumberFormat(overrideFields, (NumberFormat*)numberFormatToSet, *status);
+    }
+}
+
 U_CAPI void U_EXPORT2
 udat_setNumberFormat(UDateFormat*    fmt,
                      const   UNumberFormat*  numberFormatToSet)
 {
     ((DateFormat*)fmt)->setNumberFormat(*((NumberFormat*)numberFormatToSet));
 }
 
+U_DRAFT void U_EXPORT2
+udat_adoptNumberFormat(      UDateFormat*    fmt,
+                             UNumberFormat*  numberFormatToAdopt)
+{
+    ((DateFormat*)fmt)->adoptNumberFormat((NumberFormat*)numberFormatToAdopt);
+}
+
 U_CAPI const char* U_EXPORT2
 udat_getAvailable(int32_t index)
 {
     return uloc_getAvailable(index);
 }
 
 U_CAPI int32_t U_EXPORT2
 udat_countAvailable()
 {
     return uloc_countAvailable();
@@ skipping 185 matching lines @@
         break;
 
     case UDAT_STANDALONE_QUARTERS:
         res = syms->getQuarters(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
         break;
 
     case UDAT_STANDALONE_SHORT_QUARTERS:
         res = syms->getQuarters(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
         break;
 
+    case UDAT_CYCLIC_YEARS_WIDE:
+        res = syms->getYearNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::WIDE);
+        break;
+
+    case UDAT_CYCLIC_YEARS_ABBREVIATED:
+        res = syms->getYearNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::ABBREVIATED);
+        break;
+
+    case UDAT_CYCLIC_YEARS_NARROW:
+        res = syms->getYearNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
+        break;
+
+    case UDAT_ZODIAC_NAMES_WIDE:
+        res = syms->getZodiacNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::WIDE);
+        break;
+
+    case UDAT_ZODIAC_NAMES_ABBREVIATED:
+        res = syms->getZodiacNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::ABBREVIATED);
+        break;
+
+    case UDAT_ZODIAC_NAMES_NARROW:
+        res = syms->getZodiacNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
+        break;
+
     }
 
     if(index < count) {
         return res[index].extract(result, resultLength, *status);
     }
     return 0;
 }
 
 // TODO: also needs an errorCode.
 U_CAPI int32_t U_EXPORT2
@@ skipping 94 matching lines @@
         break;
 
     case UDAT_STANDALONE_QUARTERS:
         syms->getQuarters(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
         break;
 
     case UDAT_STANDALONE_SHORT_QUARTERS:
         syms->getQuarters(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
         break;
 
+    case UDAT_CYCLIC_YEARS_WIDE:
+        syms->getYearNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::WIDE);
+        break;
+
+    case UDAT_CYCLIC_YEARS_ABBREVIATED:
+        syms->getYearNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::ABBREVIATED);
+        break;
+
+    case UDAT_CYCLIC_YEARS_NARROW:
+        syms->getYearNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
+        break;
+
+    case UDAT_ZODIAC_NAMES_WIDE:
+        syms->getZodiacNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::WIDE);
+        break;
+
+    case UDAT_ZODIAC_NAMES_ABBREVIATED:
+        syms->getZodiacNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::ABBREVIATED);
+        break;
+
+    case UDAT_ZODIAC_NAMES_NARROW:
+        syms->getZodiacNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
+        break;
+
     }
 
     return count;
 }
 
 U_NAMESPACE_BEGIN
 
 /*
  * This DateFormatSymbolsSingleSetter class is a friend of DateFormatSymbols
  * solely for the purpose of avoiding to clone the array of strings
@@ skipping 169 matching lines @@
     }
 
     static void
         setStandaloneShortQuarter(DateFormatSymbols *syms, int32_t index,
         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
     {
         setSymbol(syms->fStandaloneShortQuarters, syms->fStandaloneShortQuartersCount, index, value, valueLength, errorCode);
     }
 
     static void
+        setShortYearNames(DateFormatSymbols *syms, int32_t index,
+        const UChar *value, int32_t valueLength, UErrorCode &errorCode)
+    {
+        setSymbol(syms->fShortYearNames, syms->fShortYearNamesCount, index, value, valueLength, errorCode);
+    }
+
+    static void
+        setShortZodiacNames(DateFormatSymbols *syms, int32_t index,
+        const UChar *value, int32_t valueLength, UErrorCode &errorCode)
+    {
+        setSymbol(syms->fShortZodiacNames, syms->fShortZodiacNamesCount, index, value, valueLength, errorCode);
+    }
+
+    static void
         setAmPm(DateFormatSymbols *syms, int32_t index,
         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
     {
         setSymbol(syms->fAmPms, syms->fAmPmsCount, index, value, valueLength, errorCode);
     }
 
     static void
         setLocalPatternChars(DateFormatSymbols *syms,
         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
     {
@@ skipping 90 matching lines @@
         break;
 
     case UDAT_STANDALONE_QUARTERS:
         DateFormatSymbolsSingleSetter::setStandaloneQuarter(syms, index, value, valueLength, *status);
         break;
 
     case UDAT_STANDALONE_SHORT_QUARTERS:
         DateFormatSymbolsSingleSetter::setStandaloneShortQuarter(syms, index, value, valueLength, *status);
         break;
 
+    case UDAT_CYCLIC_YEARS_ABBREVIATED:
+        DateFormatSymbolsSingleSetter::setShortYearNames(syms, index, value, valueLength, *status);
+        break;
+
+    case UDAT_ZODIAC_NAMES_ABBREVIATED:
+        DateFormatSymbolsSingleSetter::setShortZodiacNames(syms, index, value, valueLength, *status);
+        break;
+
     case UDAT_AM_PMS:
         DateFormatSymbolsSingleSetter::setAmPm(syms, index, value, valueLength, *status);
         break;
 
     case UDAT_LOCALIZED_CHARS:
         DateFormatSymbolsSingleSetter::setLocalPatternChars(syms, value, valueLength, *status);
         break;
 
     default:
         *status = U_UNSUPPORTED_ERROR;
         break;
         
     }
 }
 
 U_CAPI const char* U_EXPORT2
 udat_getLocaleByType(const UDateFormat *fmt,
                      ULocDataLocaleType type,
                      UErrorCode* status)
 {
     if (fmt == NULL) {
         if (U_SUCCESS(*status)) {
             *status = U_ILLEGAL_ARGUMENT_ERROR;
         }
         return NULL;
     }
     return ((Format*)fmt)->getLocaleID(type, *status);
 }
 
-
 U_CAPI void U_EXPORT2
 udat_setContext(UDateFormat* fmt, UDisplayContext value, UErrorCode* status)
 {
-    verifyIsSimpleDateFormat(fmt, status);
     if (U_FAILURE(*status)) {
         return;
     }
-    ((SimpleDateFormat*)fmt)->setContext(value, *status);
+    ((DateFormat*)fmt)->setContext(value, *status);
+    return;
 }
 
 U_CAPI UDisplayContext U_EXPORT2
-udat_getContext(UDateFormat* fmt, UDisplayContextType type, UErrorCode* status)
+udat_getContext(const UDateFormat* fmt, UDisplayContextType type, UErrorCode* status)
 {
-    verifyIsSimpleDateFormat(fmt, status);
     if (U_FAILURE(*status)) {
         return (UDisplayContext)0;
     }
-    return ((SimpleDateFormat*)fmt)->getContext(type, *status);
+    return ((const DateFormat*)fmt)->getContext(type, *status);
 }
 
 
 /**
  * Verify that fmt is a RelativeDateFormat. Invalid error if not.
  * @param fmt the UDateFormat, definitely a DateFormat, maybe something else
  * @param status error code, will be set to failure if there is a familure or the fmt is NULL.
  */
 static void verifyIsRelativeDateFormat(const UDateFormat* fmt, UErrorCode *status) {
    if(U_SUCCESS(*status) &&
@@ skipping 50 matching lines @@
                           UErrorCode  *status)
 {
     verifyIsRelativeDateFormat(format, status);
     if(U_FAILURE(*status)) return;
     const UnicodeString datePat((UBool)(datePatternLength == -1), datePattern, datePatternLength);
     const UnicodeString timePat((UBool)(timePatternLength == -1), timePattern, timePatternLength);
     ((RelativeDateFormat*)format)->applyPatterns(datePat, timePat, *status);
 }
 
 #endif /* #if !UCONFIG_NO_FORMATTING */