Home | History | Annotate | Download | only in i18n 
      1 //  2016 and later: Unicode, Inc. and others.
      2 // License & terms of use: http://www.unicode.org/copyright.html
      3 /*
      4 *******************************************************************************
      5 *   Copyright (C) 1996-2015, International Business Machines
      6 *   Corporation and others.  All Rights Reserved.
      7 *******************************************************************************
      8 */
      9 
     10 #include "unicode/utypes.h"
     11 
     12 #if !UCONFIG_NO_FORMATTING
     13 
     14 #include "unicode/udat.h"
     15 
     16 #include "unicode/uloc.h"
     17 #include "unicode/datefmt.h"
     18 #include "unicode/timezone.h"
     19 #include "unicode/smpdtfmt.h"
     20 #include "unicode/fieldpos.h"
     21 #include "unicode/parsepos.h"
     22 #include "unicode/calendar.h"
     23 #include "unicode/numfmt.h"
     24 #include "unicode/dtfmtsym.h"
     25 #include "unicode/ustring.h"
     26 #include "unicode/udisplaycontext.h"
     27 #include "unicode/ufieldpositer.h"
     28 #include "cpputils.h"
     29 #include "reldtfmt.h"
     30 #include "umutex.h"
     31 
     32 U_NAMESPACE_USE
     33 
     34 /**
     35  * Verify that fmt is a SimpleDateFormat. Invalid error if not.
     36  * @param fmt the UDateFormat, definitely a DateFormat, maybe something else
     37  * @param status error code, will be set to failure if there is a familure or the fmt is NULL.
     38  */
     39 static void verifyIsSimpleDateFormat(const UDateFormat* fmt, UErrorCode *status) {
     40    if(U_SUCCESS(*status) &&
     41        dynamic_cast<const SimpleDateFormat*>(reinterpret_cast<const DateFormat*>(fmt))==NULL) {
     42        *status = U_ILLEGAL_ARGUMENT_ERROR;
     43    }
     44 }
     45 
     46 // This mirrors the correspondence between the
     47 // SimpleDateFormat::fgPatternIndexToDateFormatField and
     48 // SimpleDateFormat::fgPatternIndexToCalendarField arrays.
     49 static UCalendarDateFields gDateFieldMapping[] = {
     50     UCAL_ERA,                  // UDAT_ERA_FIELD = 0
     51     UCAL_YEAR,                 // UDAT_YEAR_FIELD = 1
     52     UCAL_MONTH,                // UDAT_MONTH_FIELD = 2
     53     UCAL_DATE,                 // UDAT_DATE_FIELD = 3
     54     UCAL_HOUR_OF_DAY,          // UDAT_HOUR_OF_DAY1_FIELD = 4
     55     UCAL_HOUR_OF_DAY,          // UDAT_HOUR_OF_DAY0_FIELD = 5
     56     UCAL_MINUTE,               // UDAT_MINUTE_FIELD = 6
     57     UCAL_SECOND,               // UDAT_SECOND_FIELD = 7
     58     UCAL_MILLISECOND,          // UDAT_FRACTIONAL_SECOND_FIELD = 8
     59     UCAL_DAY_OF_WEEK,          // UDAT_DAY_OF_WEEK_FIELD = 9
     60     UCAL_DAY_OF_YEAR,          // UDAT_DAY_OF_YEAR_FIELD = 10
     61     UCAL_DAY_OF_WEEK_IN_MONTH, // UDAT_DAY_OF_WEEK_IN_MONTH_FIELD = 11
     62     UCAL_WEEK_OF_YEAR,         // UDAT_WEEK_OF_YEAR_FIELD = 12
     63     UCAL_WEEK_OF_MONTH,        // UDAT_WEEK_OF_MONTH_FIELD = 13
     64     UCAL_AM_PM,                // UDAT_AM_PM_FIELD = 14
     65     UCAL_HOUR,                 // UDAT_HOUR1_FIELD = 15
     66     UCAL_HOUR,                 // UDAT_HOUR0_FIELD = 16
     67     UCAL_ZONE_OFFSET,          // UDAT_TIMEZONE_FIELD = 17
     68     UCAL_YEAR_WOY,             // UDAT_YEAR_WOY_FIELD = 18
     69     UCAL_DOW_LOCAL,            // UDAT_DOW_LOCAL_FIELD = 19
     70     UCAL_EXTENDED_YEAR,        // UDAT_EXTENDED_YEAR_FIELD = 20
     71     UCAL_JULIAN_DAY,           // UDAT_JULIAN_DAY_FIELD = 21
     72     UCAL_MILLISECONDS_IN_DAY,  // UDAT_MILLISECONDS_IN_DAY_FIELD = 22
     73     UCAL_ZONE_OFFSET,          // UDAT_TIMEZONE_RFC_FIELD = 23 (also UCAL_DST_OFFSET)
     74     UCAL_ZONE_OFFSET,          // UDAT_TIMEZONE_GENERIC_FIELD = 24 (also UCAL_DST_OFFSET)
     75     UCAL_DOW_LOCAL,            // UDAT_STANDALONE_DAY_FIELD = 25
     76     UCAL_MONTH,                // UDAT_STANDALONE_MONTH_FIELD = 26
     77     UCAL_MONTH,                // UDAT_QUARTER_FIELD = 27
     78     UCAL_MONTH,                // UDAT_STANDALONE_QUARTER_FIELD = 28
     79     UCAL_ZONE_OFFSET,          // UDAT_TIMEZONE_SPECIAL_FIELD = 29 (also UCAL_DST_OFFSET)
     80     UCAL_YEAR,                 // UDAT_YEAR_NAME_FIELD = 30
     81     UCAL_ZONE_OFFSET,          // UDAT_TIMEZONE_LOCALIZED_GMT_OFFSET_FIELD = 31 (also UCAL_DST_OFFSET)
     82     UCAL_ZONE_OFFSET,          // UDAT_TIMEZONE_ISO_FIELD = 32 (also UCAL_DST_OFFSET)
     83     UCAL_ZONE_OFFSET,          // UDAT_TIMEZONE_ISO_LOCAL_FIELD = 33 (also UCAL_DST_OFFSET)
     84     UCAL_EXTENDED_YEAR,        // UDAT_RELATED_YEAR_FIELD = 34 (not an exact match)
     85     UCAL_FIELD_COUNT,          // UDAT_FIELD_COUNT = 35
     86     // UCAL_IS_LEAP_MONTH is not the target of a mapping
     87 };
     88 
     89 U_CAPI UCalendarDateFields U_EXPORT2
     90 udat_toCalendarDateField(UDateFormatField field) {
     91   return gDateFieldMapping[field];
     92 }
     93 
     94 /* For now- one opener. */
     95 static UDateFormatOpener gOpener = NULL;
     96 
     97 U_INTERNAL void U_EXPORT2
     98 udat_registerOpener(UDateFormatOpener opener, UErrorCode *status)
     99 {
    100   if(U_FAILURE(*status)) return;
    101   umtx_lock(NULL);
    102   if(gOpener==NULL) {
    103     gOpener = opener;
    104   } else {
    105     *status = U_ILLEGAL_ARGUMENT_ERROR;
    106   }
    107   umtx_unlock(NULL);
    108 }
    109 
    110 U_INTERNAL UDateFormatOpener U_EXPORT2
    111 udat_unregisterOpener(UDateFormatOpener opener, UErrorCode *status)
    112 {
    113   if(U_FAILURE(*status)) return NULL;
    114   UDateFormatOpener oldOpener = NULL;
    115   umtx_lock(NULL);
    116   if(gOpener==NULL || gOpener!=opener) {
    117     *status = U_ILLEGAL_ARGUMENT_ERROR;
    118   } else {
    119     oldOpener=gOpener;
    120     gOpener=NULL;
    121   }
    122   umtx_unlock(NULL);
    123   return oldOpener;
    124 }
    125 
    126 
    127 
    128 U_CAPI UDateFormat* U_EXPORT2
    129 udat_open(UDateFormatStyle  timeStyle,
    130           UDateFormatStyle  dateStyle,
    131           const char        *locale,
    132           const UChar       *tzID,
    133           int32_t           tzIDLength,
    134           const UChar       *pattern,
    135           int32_t           patternLength,
    136           UErrorCode        *status)
    137 {
    138     DateFormat *fmt;
    139     if(U_FAILURE(*status)) {
    140         return 0;
    141     }
    142     if(gOpener!=NULL) { // if it's registered
    143       fmt = (DateFormat*) (*gOpener)(timeStyle,dateStyle,locale,tzID,tzIDLength,pattern,patternLength,status);
    144       if(fmt!=NULL) {
    145         return (UDateFormat*)fmt;
    146       } // else fall through.
    147     }
    148     if(timeStyle != UDAT_PATTERN) {
    149         if(locale == 0) {
    150             fmt = DateFormat::createDateTimeInstance((DateFormat::EStyle)dateStyle,
    151                 (DateFormat::EStyle)timeStyle);
    152         }
    153         else {
    154             fmt = DateFormat::createDateTimeInstance((DateFormat::EStyle)dateStyle,
    155                 (DateFormat::EStyle)timeStyle,
    156                 Locale(locale));
    157         }
    158     }
    159     else {
    160         UnicodeString pat((UBool)(patternLength == -1), pattern, patternLength);
    161 
    162         if(locale == 0) {
    163             fmt = new SimpleDateFormat(pat, *status);
    164         }
    165         else {
    166             fmt = new SimpleDateFormat(pat, Locale(locale), *status);
    167         }
    168     }
    169 
    170     if(fmt == 0) {
    171         *status = U_MEMORY_ALLOCATION_ERROR;
    172         return 0;
    173     }
    174 
    175     if(tzID != 0) {
    176         TimeZone *zone = TimeZone::createTimeZone(UnicodeString((UBool)(tzIDLength == -1), tzID, tzIDLength));
    177         if(zone == 0) {
    178             *status = U_MEMORY_ALLOCATION_ERROR;
    179             delete fmt;
    180             return 0;
    181         }
    182         fmt->adoptTimeZone(zone);
    183     }
    184 
    185     return (UDateFormat*)fmt;
    186 }
    187 
    188 
    189 U_CAPI void U_EXPORT2
    190 udat_close(UDateFormat* format)
    191 {
    192     delete (DateFormat*)format;
    193 }
    194 
    195 U_CAPI UDateFormat* U_EXPORT2
    196 udat_clone(const UDateFormat *fmt,
    197        UErrorCode *status)
    198 {
    199     if(U_FAILURE(*status)) return 0;
    200 
    201     Format *res = ((DateFormat*)fmt)->clone();
    202 
    203     if(res == 0) {
    204         *status = U_MEMORY_ALLOCATION_ERROR;
    205         return 0;
    206     }
    207 
    208     return (UDateFormat*) res;
    209 }
    210 
    211 U_CAPI int32_t U_EXPORT2
    212 udat_format(    const    UDateFormat*    format,
    213         UDate           dateToFormat,
    214         UChar*          result,
    215         int32_t         resultLength,
    216         UFieldPosition* position,
    217         UErrorCode*     status)
    218 {
    219     if(U_FAILURE(*status)) {
    220         return -1;
    221     }
    222     if (result == NULL ? resultLength != 0 : resultLength < 0) {
    223         *status = U_ILLEGAL_ARGUMENT_ERROR;
    224         return -1;
    225     }
    226 
    227     UnicodeString res;
    228     if (result != NULL) {
    229         // NULL destination for pure preflighting: empty dummy string
    230         // otherwise, alias the destination buffer
    231         res.setTo(result, 0, resultLength);
    232     }
    233 
    234     FieldPosition fp;
    235 
    236     if(position != 0)
    237         fp.setField(position->field);
    238 
    239     ((DateFormat*)format)->format(dateToFormat, res, fp);
    240 
    241     if(position != 0) {
    242         position->beginIndex = fp.getBeginIndex();
    243         position->endIndex = fp.getEndIndex();
    244     }
    245 
    246     return res.extract(result, resultLength, *status);
    247 }
    248 
    249 U_CAPI int32_t U_EXPORT2
    250 udat_formatCalendar(const UDateFormat*  format,
    251         UCalendar*      calendar,
    252         UChar*          result,
    253         int32_t         resultLength,
    254         UFieldPosition* position,
    255         UErrorCode*     status)
    256 {
    257     if(U_FAILURE(*status)) {
    258         return -1;
    259     }
    260     if (result == NULL ? resultLength != 0 : resultLength < 0) {
    261         *status = U_ILLEGAL_ARGUMENT_ERROR;
    262         return -1;
    263     }
    264 
    265     UnicodeString res;
    266     if (result != NULL) {
    267         // NULL destination for pure preflighting: empty dummy string
    268         // otherwise, alias the destination buffer
    269         res.setTo(result, 0, resultLength);
    270     }
    271 
    272     FieldPosition fp;
    273 
    274     if(position != 0)
    275         fp.setField(position->field);
    276 
    277     ((DateFormat*)format)->format(*(Calendar*)calendar, res, fp);
    278 
    279     if(position != 0) {
    280         position->beginIndex = fp.getBeginIndex();
    281         position->endIndex = fp.getEndIndex();
    282     }
    283 
    284     return res.extract(result, resultLength, *status);
    285 }
    286 
    287 U_CAPI int32_t U_EXPORT2
    288 udat_formatForFields(    const    UDateFormat*    format,
    289         UDate           dateToFormat,
    290         UChar*          result,
    291         int32_t         resultLength,
    292         UFieldPositionIterator* fpositer,
    293         UErrorCode*     status)
    294 {
    295     if(U_FAILURE(*status)) {
    296         return -1;
    297     }
    298     if (result == NULL ? resultLength != 0 : resultLength < 0) {
    299         *status = U_ILLEGAL_ARGUMENT_ERROR;
    300         return -1;
    301     }
    302 
    303     UnicodeString res;
    304     if (result != NULL) {
    305         // NULL destination for pure preflighting: empty dummy string
    306         // otherwise, alias the destination buffer
    307         res.setTo(result, 0, resultLength);
    308     }
    309 
    310     ((DateFormat*)format)->format(dateToFormat, res, (FieldPositionIterator*)fpositer, *status);
    311 
    312     return res.extract(result, resultLength, *status);
    313 }
    314 
    315 U_CAPI int32_t U_EXPORT2
    316 udat_formatCalendarForFields(const UDateFormat*  format,
    317         UCalendar*      calendar,
    318         UChar*          result,
    319         int32_t         resultLength,
    320         UFieldPositionIterator* fpositer,
    321         UErrorCode*     status)
    322 {
    323     if(U_FAILURE(*status)) {
    324         return -1;
    325     }
    326     if (result == NULL ? resultLength != 0 : resultLength < 0) {
    327         *status = U_ILLEGAL_ARGUMENT_ERROR;
    328         return -1;
    329     }
    330 
    331     UnicodeString res;
    332     if (result != NULL) {
    333         // NULL destination for pure preflighting: empty dummy string
    334         // otherwise, alias the destination buffer
    335         res.setTo(result, 0, resultLength);
    336     }
    337 
    338     ((DateFormat*)format)->format(*(Calendar*)calendar, res, (FieldPositionIterator*)fpositer, *status);
    339 
    340     return res.extract(result, resultLength, *status);
    341 }
    342 
    343 U_CAPI UDate U_EXPORT2
    344 udat_parse(    const    UDateFormat*        format,
    345         const    UChar*          text,
    346         int32_t         textLength,
    347         int32_t         *parsePos,
    348         UErrorCode      *status)
    349 {
    350     if(U_FAILURE(*status)) return (UDate)0;
    351 
    352     const UnicodeString src((UBool)(textLength == -1), text, textLength);
    353     ParsePosition pp;
    354     int32_t stackParsePos = 0;
    355     UDate res;
    356 
    357     if(parsePos == NULL) {
    358         parsePos = &stackParsePos;
    359     }
    360 
    361     pp.setIndex(*parsePos);
    362 
    363     res = ((DateFormat*)format)->parse(src, pp);
    364 
    365     if(pp.getErrorIndex() == -1)
    366         *parsePos = pp.getIndex();
    367     else {
    368         *parsePos = pp.getErrorIndex();
    369         *status = U_PARSE_ERROR;
    370     }
    371 
    372     return res;
    373 }
    374 
    375 U_CAPI void U_EXPORT2
    376 udat_parseCalendar(const    UDateFormat*    format,
    377                             UCalendar*      calendar,
    378                    const    UChar*          text,
    379                             int32_t         textLength,
    380                             int32_t         *parsePos,
    381                             UErrorCode      *status)
    382 {
    383     if(U_FAILURE(*status)) return;
    384 
    385     const UnicodeString src((UBool)(textLength == -1), text, textLength);
    386     ParsePosition pp;
    387     int32_t stackParsePos = 0;
    388 
    389     if(parsePos == NULL) {
    390         parsePos = &stackParsePos;
    391     }
    392 
    393     pp.setIndex(*parsePos);
    394 
    395     ((DateFormat*)format)->parse(src, *(Calendar*)calendar, pp);
    396 
    397     if(pp.getErrorIndex() == -1)
    398         *parsePos = pp.getIndex();
    399     else {
    400         *parsePos = pp.getErrorIndex();
    401         *status = U_PARSE_ERROR;
    402     }
    403 }
    404 
    405 U_CAPI UBool U_EXPORT2
    406 udat_isLenient(const UDateFormat* fmt)
    407 {
    408     return ((DateFormat*)fmt)->isLenient();
    409 }
    410 
    411 U_CAPI void U_EXPORT2
    412 udat_setLenient(    UDateFormat*    fmt,
    413             UBool          isLenient)
    414 {
    415     ((DateFormat*)fmt)->setLenient(isLenient);
    416 }
    417 
    418 U_DRAFT UBool U_EXPORT2
    419 udat_getBooleanAttribute(const UDateFormat* fmt,
    420                          UDateFormatBooleanAttribute attr,
    421                          UErrorCode* status)
    422 {
    423     if(U_FAILURE(*status)) return FALSE;
    424     return ((DateFormat*)fmt)->getBooleanAttribute(attr, *status);
    425     //return FALSE;
    426 }
    427 
    428 U_DRAFT void U_EXPORT2
    429 udat_setBooleanAttribute(UDateFormat *fmt,
    430                          UDateFormatBooleanAttribute attr,
    431                          UBool newValue,
    432                          UErrorCode* status)
    433 {
    434     if(U_FAILURE(*status)) return;
    435     ((DateFormat*)fmt)->setBooleanAttribute(attr, newValue, *status);
    436 }
    437 
    438 U_CAPI const UCalendar* U_EXPORT2
    439 udat_getCalendar(const UDateFormat* fmt)
    440 {
    441     return (const UCalendar*) ((DateFormat*)fmt)->getCalendar();
    442 }
    443 
    444 U_CAPI void U_EXPORT2
    445 udat_setCalendar(UDateFormat*    fmt,
    446                  const   UCalendar*      calendarToSet)
    447 {
    448     ((DateFormat*)fmt)->setCalendar(*((Calendar*)calendarToSet));
    449 }
    450 
    451 U_DRAFT const UNumberFormat* U_EXPORT2
    452 udat_getNumberFormatForField(const UDateFormat* fmt, UChar field)
    453 {
    454     UErrorCode status = U_ZERO_ERROR;
    455     verifyIsSimpleDateFormat(fmt, &status);
    456     if (U_FAILURE(status)) return (const UNumberFormat*) ((DateFormat*)fmt)->getNumberFormat();
    457     return (const UNumberFormat*) ((SimpleDateFormat*)fmt)->getNumberFormatForField(field);
    458 }
    459 
    460 U_CAPI const UNumberFormat* U_EXPORT2
    461 udat_getNumberFormat(const UDateFormat* fmt)
    462 {
    463     return (const UNumberFormat*) ((DateFormat*)fmt)->getNumberFormat();
    464 }
    465 
    466 U_DRAFT void U_EXPORT2
    467 udat_adoptNumberFormatForFields(           UDateFormat*    fmt,
    468                                     const  UChar*          fields,
    469                                            UNumberFormat*  numberFormatToSet,
    470                                            UErrorCode*     status)
    471 {
    472     verifyIsSimpleDateFormat(fmt, status);
    473     if (U_FAILURE(*status)) return;
    474 
    475     if (fields!=NULL) {
    476         UnicodeString overrideFields(fields);
    477         ((SimpleDateFormat*)fmt)->adoptNumberFormat(overrideFields, (NumberFormat*)numberFormatToSet, *status);
    478     }
    479 }
    480 
    481 U_CAPI void U_EXPORT2
    482 udat_setNumberFormat(UDateFormat*    fmt,
    483                      const   UNumberFormat*  numberFormatToSet)
    484 {
    485     ((DateFormat*)fmt)->setNumberFormat(*((NumberFormat*)numberFormatToSet));
    486 }
    487 
    488 U_DRAFT void U_EXPORT2
    489 udat_adoptNumberFormat(      UDateFormat*    fmt,
    490                              UNumberFormat*  numberFormatToAdopt)
    491 {
    492     ((DateFormat*)fmt)->adoptNumberFormat((NumberFormat*)numberFormatToAdopt);
    493 }
    494 
    495 U_CAPI const char* U_EXPORT2
    496 udat_getAvailable(int32_t index)
    497 {
    498     return uloc_getAvailable(index);
    499 }
    500 
    501 U_CAPI int32_t U_EXPORT2
    502 udat_countAvailable()
    503 {
    504     return uloc_countAvailable();
    505 }
    506 
    507 U_CAPI UDate U_EXPORT2
    508 udat_get2DigitYearStart(    const   UDateFormat     *fmt,
    509                         UErrorCode      *status)
    510 {
    511     verifyIsSimpleDateFormat(fmt, status);
    512     if(U_FAILURE(*status)) return (UDate)0;
    513     return ((SimpleDateFormat*)fmt)->get2DigitYearStart(*status);
    514 }
    515 
    516 U_CAPI void U_EXPORT2
    517 udat_set2DigitYearStart(    UDateFormat     *fmt,
    518                         UDate           d,
    519                         UErrorCode      *status)
    520 {
    521     verifyIsSimpleDateFormat(fmt, status);
    522     if(U_FAILURE(*status)) return;
    523     ((SimpleDateFormat*)fmt)->set2DigitYearStart(d, *status);
    524 }
    525 
    526 U_CAPI int32_t U_EXPORT2
    527 udat_toPattern(    const   UDateFormat     *fmt,
    528         UBool          localized,
    529         UChar           *result,
    530         int32_t         resultLength,
    531         UErrorCode      *status)
    532 {
    533     if(U_FAILURE(*status)) {
    534         return -1;
    535     }
    536     if (result == NULL ? resultLength != 0 : resultLength < 0) {
    537         *status = U_ILLEGAL_ARGUMENT_ERROR;
    538         return -1;
    539     }
    540 
    541     UnicodeString res;
    542     if (result != NULL) {
    543         // NULL destination for pure preflighting: empty dummy string
    544         // otherwise, alias the destination buffer
    545         res.setTo(result, 0, resultLength);
    546     }
    547 
    548     const DateFormat *df=reinterpret_cast<const DateFormat *>(fmt);
    549     const SimpleDateFormat *sdtfmt=dynamic_cast<const SimpleDateFormat *>(df);
    550     const RelativeDateFormat *reldtfmt;
    551     if (sdtfmt!=NULL) {
    552         if(localized)
    553             sdtfmt->toLocalizedPattern(res, *status);
    554         else
    555             sdtfmt->toPattern(res);
    556     } else if (!localized && (reldtfmt=dynamic_cast<const RelativeDateFormat *>(df))!=NULL) {
    557         reldtfmt->toPattern(res, *status);
    558     } else {
    559         *status = U_ILLEGAL_ARGUMENT_ERROR;
    560         return -1;
    561     }
    562 
    563     return res.extract(result, resultLength, *status);
    564 }
    565 
    566 // TODO: should this take an UErrorCode?
    567 // A: Yes. Of course.
    568 U_CAPI void U_EXPORT2
    569 udat_applyPattern(  UDateFormat     *format,
    570                     UBool          localized,
    571                     const   UChar           *pattern,
    572                     int32_t         patternLength)
    573 {
    574     const UnicodeString pat((UBool)(patternLength == -1), pattern, patternLength);
    575     UErrorCode status = U_ZERO_ERROR;
    576 
    577     verifyIsSimpleDateFormat(format, &status);
    578     if(U_FAILURE(status)) {
    579         return;
    580     }
    581 
    582     if(localized)
    583         ((SimpleDateFormat*)format)->applyLocalizedPattern(pat, status);
    584     else
    585         ((SimpleDateFormat*)format)->applyPattern(pat);
    586 }
    587 
    588 U_CAPI int32_t U_EXPORT2
    589 udat_getSymbols(const   UDateFormat     *fmt,
    590                 UDateFormatSymbolType   type,
    591                 int32_t                 index,
    592                 UChar                   *result,
    593                 int32_t                 resultLength,
    594                 UErrorCode              *status)
    595 {
    596     const DateFormatSymbols *syms;
    597     const SimpleDateFormat* sdtfmt;
    598     const RelativeDateFormat* rdtfmt;
    599     if ((sdtfmt = dynamic_cast<const SimpleDateFormat*>(reinterpret_cast<const DateFormat*>(fmt))) != NULL) {
    600         syms = sdtfmt->getDateFormatSymbols();
    601     } else if ((rdtfmt = dynamic_cast<const RelativeDateFormat*>(reinterpret_cast<const DateFormat*>(fmt))) != NULL) {
    602         syms = rdtfmt->getDateFormatSymbols();
    603     } else {
    604         return -1;
    605     }
    606     int32_t count;
    607     const UnicodeString *res = NULL;
    608 
    609     switch(type) {
    610     case UDAT_ERAS:
    611         res = syms->getEras(count);
    612         break;
    613 
    614     case UDAT_ERA_NAMES:
    615         res = syms->getEraNames(count);
    616         break;
    617 
    618     case UDAT_MONTHS:
    619         res = syms->getMonths(count);
    620         break;
    621 
    622     case UDAT_SHORT_MONTHS:
    623         res = syms->getShortMonths(count);
    624         break;
    625 
    626     case UDAT_WEEKDAYS:
    627         res = syms->getWeekdays(count);
    628         break;
    629 
    630     case UDAT_SHORT_WEEKDAYS:
    631         res = syms->getShortWeekdays(count);
    632         break;
    633 
    634     case UDAT_AM_PMS:
    635         res = syms->getAmPmStrings(count);
    636         break;
    637 
    638     case UDAT_LOCALIZED_CHARS:
    639         {
    640             UnicodeString res1;
    641             if(!(result==NULL && resultLength==0)) {
    642                 // NULL destination for pure preflighting: empty dummy string
    643                 // otherwise, alias the destination buffer
    644                 res1.setTo(result, 0, resultLength);
    645             }
    646             syms->getLocalPatternChars(res1);
    647             return res1.extract(result, resultLength, *status);
    648         }
    649 
    650     case UDAT_NARROW_MONTHS:
    651         res = syms->getMonths(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
    652         break;
    653 
    654     case UDAT_SHORTER_WEEKDAYS:
    655         res = syms->getWeekdays(count, DateFormatSymbols::FORMAT, DateFormatSymbols::SHORT);
    656         break;
    657 
    658     case UDAT_NARROW_WEEKDAYS:
    659         res = syms->getWeekdays(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
    660         break;
    661 
    662     case UDAT_STANDALONE_MONTHS:
    663         res = syms->getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
    664         break;
    665 
    666     case UDAT_STANDALONE_SHORT_MONTHS:
    667         res = syms->getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
    668         break;
    669 
    670     case UDAT_STANDALONE_NARROW_MONTHS:
    671         res = syms->getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::NARROW);
    672         break;
    673 
    674     case UDAT_STANDALONE_WEEKDAYS:
    675         res = syms->getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
    676         break;
    677 
    678     case UDAT_STANDALONE_SHORT_WEEKDAYS:
    679         res = syms->getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
    680         break;
    681 
    682     case UDAT_STANDALONE_SHORTER_WEEKDAYS:
    683         res = syms->getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::SHORT);
    684         break;
    685 
    686     case UDAT_STANDALONE_NARROW_WEEKDAYS:
    687         res = syms->getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::NARROW);
    688         break;
    689 
    690     case UDAT_QUARTERS:
    691         res = syms->getQuarters(count, DateFormatSymbols::FORMAT, DateFormatSymbols::WIDE);
    692         break;
    693 
    694     case UDAT_SHORT_QUARTERS:
    695         res = syms->getQuarters(count, DateFormatSymbols::FORMAT, DateFormatSymbols::ABBREVIATED);
    696         break;
    697 
    698     case UDAT_STANDALONE_QUARTERS:
    699         res = syms->getQuarters(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
    700         break;
    701 
    702     case UDAT_STANDALONE_SHORT_QUARTERS:
    703         res = syms->getQuarters(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
    704         break;
    705 
    706     case UDAT_CYCLIC_YEARS_WIDE:
    707         res = syms->getYearNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::WIDE);
    708         break;
    709 
    710     case UDAT_CYCLIC_YEARS_ABBREVIATED:
    711         res = syms->getYearNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::ABBREVIATED);
    712         break;
    713 
    714     case UDAT_CYCLIC_YEARS_NARROW:
    715         res = syms->getYearNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
    716         break;
    717 
    718     case UDAT_ZODIAC_NAMES_WIDE:
    719         res = syms->getZodiacNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::WIDE);
    720         break;
    721 
    722     case UDAT_ZODIAC_NAMES_ABBREVIATED:
    723         res = syms->getZodiacNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::ABBREVIATED);
    724         break;
    725 
    726     case UDAT_ZODIAC_NAMES_NARROW:
    727         res = syms->getZodiacNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
    728         break;
    729 
    730     }
    731 
    732     if(index < count) {
    733         return res[index].extract(result, resultLength, *status);
    734     }
    735     return 0;
    736 }
    737 
    738 // TODO: also needs an errorCode.
    739 U_CAPI int32_t U_EXPORT2
    740 udat_countSymbols(    const    UDateFormat                *fmt,
    741             UDateFormatSymbolType    type)
    742 {
    743     const DateFormatSymbols *syms;
    744     const SimpleDateFormat* sdtfmt;
    745     const RelativeDateFormat* rdtfmt;
    746     if ((sdtfmt = dynamic_cast<const SimpleDateFormat*>(reinterpret_cast<const DateFormat*>(fmt))) != NULL) {
    747         syms = sdtfmt->getDateFormatSymbols();
    748     } else if ((rdtfmt = dynamic_cast<const RelativeDateFormat*>(reinterpret_cast<const DateFormat*>(fmt))) != NULL) {
    749         syms = rdtfmt->getDateFormatSymbols();
    750     } else {
    751         return 0;
    752     }
    753     int32_t count = 0;
    754 
    755     switch(type) {
    756     case UDAT_ERAS:
    757         syms->getEras(count);
    758         break;
    759 
    760     case UDAT_MONTHS:
    761         syms->getMonths(count);
    762         break;
    763 
    764     case UDAT_SHORT_MONTHS:
    765         syms->getShortMonths(count);
    766         break;
    767 
    768     case UDAT_WEEKDAYS:
    769         syms->getWeekdays(count);
    770         break;
    771 
    772     case UDAT_SHORT_WEEKDAYS:
    773         syms->getShortWeekdays(count);
    774         break;
    775 
    776     case UDAT_AM_PMS:
    777         syms->getAmPmStrings(count);
    778         break;
    779 
    780     case UDAT_LOCALIZED_CHARS:
    781         count = 1;
    782         break;
    783 
    784     case UDAT_ERA_NAMES:
    785         syms->getEraNames(count);
    786         break;
    787 
    788     case UDAT_NARROW_MONTHS:
    789         syms->getMonths(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
    790         break;
    791 
    792     case UDAT_SHORTER_WEEKDAYS:
    793         syms->getWeekdays(count, DateFormatSymbols::FORMAT, DateFormatSymbols::SHORT);
    794         break;
    795 
    796     case UDAT_NARROW_WEEKDAYS:
    797         syms->getWeekdays(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
    798         break;
    799 
    800     case UDAT_STANDALONE_MONTHS:
    801         syms->getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
    802         break;
    803 
    804     case UDAT_STANDALONE_SHORT_MONTHS:
    805         syms->getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
    806         break;
    807 
    808     case UDAT_STANDALONE_NARROW_MONTHS:
    809         syms->getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::NARROW);
    810         break;
    811 
    812     case UDAT_STANDALONE_WEEKDAYS:
    813         syms->getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
    814         break;
    815 
    816     case UDAT_STANDALONE_SHORT_WEEKDAYS:
    817         syms->getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
    818         break;
    819 
    820     case UDAT_STANDALONE_SHORTER_WEEKDAYS:
    821         syms->getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::SHORT);
    822         break;
    823 
    824     case UDAT_STANDALONE_NARROW_WEEKDAYS:
    825         syms->getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::NARROW);
    826         break;
    827 
    828     case UDAT_QUARTERS:
    829         syms->getQuarters(count, DateFormatSymbols::FORMAT, DateFormatSymbols::WIDE);
    830         break;
    831 
    832     case UDAT_SHORT_QUARTERS:
    833         syms->getQuarters(count, DateFormatSymbols::FORMAT, DateFormatSymbols::ABBREVIATED);
    834         break;
    835 
    836     case UDAT_STANDALONE_QUARTERS:
    837         syms->getQuarters(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
    838         break;
    839 
    840     case UDAT_STANDALONE_SHORT_QUARTERS:
    841         syms->getQuarters(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
    842         break;
    843 
    844     case UDAT_CYCLIC_YEARS_WIDE:
    845         syms->getYearNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::WIDE);
    846         break;
    847 
    848     case UDAT_CYCLIC_YEARS_ABBREVIATED:
    849         syms->getYearNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::ABBREVIATED);
    850         break;
    851 
    852     case UDAT_CYCLIC_YEARS_NARROW:
    853         syms->getYearNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
    854         break;
    855 
    856     case UDAT_ZODIAC_NAMES_WIDE:
    857         syms->getZodiacNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::WIDE);
    858         break;
    859 
    860     case UDAT_ZODIAC_NAMES_ABBREVIATED:
    861         syms->getZodiacNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::ABBREVIATED);
    862         break;
    863 
    864     case UDAT_ZODIAC_NAMES_NARROW:
    865         syms->getZodiacNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
    866         break;
    867 
    868     }
    869 
    870     return count;
    871 }
    872 
    873 U_NAMESPACE_BEGIN
    874 
    875 /*
    876  * This DateFormatSymbolsSingleSetter class is a friend of DateFormatSymbols
    877  * solely for the purpose of avoiding to clone the array of strings
    878  * just to modify one of them and then setting all of them back.
    879  * For example, the old code looked like this:
    880  *  case UDAT_MONTHS:
    881  *    res = syms->getMonths(count);
    882  *    array = new UnicodeString[count];
    883  *    if(array == 0) {
    884  *      *status = U_MEMORY_ALLOCATION_ERROR;
    885  *      return;
    886  *    }
    887  *    uprv_arrayCopy(res, array, count);
    888  *    if(index < count)
    889  *      array[index] = val;
    890  *    syms->setMonths(array, count);
    891  *    break;
    892  *
    893  * Even worse, the old code actually cloned the entire DateFormatSymbols object,
    894  * cloned one value array, changed one value, and then made the SimpleDateFormat
    895  * replace its DateFormatSymbols object with the new one.
    896  *
    897  * markus 2002-oct-14
    898  */
    899 class DateFormatSymbolsSingleSetter /* not : public UObject because all methods are static */ {
    900 public:
    901     static void
    902         setSymbol(UnicodeString *array, int32_t count, int32_t index,
    903         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
    904     {
    905         if(array!=NULL) {
    906             if(index>=count) {
    907                 errorCode=U_INDEX_OUTOFBOUNDS_ERROR;
    908             } else if(value==NULL) {
    909                 errorCode=U_ILLEGAL_ARGUMENT_ERROR;
    910             } else {
    911                 array[index].setTo(value, valueLength);
    912             }
    913         }
    914     }
    915 
    916     static void
    917         setEra(DateFormatSymbols *syms, int32_t index,
    918         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
    919     {
    920         setSymbol(syms->fEras, syms->fErasCount, index, value, valueLength, errorCode);
    921     }
    922 
    923     static void
    924         setEraName(DateFormatSymbols *syms, int32_t index,
    925         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
    926     {
    927         setSymbol(syms->fEraNames, syms->fEraNamesCount, index, value, valueLength, errorCode);
    928     }
    929 
    930     static void
    931         setMonth(DateFormatSymbols *syms, int32_t index,
    932         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
    933     {
    934         setSymbol(syms->fMonths, syms->fMonthsCount, index, value, valueLength, errorCode);
    935     }
    936 
    937     static void
    938         setShortMonth(DateFormatSymbols *syms, int32_t index,
    939         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
    940     {
    941         setSymbol(syms->fShortMonths, syms->fShortMonthsCount, index, value, valueLength, errorCode);
    942     }
    943 
    944     static void
    945         setNarrowMonth(DateFormatSymbols *syms, int32_t index,
    946         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
    947     {
    948         setSymbol(syms->fNarrowMonths, syms->fNarrowMonthsCount, index, value, valueLength, errorCode);
    949     }
    950 
    951     static void
    952         setStandaloneMonth(DateFormatSymbols *syms, int32_t index,
    953         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
    954     {
    955         setSymbol(syms->fStandaloneMonths, syms->fStandaloneMonthsCount, index, value, valueLength, errorCode);
    956     }
    957 
    958     static void
    959         setStandaloneShortMonth(DateFormatSymbols *syms, int32_t index,
    960         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
    961     {
    962         setSymbol(syms->fStandaloneShortMonths, syms->fStandaloneShortMonthsCount, index, value, valueLength, errorCode);
    963     }
    964 
    965     static void
    966         setStandaloneNarrowMonth(DateFormatSymbols *syms, int32_t index,
    967         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
    968     {
    969         setSymbol(syms->fStandaloneNarrowMonths, syms->fStandaloneNarrowMonthsCount, index, value, valueLength, errorCode);
    970     }
    971 
    972     static void
    973         setWeekday(DateFormatSymbols *syms, int32_t index,
    974         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
    975     {
    976         setSymbol(syms->fWeekdays, syms->fWeekdaysCount, index, value, valueLength, errorCode);
    977     }
    978 
    979     static void
    980         setShortWeekday(DateFormatSymbols *syms, int32_t index,
    981         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
    982     {
    983         setSymbol(syms->fShortWeekdays, syms->fShortWeekdaysCount, index, value, valueLength, errorCode);
    984     }
    985 
    986     static void
    987         setShorterWeekday(DateFormatSymbols *syms, int32_t index,
    988         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
    989     {
    990         setSymbol(syms->fShorterWeekdays, syms->fShorterWeekdaysCount, index, value, valueLength, errorCode);
    991     }
    992 
    993     static void
    994         setNarrowWeekday(DateFormatSymbols *syms, int32_t index,
    995         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
    996     {
    997         setSymbol(syms->fNarrowWeekdays, syms->fNarrowWeekdaysCount, index, value, valueLength, errorCode);
    998     }
    999 
   1000     static void
   1001         setStandaloneWeekday(DateFormatSymbols *syms, int32_t index,
   1002         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
   1003     {
   1004         setSymbol(syms->fStandaloneWeekdays, syms->fStandaloneWeekdaysCount, index, value, valueLength, errorCode);
   1005     }
   1006 
   1007     static void
   1008         setStandaloneShortWeekday(DateFormatSymbols *syms, int32_t index,
   1009         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
   1010     {
   1011         setSymbol(syms->fStandaloneShortWeekdays, syms->fStandaloneShortWeekdaysCount, index, value, valueLength, errorCode);
   1012     }
   1013 
   1014     static void
   1015         setStandaloneShorterWeekday(DateFormatSymbols *syms, int32_t index,
   1016         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
   1017     {
   1018         setSymbol(syms->fStandaloneShorterWeekdays, syms->fStandaloneShorterWeekdaysCount, index, value, valueLength, errorCode);
   1019     }
   1020 
   1021     static void
   1022         setStandaloneNarrowWeekday(DateFormatSymbols *syms, int32_t index,
   1023         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
   1024     {
   1025         setSymbol(syms->fStandaloneNarrowWeekdays, syms->fStandaloneNarrowWeekdaysCount, index, value, valueLength, errorCode);
   1026     }
   1027 
   1028     static void
   1029         setQuarter(DateFormatSymbols *syms, int32_t index,
   1030         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
   1031     {
   1032         setSymbol(syms->fQuarters, syms->fQuartersCount, index, value, valueLength, errorCode);
   1033     }
   1034 
   1035     static void
   1036         setShortQuarter(DateFormatSymbols *syms, int32_t index,
   1037         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
   1038     {
   1039         setSymbol(syms->fShortQuarters, syms->fShortQuartersCount, index, value, valueLength, errorCode);
   1040     }
   1041 
   1042     static void
   1043         setStandaloneQuarter(DateFormatSymbols *syms, int32_t index,
   1044         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
   1045     {
   1046         setSymbol(syms->fStandaloneQuarters, syms->fStandaloneQuartersCount, index, value, valueLength, errorCode);
   1047     }
   1048 
   1049     static void
   1050         setStandaloneShortQuarter(DateFormatSymbols *syms, int32_t index,
   1051         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
   1052     {
   1053         setSymbol(syms->fStandaloneShortQuarters, syms->fStandaloneShortQuartersCount, index, value, valueLength, errorCode);
   1054     }
   1055 
   1056     static void
   1057         setShortYearNames(DateFormatSymbols *syms, int32_t index,
   1058         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
   1059     {
   1060         setSymbol(syms->fShortYearNames, syms->fShortYearNamesCount, index, value, valueLength, errorCode);
   1061     }
   1062 
   1063     static void
   1064         setShortZodiacNames(DateFormatSymbols *syms, int32_t index,
   1065         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
   1066     {
   1067         setSymbol(syms->fShortZodiacNames, syms->fShortZodiacNamesCount, index, value, valueLength, errorCode);
   1068     }
   1069 
   1070     static void
   1071         setAmPm(DateFormatSymbols *syms, int32_t index,
   1072         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
   1073     {
   1074         setSymbol(syms->fAmPms, syms->fAmPmsCount, index, value, valueLength, errorCode);
   1075     }
   1076 
   1077     static void
   1078         setLocalPatternChars(DateFormatSymbols *syms,
   1079         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
   1080     {
   1081         setSymbol(&syms->fLocalPatternChars, 1, 0, value, valueLength, errorCode);
   1082     }
   1083 };
   1084 
   1085 U_NAMESPACE_END
   1086 
   1087 U_CAPI void U_EXPORT2
   1088 udat_setSymbols(    UDateFormat             *format,
   1089             UDateFormatSymbolType   type,
   1090             int32_t                 index,
   1091             UChar                   *value,
   1092             int32_t                 valueLength,
   1093             UErrorCode              *status)
   1094 {
   1095     verifyIsSimpleDateFormat(format, status);
   1096     if(U_FAILURE(*status)) return;
   1097 
   1098     DateFormatSymbols *syms = (DateFormatSymbols *)((SimpleDateFormat *)format)->getDateFormatSymbols();
   1099 
   1100     switch(type) {
   1101     case UDAT_ERAS:
   1102         DateFormatSymbolsSingleSetter::setEra(syms, index, value, valueLength, *status);
   1103         break;
   1104 
   1105     case UDAT_ERA_NAMES:
   1106         DateFormatSymbolsSingleSetter::setEraName(syms, index, value, valueLength, *status);
   1107         break;
   1108 
   1109     case UDAT_MONTHS:
   1110         DateFormatSymbolsSingleSetter::setMonth(syms, index, value, valueLength, *status);
   1111         break;
   1112 
   1113     case UDAT_SHORT_MONTHS:
   1114         DateFormatSymbolsSingleSetter::setShortMonth(syms, index, value, valueLength, *status);
   1115         break;
   1116 
   1117     case UDAT_NARROW_MONTHS:
   1118         DateFormatSymbolsSingleSetter::setNarrowMonth(syms, index, value, valueLength, *status);
   1119         break;
   1120 
   1121     case UDAT_STANDALONE_MONTHS:
   1122         DateFormatSymbolsSingleSetter::setStandaloneMonth(syms, index, value, valueLength, *status);
   1123         break;
   1124 
   1125     case UDAT_STANDALONE_SHORT_MONTHS:
   1126         DateFormatSymbolsSingleSetter::setStandaloneShortMonth(syms, index, value, valueLength, *status);
   1127         break;
   1128 
   1129     case UDAT_STANDALONE_NARROW_MONTHS:
   1130         DateFormatSymbolsSingleSetter::setStandaloneNarrowMonth(syms, index, value, valueLength, *status);
   1131         break;
   1132 
   1133     case UDAT_WEEKDAYS:
   1134         DateFormatSymbolsSingleSetter::setWeekday(syms, index, value, valueLength, *status);
   1135         break;
   1136 
   1137     case UDAT_SHORT_WEEKDAYS:
   1138         DateFormatSymbolsSingleSetter::setShortWeekday(syms, index, value, valueLength, *status);
   1139         break;
   1140 
   1141     case UDAT_SHORTER_WEEKDAYS:
   1142         DateFormatSymbolsSingleSetter::setShorterWeekday(syms, index, value, valueLength, *status);
   1143         break;
   1144 
   1145     case UDAT_NARROW_WEEKDAYS:
   1146         DateFormatSymbolsSingleSetter::setNarrowWeekday(syms, index, value, valueLength, *status);
   1147         break;
   1148 
   1149     case UDAT_STANDALONE_WEEKDAYS:
   1150         DateFormatSymbolsSingleSetter::setStandaloneWeekday(syms, index, value, valueLength, *status);
   1151         break;
   1152 
   1153     case UDAT_STANDALONE_SHORT_WEEKDAYS:
   1154         DateFormatSymbolsSingleSetter::setStandaloneShortWeekday(syms, index, value, valueLength, *status);
   1155         break;
   1156 
   1157     case UDAT_STANDALONE_SHORTER_WEEKDAYS:
   1158         DateFormatSymbolsSingleSetter::setStandaloneShorterWeekday(syms, index, value, valueLength, *status);
   1159         break;
   1160 
   1161     case UDAT_STANDALONE_NARROW_WEEKDAYS:
   1162         DateFormatSymbolsSingleSetter::setStandaloneNarrowWeekday(syms, index, value, valueLength, *status);
   1163         break;
   1164 
   1165     case UDAT_QUARTERS:
   1166         DateFormatSymbolsSingleSetter::setQuarter(syms, index, value, valueLength, *status);
   1167         break;
   1168 
   1169     case UDAT_SHORT_QUARTERS:
   1170         DateFormatSymbolsSingleSetter::setShortQuarter(syms, index, value, valueLength, *status);
   1171         break;
   1172 
   1173     case UDAT_STANDALONE_QUARTERS:
   1174         DateFormatSymbolsSingleSetter::setStandaloneQuarter(syms, index, value, valueLength, *status);
   1175         break;
   1176 
   1177     case UDAT_STANDALONE_SHORT_QUARTERS:
   1178         DateFormatSymbolsSingleSetter::setStandaloneShortQuarter(syms, index, value, valueLength, *status);
   1179         break;
   1180 
   1181     case UDAT_CYCLIC_YEARS_ABBREVIATED:
   1182         DateFormatSymbolsSingleSetter::setShortYearNames(syms, index, value, valueLength, *status);
   1183         break;
   1184 
   1185     case UDAT_ZODIAC_NAMES_ABBREVIATED:
   1186         DateFormatSymbolsSingleSetter::setShortZodiacNames(syms, index, value, valueLength, *status);
   1187         break;
   1188 
   1189     case UDAT_AM_PMS:
   1190         DateFormatSymbolsSingleSetter::setAmPm(syms, index, value, valueLength, *status);
   1191         break;
   1192 
   1193     case UDAT_LOCALIZED_CHARS:
   1194         DateFormatSymbolsSingleSetter::setLocalPatternChars(syms, value, valueLength, *status);
   1195         break;
   1196 
   1197     default:
   1198         *status = U_UNSUPPORTED_ERROR;
   1199         break;
   1200 
   1201     }
   1202 }
   1203 
   1204 U_CAPI const char* U_EXPORT2
   1205 udat_getLocaleByType(const UDateFormat *fmt,
   1206                      ULocDataLocaleType type,
   1207                      UErrorCode* status)
   1208 {
   1209     if (fmt == NULL) {
   1210         if (U_SUCCESS(*status)) {
   1211             *status = U_ILLEGAL_ARGUMENT_ERROR;
   1212         }
   1213         return NULL;
   1214     }
   1215     return ((Format*)fmt)->getLocaleID(type, *status);
   1216 }
   1217 
   1218 U_CAPI void U_EXPORT2
   1219 udat_setContext(UDateFormat* fmt, UDisplayContext value, UErrorCode* status)
   1220 {
   1221     if (U_FAILURE(*status)) {
   1222         return;
   1223     }
   1224     ((DateFormat*)fmt)->setContext(value, *status);
   1225     return;
   1226 }
   1227 
   1228 U_CAPI UDisplayContext U_EXPORT2
   1229 udat_getContext(const UDateFormat* fmt, UDisplayContextType type, UErrorCode* status)
   1230 {
   1231     if (U_FAILURE(*status)) {
   1232         return (UDisplayContext)0;
   1233     }
   1234     return ((const DateFormat*)fmt)->getContext(type, *status);
   1235 }
   1236 
   1237 
   1238 /**
   1239  * Verify that fmt is a RelativeDateFormat. Invalid error if not.
   1240  * @param fmt the UDateFormat, definitely a DateFormat, maybe something else
   1241  * @param status error code, will be set to failure if there is a familure or the fmt is NULL.
   1242  */
   1243 static void verifyIsRelativeDateFormat(const UDateFormat* fmt, UErrorCode *status) {
   1244    if(U_SUCCESS(*status) &&
   1245        dynamic_cast<const RelativeDateFormat*>(reinterpret_cast<const DateFormat*>(fmt))==NULL) {
   1246        *status = U_ILLEGAL_ARGUMENT_ERROR;
   1247    }
   1248 }
   1249 
   1250 
   1251 U_CAPI int32_t U_EXPORT2
   1252 udat_toPatternRelativeDate(const UDateFormat *fmt,
   1253                            UChar             *result,
   1254                            int32_t           resultLength,
   1255                            UErrorCode        *status)
   1256 {
   1257     verifyIsRelativeDateFormat(fmt, status);
   1258     if(U_FAILURE(*status)) {
   1259         return -1;
   1260     }
   1261     if (result == NULL ? resultLength != 0 : resultLength < 0) {
   1262         *status = U_ILLEGAL_ARGUMENT_ERROR;
   1263         return -1;
   1264     }
   1265 
   1266     UnicodeString datePattern;
   1267     if (result != NULL) {
   1268         // NULL destination for pure preflighting: empty dummy string
   1269         // otherwise, alias the destination buffer
   1270         datePattern.setTo(result, 0, resultLength);
   1271     }
   1272     ((RelativeDateFormat*)fmt)->toPatternDate(datePattern, *status);
   1273     return datePattern.extract(result, resultLength, *status);
   1274 }
   1275 
   1276 U_CAPI int32_t U_EXPORT2
   1277 udat_toPatternRelativeTime(const UDateFormat *fmt,
   1278                            UChar             *result,
   1279                            int32_t           resultLength,
   1280                            UErrorCode        *status)
   1281 {
   1282     verifyIsRelativeDateFormat(fmt, status);
   1283     if(U_FAILURE(*status)) {
   1284         return -1;
   1285     }
   1286     if (result == NULL ? resultLength != 0 : resultLength < 0) {
   1287         *status = U_ILLEGAL_ARGUMENT_ERROR;
   1288         return -1;
   1289     }
   1290 
   1291     UnicodeString timePattern;
   1292     if (result != NULL) {
   1293         // NULL destination for pure preflighting: empty dummy string
   1294         // otherwise, alias the destination buffer
   1295         timePattern.setTo(result, 0, resultLength);
   1296     }
   1297     ((RelativeDateFormat*)fmt)->toPatternTime(timePattern, *status);
   1298     return timePattern.extract(result, resultLength, *status);
   1299 }
   1300 
   1301 U_CAPI void U_EXPORT2
   1302 udat_applyPatternRelative(UDateFormat *format,
   1303                           const UChar *datePattern,
   1304                           int32_t     datePatternLength,
   1305                           const UChar *timePattern,
   1306                           int32_t     timePatternLength,
   1307                           UErrorCode  *status)
   1308 {
   1309     verifyIsRelativeDateFormat(format, status);
   1310     if(U_FAILURE(*status)) return;
   1311     const UnicodeString datePat((UBool)(datePatternLength == -1), datePattern, datePatternLength);
   1312     const UnicodeString timePat((UBool)(timePatternLength == -1), timePattern, timePatternLength);
   1313     ((RelativeDateFormat*)format)->applyPatterns(datePat, timePat, *status);
   1314 }
   1315 
   1316 #endif /* #if !UCONFIG_NO_FORMATTING */
   1317