icuSources/i18n/udat.cpp

   1 /*
   2 *******************************************************************************
   3 *   Copyright (C) 1996-2010, International Business Machines
   4 *   Corporation and others.  All Rights Reserved.
   5 *******************************************************************************
   6 */
   7
   8 #include "unicode/utypes.h"
   9
  10 #if !UCONFIG_NO_FORMATTING
  11
  12 #include "unicode/udat.h"
  13
  14 #include "unicode/uloc.h"
  15 #include "unicode/datefmt.h"
  16 #include "unicode/timezone.h"
  17 #include "unicode/smpdtfmt.h"
  18 #include "unicode/fieldpos.h"
  19 #include "unicode/parsepos.h"
  20 #include "unicode/calendar.h"
  21 #include "unicode/numfmt.h"
  22 #include "unicode/dtfmtsym.h"
  23 #include "unicode/ustring.h"
  24 #include "cpputils.h"
  25 #include "reldtfmt.h"
  26
  27 U_NAMESPACE_USE
  28
  29 /**
  30  * Verify that fmt is a SimpleDateFormat. Invalid error if not.
  31  * @param fmt the UDateFormat, definitely a DateFormat, maybe something else
  32  * @param status error code, will be set to failure if there is a familure or the fmt is NULL.
  33  */
  34 static void verifyIsSimpleDateFormat(const UDateFormat* fmt, UErrorCode *status) {
  35    if(U_SUCCESS(*status) &&
  36        dynamic_cast<const SimpleDateFormat*>(reinterpret_cast<const DateFormat*>(fmt))==NULL) {
  37        *status = U_ILLEGAL_ARGUMENT_ERROR;
  38    }
  39 }
  40
  41 // This mirrors the correspondence between the
  42 // SimpleDateFormat::fgPatternIndexToDateFormatField and
  43 // SimpleDateFormat::fgPatternIndexToCalendarField arrays.
  44 static UCalendarDateFields gDateFieldMapping[] = {
  45     UCAL_ERA,                  // UDAT_ERA_FIELD = 0
  46     UCAL_YEAR,                 // UDAT_YEAR_FIELD = 1
  47     UCAL_MONTH,                // UDAT_MONTH_FIELD = 2
  48     UCAL_DATE,                 // UDAT_DATE_FIELD = 3
  49     UCAL_HOUR_OF_DAY,          // UDAT_HOUR_OF_DAY1_FIELD = 4
  50     UCAL_HOUR_OF_DAY,          // UDAT_HOUR_OF_DAY0_FIELD = 5
  51     UCAL_MINUTE,               // UDAT_MINUTE_FIELD = 6
  52     UCAL_SECOND,               // UDAT_SECOND_FIELD = 7
  53     UCAL_MILLISECOND,          // UDAT_FRACTIONAL_SECOND_FIELD = 8
  54     UCAL_DAY_OF_WEEK,          // UDAT_DAY_OF_WEEK_FIELD = 9
  55     UCAL_DAY_OF_YEAR,          // UDAT_DAY_OF_YEAR_FIELD = 10
  56     UCAL_DAY_OF_WEEK_IN_MONTH, // UDAT_DAY_OF_WEEK_IN_MONTH_FIELD = 11
  57     UCAL_WEEK_OF_YEAR,         // UDAT_WEEK_OF_YEAR_FIELD = 12
  58     UCAL_WEEK_OF_MONTH,        // UDAT_WEEK_OF_MONTH_FIELD = 13
  59     UCAL_AM_PM,                // UDAT_AM_PM_FIELD = 14
  60     UCAL_HOUR,                 // UDAT_HOUR1_FIELD = 15
  61     UCAL_HOUR,                 // UDAT_HOUR0_FIELD = 16
  62     UCAL_ZONE_OFFSET,          // UDAT_TIMEZONE_FIELD = 17
  63     UCAL_YEAR_WOY,             // UDAT_YEAR_WOY_FIELD = 18
  64     UCAL_DOW_LOCAL,            // UDAT_DOW_LOCAL_FIELD = 19
  65     UCAL_EXTENDED_YEAR,        // UDAT_EXTENDED_YEAR_FIELD = 20
  66     UCAL_JULIAN_DAY,           // UDAT_JULIAN_DAY_FIELD = 21
  67     UCAL_MILLISECONDS_IN_DAY,  // UDAT_MILLISECONDS_IN_DAY_FIELD = 22
  68     UCAL_ZONE_OFFSET,          // UDAT_TIMEZONE_RFC_FIELD = 23
  69     // UCAL_DST_OFFSET also
  70     UCAL_ZONE_OFFSET,          // UDAT_TIMEZONE_GENERIC_FIELD = 24
  71     UCAL_DOW_LOCAL,            // UDAT_STANDALONE_DAY_FIELD = 25
  72     UCAL_MONTH,                // UDAT_STANDALONE_MONTH_FIELD = 26
  73     UCAL_MONTH,                // UDAT_QUARTER_FIELD = 27
  74     UCAL_MONTH,                // UDAT_STANDALONE_QUARTER_FIELD = 28
  75     UCAL_ZONE_OFFSET,          // UDAT_TIMEZONE_SPECIAL_FIELD = 29
  76     UCAL_FIELD_COUNT,          // UDAT_FIELD_COUNT = 30
  77     // UCAL_IS_LEAP_MONTH is not the target of a mapping
  78 };
  79
  80 U_CAPI UCalendarDateFields U_EXPORT2
  81 udat_toCalendarDateField(UDateFormatField field) {
  82   return gDateFieldMapping[field];
  83 }
  84
  85 U_CAPI UDateFormat* U_EXPORT2
  86 udat_open(UDateFormatStyle  timeStyle,
  87           UDateFormatStyle  dateStyle,
  88           const char        *locale,
  89           const UChar       *tzID,
  90           int32_t           tzIDLength,
  91           const UChar       *pattern,
  92           int32_t           patternLength,
  93           UErrorCode        *status)
  94 {
  95     DateFormat *fmt;
  96     if(U_FAILURE(*status)) {
  97         return 0;
  98     }
  99     if(timeStyle != UDAT_IGNORE) {
 100         if(locale == 0) {
 101             fmt = DateFormat::createDateTimeInstance((DateFormat::EStyle)dateStyle,
 102                 (DateFormat::EStyle)timeStyle);
 103         }
 104         else {
 105             fmt = DateFormat::createDateTimeInstance((DateFormat::EStyle)dateStyle,
 106                 (DateFormat::EStyle)timeStyle,
 107                 Locale(locale));
 108         }
 109     }
 110     else {
 111         UnicodeString pat((UBool)(patternLength == -1), pattern, patternLength);
 112
 113         if(locale == 0) {
 114             fmt = new SimpleDateFormat(pat, *status);
 115         }
 116         else {
 117             fmt = new SimpleDateFormat(pat, Locale(locale), *status);
 118         }
 119     }
 120
 121     if(fmt == 0) {
 122         *status = U_MEMORY_ALLOCATION_ERROR;
 123         return 0;
 124     }
 125
 126     if(tzID != 0) {
 127         TimeZone *zone = TimeZone::createTimeZone(UnicodeString((UBool)(tzIDLength == -1), tzID, tzIDLength));
 128         if(zone == 0) {
 129             *status = U_MEMORY_ALLOCATION_ERROR;
 130             delete fmt;
 131             return 0;
 132         }
 133         fmt->adoptTimeZone(zone);
 134     }
 135
 136     return (UDateFormat*)fmt;
 137 }
 138
 139
 140 U_CAPI void U_EXPORT2
 141 udat_close(UDateFormat* format)
 142 {
 143     delete (DateFormat*)format;
 144 }
 145
 146 U_CAPI UDateFormat* U_EXPORT2
 147 udat_clone(const UDateFormat *fmt,
 148        UErrorCode *status)
 149 {
 150     if(U_FAILURE(*status)) return 0;
 151
 152     Format *res = ((DateFormat*)fmt)->clone();
 153
 154     if(res == 0) {
 155         *status = U_MEMORY_ALLOCATION_ERROR;
 156         return 0;
 157     }
 158
 159     return (UDateFormat*) res;
 160 }
 161
 162 U_CAPI int32_t U_EXPORT2
 163 udat_format(    const    UDateFormat*    format,
 164         UDate           dateToFormat,
 165         UChar*          result,
 166         int32_t         resultLength,
 167         UFieldPosition* position,
 168         UErrorCode*     status)
 169 {
 170     if(U_FAILURE(*status)) return -1;
 171
 172     UnicodeString res;
 173     if(!(result==NULL && resultLength==0)) {
 174         // NULL destination for pure preflighting: empty dummy string
 175         // otherwise, alias the destination buffer
 176         res.setTo(result, 0, resultLength);
 177     }
 178
 179     FieldPosition fp;
 180
 181     if(position != 0)
 182         fp.setField(position->field);
 183
 184     ((DateFormat*)format)->format(dateToFormat, res, fp);
 185
 186     if(position != 0) {
 187         position->beginIndex = fp.getBeginIndex();
 188         position->endIndex = fp.getEndIndex();
 189     }
 190
 191     return res.extract(result, resultLength, *status);
 192 }
 193
 194 U_CAPI UDate U_EXPORT2
 195 udat_parse(    const    UDateFormat*        format,
 196         const    UChar*          text,
 197         int32_t         textLength,
 198         int32_t         *parsePos,
 199         UErrorCode      *status)
 200 {
 201     if(U_FAILURE(*status)) return (UDate)0;
 202
 203     const UnicodeString src((UBool)(textLength == -1), text, textLength);
 204     ParsePosition pp;
 205     int32_t stackParsePos = 0;
 206     UDate res;
 207
 208     if(parsePos == NULL) {
 209         parsePos = &stackParsePos;
 210     }
 211
 212     pp.setIndex(*parsePos);
 213
 214     res = ((DateFormat*)format)->parse(src, pp);
 215
 216     if(pp.getErrorIndex() == -1)
 217         *parsePos = pp.getIndex();
 218     else {
 219         *parsePos = pp.getErrorIndex();
 220         *status = U_PARSE_ERROR;
 221     }
 222
 223     return res;
 224 }
 225
 226 U_CAPI void U_EXPORT2
 227 udat_parseCalendar(const    UDateFormat*    format,
 228                             UCalendar*      calendar,
 229                    const    UChar*          text,
 230                             int32_t         textLength,
 231                             int32_t         *parsePos,
 232                             UErrorCode      *status)
 233 {
 234     if(U_FAILURE(*status)) return;
 235
 236     const UnicodeString src((UBool)(textLength == -1), text, textLength);
 237     ParsePosition pp;
 238
 239     if(parsePos != 0)
 240         pp.setIndex(*parsePos);
 241
 242     ((DateFormat*)format)->parse(src, *(Calendar*)calendar, pp);
 243
 244     if(parsePos != 0) {
 245         if(pp.getErrorIndex() == -1)
 246             *parsePos = pp.getIndex();
 247         else {
 248             *parsePos = pp.getErrorIndex();
 249             *status = U_PARSE_ERROR;
 250         }
 251     }
 252 }
 253
 254 U_CAPI UBool U_EXPORT2
 255 udat_isLenient(const UDateFormat* fmt)
 256 {
 257     return ((DateFormat*)fmt)->isLenient();
 258 }
 259
 260 U_CAPI void U_EXPORT2
 261 udat_setLenient(    UDateFormat*    fmt,
 262             UBool          isLenient)
 263 {
 264     ((DateFormat*)fmt)->setLenient(isLenient);
 265 }
 266
 267 U_CAPI const UCalendar* U_EXPORT2
 268 udat_getCalendar(const UDateFormat* fmt)
 269 {
 270     return (const UCalendar*) ((DateFormat*)fmt)->getCalendar();
 271 }
 272
 273 U_CAPI void U_EXPORT2
 274 udat_setCalendar(UDateFormat*    fmt,
 275                  const   UCalendar*      calendarToSet)
 276 {
 277     ((DateFormat*)fmt)->setCalendar(*((Calendar*)calendarToSet));
 278 }
 279
 280 U_CAPI const UNumberFormat* U_EXPORT2
 281 udat_getNumberFormat(const UDateFormat* fmt)
 282 {
 283     return (const UNumberFormat*) ((DateFormat*)fmt)->getNumberFormat();
 284 }
 285
 286 U_CAPI void U_EXPORT2
 287 udat_setNumberFormat(UDateFormat*    fmt,
 288                      const   UNumberFormat*  numberFormatToSet)
 289 {
 290     ((DateFormat*)fmt)->setNumberFormat(*((NumberFormat*)numberFormatToSet));
 291 }
 292
 293 U_CAPI const char* U_EXPORT2
 294 udat_getAvailable(int32_t index)
 295 {
 296     return uloc_getAvailable(index);
 297 }
 298
 299 U_CAPI int32_t U_EXPORT2
 300 udat_countAvailable()
 301 {
 302     return uloc_countAvailable();
 303 }
 304
 305 U_CAPI UDate U_EXPORT2
 306 udat_get2DigitYearStart(    const   UDateFormat     *fmt,
 307                         UErrorCode      *status)
 308 {
 309     verifyIsSimpleDateFormat(fmt, status);
 310     if(U_FAILURE(*status)) return (UDate)0;
 311     return ((SimpleDateFormat*)fmt)->get2DigitYearStart(*status);
 312 }
 313
 314 U_CAPI void U_EXPORT2
 315 udat_set2DigitYearStart(    UDateFormat     *fmt,
 316                         UDate           d,
 317                         UErrorCode      *status)
 318 {
 319     verifyIsSimpleDateFormat(fmt, status);
 320     if(U_FAILURE(*status)) return;
 321     ((SimpleDateFormat*)fmt)->set2DigitYearStart(d, *status);
 322 }
 323
 324 U_CAPI int32_t U_EXPORT2
 325 udat_toPattern(    const   UDateFormat     *fmt,
 326         UBool          localized,
 327         UChar           *result,
 328         int32_t         resultLength,
 329         UErrorCode      *status)
 330 {
 331     if(U_FAILURE(*status)) return -1;
 332
 333     UnicodeString res;
 334     if(!(result==NULL && resultLength==0)) {
 335         // NULL destination for pure preflighting: empty dummy string
 336         // otherwise, alias the destination buffer
 337         res.setTo(result, 0, resultLength);
 338     }
 339
 340     const DateFormat *df=reinterpret_cast<const DateFormat *>(fmt);
 341     const SimpleDateFormat *sdtfmt=dynamic_cast<const SimpleDateFormat *>(df);
 342     const RelativeDateFormat *reldtfmt;
 343     if (sdtfmt!=NULL) {
 344         if(localized)
 345             sdtfmt->toLocalizedPattern(res, *status);
 346         else
 347             sdtfmt->toPattern(res);
 348     } else if (!localized && (reldtfmt=dynamic_cast<const RelativeDateFormat *>(df))!=NULL) {
 349         reldtfmt->toPattern(res, *status);
 350     } else {
 351         *status = U_ILLEGAL_ARGUMENT_ERROR;
 352         return -1;
 353     }
 354
 355     return res.extract(result, resultLength, *status);
 356 }
 357
 358 // TODO: should this take an UErrorCode?
 359 // A: Yes. Of course.
 360 U_CAPI void U_EXPORT2
 361 udat_applyPattern(  UDateFormat     *format,
 362                     UBool          localized,
 363                     const   UChar           *pattern,
 364                     int32_t         patternLength)
 365 {
 366     const UnicodeString pat((UBool)(patternLength == -1), pattern, patternLength);
 367     UErrorCode status = U_ZERO_ERROR;
 368
 369     verifyIsSimpleDateFormat(format, &status);
 370     if(U_FAILURE(status)) {
 371         return;
 372     }
 373
 374     if(localized)
 375         ((SimpleDateFormat*)format)->applyLocalizedPattern(pat, status);
 376     else
 377         ((SimpleDateFormat*)format)->applyPattern(pat);
 378 }
 379
 380 U_CAPI int32_t U_EXPORT2
 381 udat_getSymbols(const   UDateFormat     *fmt,
 382                 UDateFormatSymbolType   type,
 383                 int32_t                 index,
 384                 UChar                   *result,
 385                 int32_t                 resultLength,
 386                 UErrorCode              *status)
 387 {
 388     const DateFormatSymbols *syms;
 389     const SimpleDateFormat* sdtfmt;
 390     const RelativeDateFormat* rdtfmt;
 391     if ((sdtfmt = dynamic_cast<const SimpleDateFormat*>(reinterpret_cast<const DateFormat*>(fmt))) != NULL) {
 392         syms = sdtfmt->getDateFormatSymbols();
 393     } else if ((rdtfmt = dynamic_cast<const RelativeDateFormat*>(reinterpret_cast<const DateFormat*>(fmt))) != NULL) {
 394         syms = rdtfmt->getDateFormatSymbols();
 395     } else {
 396         return -1;
 397     }
 398     int32_t count;
 399     const UnicodeString *res = NULL;
 400
 401     switch(type) {
 402     case UDAT_ERAS:
 403         res = syms->getEras(count);
 404         break;
 405
 406     case UDAT_ERA_NAMES:
 407         res = syms->getEraNames(count);
 408         break;
 409
 410     case UDAT_MONTHS:
 411         res = syms->getMonths(count);
 412         break;
 413
 414     case UDAT_SHORT_MONTHS:
 415         res = syms->getShortMonths(count);
 416         break;
 417
 418     case UDAT_WEEKDAYS:
 419         res = syms->getWeekdays(count);
 420         break;
 421
 422     case UDAT_SHORT_WEEKDAYS:
 423         res = syms->getShortWeekdays(count);
 424         break;
 425
 426     case UDAT_AM_PMS:
 427         res = syms->getAmPmStrings(count);
 428         break;
 429
 430     case UDAT_LOCALIZED_CHARS:
 431         {
 432             UnicodeString res1;
 433             if(!(result==NULL && resultLength==0)) {
 434                 // NULL destination for pure preflighting: empty dummy string
 435                 // otherwise, alias the destination buffer
 436                 res1.setTo(result, 0, resultLength);
 437             }
 438             syms->getLocalPatternChars(res1);
 439             return res1.extract(result, resultLength, *status);
 440         }
 441
 442     case UDAT_NARROW_MONTHS:
 443         res = syms->getMonths(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
 444         break;
 445
 446     case UDAT_NARROW_WEEKDAYS:
 447         res = syms->getWeekdays(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
 448         break;
 449
 450     case UDAT_STANDALONE_MONTHS:
 451         res = syms->getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
 452         break;
 453
 454     case UDAT_STANDALONE_SHORT_MONTHS:
 455         res = syms->getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
 456         break;
 457
 458     case UDAT_STANDALONE_NARROW_MONTHS:
 459         res = syms->getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::NARROW);
 460         break;
 461
 462     case UDAT_STANDALONE_WEEKDAYS:
 463         res = syms->getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
 464         break;
 465
 466     case UDAT_STANDALONE_SHORT_WEEKDAYS:
 467         res = syms->getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
 468         break;
 469
 470     case UDAT_STANDALONE_NARROW_WEEKDAYS:
 471         res = syms->getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::NARROW);
 472         break;
 473
 474     case UDAT_QUARTERS:
 475         res = syms->getQuarters(count, DateFormatSymbols::FORMAT, DateFormatSymbols::WIDE);
 476         break;
 477
 478     case UDAT_SHORT_QUARTERS:
 479         res = syms->getQuarters(count, DateFormatSymbols::FORMAT, DateFormatSymbols::ABBREVIATED);
 480         break;
 481
 482     case UDAT_STANDALONE_QUARTERS:
 483         res = syms->getQuarters(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
 484         break;
 485
 486     case UDAT_STANDALONE_SHORT_QUARTERS:
 487         res = syms->getQuarters(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
 488         break;
 489
 490     }
 491
 492     if(index < count) {
 493         return res[index].extract(result, resultLength, *status);
 494     }
 495     return 0;
 496 }
 497
 498 // TODO: also needs an errorCode.
 499 U_CAPI int32_t U_EXPORT2
 500 udat_countSymbols(    const    UDateFormat                *fmt,
 501             UDateFormatSymbolType    type)
 502 {
 503     const DateFormatSymbols *syms;
 504     const SimpleDateFormat* sdtfmt;
 505     const RelativeDateFormat* rdtfmt;
 506     if ((sdtfmt = dynamic_cast<const SimpleDateFormat*>(reinterpret_cast<const DateFormat*>(fmt))) != NULL) {
 507         syms = sdtfmt->getDateFormatSymbols();
 508     } else if ((rdtfmt = dynamic_cast<const RelativeDateFormat*>(reinterpret_cast<const DateFormat*>(fmt))) != NULL) {
 509         syms = rdtfmt->getDateFormatSymbols();
 510     } else {
 511         return 0;
 512     }
 513     int32_t count = 0;
 514
 515     switch(type) {
 516     case UDAT_ERAS:
 517         syms->getEras(count);
 518         break;
 519
 520     case UDAT_MONTHS:
 521         syms->getMonths(count);
 522         break;
 523
 524     case UDAT_SHORT_MONTHS:
 525         syms->getShortMonths(count);
 526         break;
 527
 528     case UDAT_WEEKDAYS:
 529         syms->getWeekdays(count);
 530         break;
 531
 532     case UDAT_SHORT_WEEKDAYS:
 533         syms->getShortWeekdays(count);
 534         break;
 535
 536     case UDAT_AM_PMS:
 537         syms->getAmPmStrings(count);
 538         break;
 539
 540     case UDAT_LOCALIZED_CHARS:
 541         count = 1;
 542         break;
 543
 544     case UDAT_ERA_NAMES:
 545         syms->getEraNames(count);
 546         break;
 547
 548     case UDAT_NARROW_MONTHS:
 549         syms->getMonths(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
 550         break;
 551
 552     case UDAT_NARROW_WEEKDAYS:
 553         syms->getWeekdays(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
 554         break;
 555
 556     case UDAT_STANDALONE_MONTHS:
 557         syms->getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
 558         break;
 559
 560     case UDAT_STANDALONE_SHORT_MONTHS:
 561         syms->getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
 562         break;
 563
 564     case UDAT_STANDALONE_NARROW_MONTHS:
 565         syms->getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::NARROW);
 566         break;
 567
 568     case UDAT_STANDALONE_WEEKDAYS:
 569         syms->getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
 570         break;
 571
 572     case UDAT_STANDALONE_SHORT_WEEKDAYS:
 573         syms->getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
 574         break;
 575
 576     case UDAT_STANDALONE_NARROW_WEEKDAYS:
 577         syms->getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::NARROW);
 578         break;
 579
 580     case UDAT_QUARTERS:
 581         syms->getQuarters(count, DateFormatSymbols::FORMAT, DateFormatSymbols::WIDE);
 582         break;
 583
 584     case UDAT_SHORT_QUARTERS:
 585         syms->getQuarters(count, DateFormatSymbols::FORMAT, DateFormatSymbols::ABBREVIATED);
 586         break;
 587
 588     case UDAT_STANDALONE_QUARTERS:
 589         syms->getQuarters(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
 590         break;
 591
 592     case UDAT_STANDALONE_SHORT_QUARTERS:
 593         syms->getQuarters(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
 594         break;
 595
 596     }
 597
 598     return count;
 599 }
 600
 601 U_NAMESPACE_BEGIN
 602
 603 /*
 604  * This DateFormatSymbolsSingleSetter class is a friend of DateFormatSymbols
 605  * solely for the purpose of avoiding to clone the array of strings
 606  * just to modify one of them and then setting all of them back.
 607  * For example, the old code looked like this:
 608  *  case UDAT_MONTHS:
 609  *    res = syms->getMonths(count);
 610  *    array = new UnicodeString[count];
 611  *    if(array == 0) {
 612  *      *status = U_MEMORY_ALLOCATION_ERROR;
 613  *      return;
 614  *    }
 615  *    uprv_arrayCopy(res, array, count);
 616  *    if(index < count)
 617  *      array[index] = val;
 618  *    syms->setMonths(array, count);
 619  *    break;
 620  *
 621  * Even worse, the old code actually cloned the entire DateFormatSymbols object,
 622  * cloned one value array, changed one value, and then made the SimpleDateFormat
 623  * replace its DateFormatSymbols object with the new one.
 624  *
 625  * markus 2002-oct-14
 626  */
 627 class DateFormatSymbolsSingleSetter /* not : public UObject because all methods are static */ {
 628 public:
 629     static void
 630         setSymbol(UnicodeString *array, int32_t count, int32_t index,
 631         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
 632     {
 633         if(array!=NULL) {
 634             if(index>=count) {
 635                 errorCode=U_INDEX_OUTOFBOUNDS_ERROR;
 636             } else if(value==NULL) {
 637                 errorCode=U_ILLEGAL_ARGUMENT_ERROR;
 638             } else {
 639                 array[index].setTo(value, valueLength);
 640             }
 641         }
 642     }
 643
 644     static void
 645         setEra(DateFormatSymbols *syms, int32_t index,
 646         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
 647     {
 648         setSymbol(syms->fEras, syms->fErasCount, index, value, valueLength, errorCode);
 649     }
 650
 651     static void
 652         setEraName(DateFormatSymbols *syms, int32_t index,
 653         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
 654     {
 655         setSymbol(syms->fEraNames, syms->fEraNamesCount, index, value, valueLength, errorCode);
 656     }
 657
 658     static void
 659         setMonth(DateFormatSymbols *syms, int32_t index,
 660         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
 661     {
 662         setSymbol(syms->fMonths, syms->fMonthsCount, index, value, valueLength, errorCode);
 663     }
 664
 665     static void
 666         setShortMonth(DateFormatSymbols *syms, int32_t index,
 667         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
 668     {
 669         setSymbol(syms->fShortMonths, syms->fShortMonthsCount, index, value, valueLength, errorCode);
 670     }
 671
 672     static void
 673         setNarrowMonth(DateFormatSymbols *syms, int32_t index,
 674         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
 675     {
 676         setSymbol(syms->fNarrowMonths, syms->fNarrowMonthsCount, index, value, valueLength, errorCode);
 677     }
 678
 679     static void
 680         setStandaloneMonth(DateFormatSymbols *syms, int32_t index,
 681         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
 682     {
 683         setSymbol(syms->fStandaloneMonths, syms->fStandaloneMonthsCount, index, value, valueLength, errorCode);
 684     }
 685
 686     static void
 687         setStandaloneShortMonth(DateFormatSymbols *syms, int32_t index,
 688         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
 689     {
 690         setSymbol(syms->fStandaloneShortMonths, syms->fStandaloneShortMonthsCount, index, value, valueLength, errorCode);
 691     }
 692
 693     static void
 694         setStandaloneNarrowMonth(DateFormatSymbols *syms, int32_t index,
 695         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
 696     {
 697         setSymbol(syms->fStandaloneNarrowMonths, syms->fStandaloneNarrowMonthsCount, index, value, valueLength, errorCode);
 698     }
 699
 700     static void
 701         setWeekday(DateFormatSymbols *syms, int32_t index,
 702         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
 703     {
 704         setSymbol(syms->fWeekdays, syms->fWeekdaysCount, index, value, valueLength, errorCode);
 705     }
 706
 707     static void
 708         setShortWeekday(DateFormatSymbols *syms, int32_t index,
 709         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
 710     {
 711         setSymbol(syms->fShortWeekdays, syms->fShortWeekdaysCount, index, value, valueLength, errorCode);
 712     }
 713
 714     static void
 715         setNarrowWeekday(DateFormatSymbols *syms, int32_t index,
 716         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
 717     {
 718         setSymbol(syms->fNarrowWeekdays, syms->fNarrowWeekdaysCount, index, value, valueLength, errorCode);
 719     }
 720
 721     static void
 722         setStandaloneWeekday(DateFormatSymbols *syms, int32_t index,
 723         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
 724     {
 725         setSymbol(syms->fStandaloneWeekdays, syms->fStandaloneWeekdaysCount, index, value, valueLength, errorCode);
 726     }
 727
 728     static void
 729         setStandaloneShortWeekday(DateFormatSymbols *syms, int32_t index,
 730         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
 731     {
 732         setSymbol(syms->fStandaloneShortWeekdays, syms->fStandaloneShortWeekdaysCount, index, value, valueLength, errorCode);
 733     }
 734
 735     static void
 736         setStandaloneNarrowWeekday(DateFormatSymbols *syms, int32_t index,
 737         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
 738     {
 739         setSymbol(syms->fStandaloneNarrowWeekdays, syms->fStandaloneNarrowWeekdaysCount, index, value, valueLength, errorCode);
 740     }
 741
 742     static void
 743         setQuarter(DateFormatSymbols *syms, int32_t index,
 744         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
 745     {
 746         setSymbol(syms->fQuarters, syms->fQuartersCount, index, value, valueLength, errorCode);
 747     }
 748
 749     static void
 750         setShortQuarter(DateFormatSymbols *syms, int32_t index,
 751         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
 752     {
 753         setSymbol(syms->fShortQuarters, syms->fShortQuartersCount, index, value, valueLength, errorCode);
 754     }
 755
 756     static void
 757         setStandaloneQuarter(DateFormatSymbols *syms, int32_t index,
 758         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
 759     {
 760         setSymbol(syms->fStandaloneQuarters, syms->fStandaloneQuartersCount, index, value, valueLength, errorCode);
 761     }
 762
 763     static void
 764         setStandaloneShortQuarter(DateFormatSymbols *syms, int32_t index,
 765         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
 766     {
 767         setSymbol(syms->fStandaloneShortQuarters, syms->fStandaloneShortQuartersCount, index, value, valueLength, errorCode);
 768     }
 769
 770     static void
 771         setAmPm(DateFormatSymbols *syms, int32_t index,
 772         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
 773     {
 774         setSymbol(syms->fAmPms, syms->fAmPmsCount, index, value, valueLength, errorCode);
 775     }
 776
 777     static void
 778         setLocalPatternChars(DateFormatSymbols *syms,
 779         const UChar *value, int32_t valueLength, UErrorCode &errorCode)
 780     {
 781         setSymbol(&syms->fLocalPatternChars, 1, 0, value, valueLength, errorCode);
 782     }
 783 };
 784
 785 U_NAMESPACE_END
 786
 787 U_CAPI void U_EXPORT2
 788 udat_setSymbols(    UDateFormat             *format,
 789             UDateFormatSymbolType   type,
 790             int32_t                 index,
 791             UChar                   *value,
 792             int32_t                 valueLength,
 793             UErrorCode              *status)
 794 {
 795     verifyIsSimpleDateFormat(format, status);
 796     if(U_FAILURE(*status)) return;
 797
 798     DateFormatSymbols *syms = (DateFormatSymbols *)((SimpleDateFormat *)format)->getDateFormatSymbols();
 799
 800     switch(type) {
 801     case UDAT_ERAS:
 802         DateFormatSymbolsSingleSetter::setEra(syms, index, value, valueLength, *status);
 803         break;
 804
 805     case UDAT_ERA_NAMES:
 806         DateFormatSymbolsSingleSetter::setEraName(syms, index, value, valueLength, *status);
 807         break;
 808
 809     case UDAT_MONTHS:
 810         DateFormatSymbolsSingleSetter::setMonth(syms, index, value, valueLength, *status);
 811         break;
 812
 813     case UDAT_SHORT_MONTHS:
 814         DateFormatSymbolsSingleSetter::setShortMonth(syms, index, value, valueLength, *status);
 815         break;
 816
 817     case UDAT_NARROW_MONTHS:
 818         DateFormatSymbolsSingleSetter::setNarrowMonth(syms, index, value, valueLength, *status);
 819         break;
 820
 821     case UDAT_STANDALONE_MONTHS:
 822         DateFormatSymbolsSingleSetter::setStandaloneMonth(syms, index, value, valueLength, *status);
 823         break;
 824
 825     case UDAT_STANDALONE_SHORT_MONTHS:
 826         DateFormatSymbolsSingleSetter::setStandaloneShortMonth(syms, index, value, valueLength, *status);
 827         break;
 828
 829     case UDAT_STANDALONE_NARROW_MONTHS:
 830         DateFormatSymbolsSingleSetter::setStandaloneNarrowMonth(syms, index, value, valueLength, *status);
 831         break;
 832
 833     case UDAT_WEEKDAYS:
 834         DateFormatSymbolsSingleSetter::setWeekday(syms, index, value, valueLength, *status);
 835         break;
 836
 837     case UDAT_SHORT_WEEKDAYS:
 838         DateFormatSymbolsSingleSetter::setShortWeekday(syms, index, value, valueLength, *status);
 839         break;
 840
 841     case UDAT_NARROW_WEEKDAYS:
 842         DateFormatSymbolsSingleSetter::setNarrowWeekday(syms, index, value, valueLength, *status);
 843         break;
 844
 845     case UDAT_STANDALONE_WEEKDAYS:
 846         DateFormatSymbolsSingleSetter::setStandaloneWeekday(syms, index, value, valueLength, *status);
 847         break;
 848
 849     case UDAT_STANDALONE_SHORT_WEEKDAYS:
 850         DateFormatSymbolsSingleSetter::setStandaloneShortWeekday(syms, index, value, valueLength, *status);
 851         break;
 852
 853     case UDAT_STANDALONE_NARROW_WEEKDAYS:
 854         DateFormatSymbolsSingleSetter::setStandaloneNarrowWeekday(syms, index, value, valueLength, *status);
 855         break;
 856
 857     case UDAT_QUARTERS:
 858         DateFormatSymbolsSingleSetter::setQuarter(syms, index, value, valueLength, *status);
 859         break;
 860
 861     case UDAT_SHORT_QUARTERS:
 862         DateFormatSymbolsSingleSetter::setShortQuarter(syms, index, value, valueLength, *status);
 863         break;
 864
 865     case UDAT_STANDALONE_QUARTERS:
 866         DateFormatSymbolsSingleSetter::setStandaloneQuarter(syms, index, value, valueLength, *status);
 867         break;
 868
 869     case UDAT_STANDALONE_SHORT_QUARTERS:
 870         DateFormatSymbolsSingleSetter::setStandaloneShortQuarter(syms, index, value, valueLength, *status);
 871         break;
 872
 873     case UDAT_AM_PMS:
 874         DateFormatSymbolsSingleSetter::setAmPm(syms, index, value, valueLength, *status);
 875         break;
 876
 877     case UDAT_LOCALIZED_CHARS:
 878         DateFormatSymbolsSingleSetter::setLocalPatternChars(syms, value, valueLength, *status);
 879         break;
 880
 881     default:
 882         *status = U_UNSUPPORTED_ERROR;
 883         break;
 884
 885     }
 886 }
 887
 888 U_CAPI const char* U_EXPORT2
 889 udat_getLocaleByType(const UDateFormat *fmt,
 890                      ULocDataLocaleType type,
 891                      UErrorCode* status)
 892 {
 893     if (fmt == NULL) {
 894         if (U_SUCCESS(*status)) {
 895             *status = U_ILLEGAL_ARGUMENT_ERROR;
 896         }
 897         return NULL;
 898     }
 899     return ((Format*)fmt)->getLocaleID(type, *status);
 900 }
 901
 902 /**
 903  * Verify that fmt is a RelativeDateFormat. Invalid error if not.
 904  * @param fmt the UDateFormat, definitely a DateFormat, maybe something else
 905  * @param status error code, will be set to failure if there is a familure or the fmt is NULL.
 906  */
 907 static void verifyIsRelativeDateFormat(const UDateFormat* fmt, UErrorCode *status) {
 908    if(U_SUCCESS(*status) &&
 909        dynamic_cast<const RelativeDateFormat*>(reinterpret_cast<const DateFormat*>(fmt))==NULL) {
 910        *status = U_ILLEGAL_ARGUMENT_ERROR;
 911    }
 912 }
 913
 914
 915 U_CAPI int32_t U_EXPORT2
 916 udat_toPatternRelativeDate(const UDateFormat *fmt,
 917                            UChar             *result,
 918                            int32_t           resultLength,
 919                            UErrorCode        *status)
 920 {
 921     verifyIsRelativeDateFormat(fmt, status);
 922     if(U_FAILURE(*status)) return -1;
 923
 924     UnicodeString datePattern;
 925     if(!(result==NULL && resultLength==0)) {
 926         // NULL destination for pure preflighting: empty dummy string
 927         // otherwise, alias the destination buffer
 928         datePattern.setTo(result, 0, resultLength);
 929     }
 930     ((RelativeDateFormat*)fmt)->toPatternDate(datePattern, *status);
 931     return datePattern.extract(result, resultLength, *status);
 932 }
 933
 934 U_CAPI int32_t U_EXPORT2
 935 udat_toPatternRelativeTime(const UDateFormat *fmt,
 936                            UChar             *result,
 937                            int32_t           resultLength,
 938                            UErrorCode        *status)
 939 {
 940     verifyIsRelativeDateFormat(fmt, status);
 941     if(U_FAILURE(*status)) return -1;
 942
 943     UnicodeString timePattern;
 944     if(!(result==NULL && resultLength==0)) {
 945         // NULL destination for pure preflighting: empty dummy string
 946         // otherwise, alias the destination buffer
 947         timePattern.setTo(result, 0, resultLength);
 948     }
 949     ((RelativeDateFormat*)fmt)->toPatternTime(timePattern, *status);
 950     return timePattern.extract(result, resultLength, *status);
 951 }
 952
 953 U_CAPI void U_EXPORT2
 954 udat_applyPatternRelative(UDateFormat *format,
 955                           const UChar *datePattern,
 956                           int32_t     datePatternLength,
 957                           const UChar *timePattern,
 958                           int32_t     timePatternLength,
 959                           UErrorCode  *status)
 960 {
 961     verifyIsRelativeDateFormat(format, status);
 962     if(U_FAILURE(*status)) return;
 963     const UnicodeString datePat((UBool)(datePatternLength == -1), datePattern, datePatternLength);
 964     const UnicodeString timePat((UBool)(timePatternLength == -1), timePattern, timePatternLength);
 965     ((RelativeDateFormat*)format)->applyPatterns(datePat, timePat, *status);
 966 }
 967
 968 #endif /* #if !UCONFIG_NO_FORMATTING */