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