1 /******************************************************************************* 2 * Copyright (C) 2008-2011, International Business Machines Corporation and 3 * others. All Rights Reserved. 4 ******************************************************************************* 5 * 6 * File DTITVFMT.CPP 7 * 8 ******************************************************************************* 9 */ 10 11 #include <typeinfo> // for 'typeid' to work 12 13 #include "unicode/dtitvfmt.h" 14 15 #if !UCONFIG_NO_FORMATTING 16 17 //TODO: put in compilation 18 //#define DTITVFMT_DEBUG 1 19 20 #include "cstring.h" 21 #include "unicode/msgfmt.h" 22 #include "unicode/dtptngen.h" 23 #include "unicode/dtitvinf.h" 24 #include "unicode/calendar.h" 25 #include "dtitv_impl.h" 26 27 #ifdef DTITVFMT_DEBUG 28 #include <iostream> 29 #include "cstring.h" 30 #endif 31 32 #include "gregoimp.h" 33 34 U_NAMESPACE_BEGIN 35 36 37 38 #ifdef DTITVFMT_DEBUG 39 #define PRINTMESG(msg) { std::cout << "(" << __FILE__ << ":" << __LINE__ << ") " << msg << "\n"; } 40 #endif 41 42 43 static const UChar gDateFormatSkeleton[][11] = { 44 //yMMMMEEEEd 45 {LOW_Y, CAP_M, CAP_M, CAP_M, CAP_M, CAP_E, CAP_E, CAP_E, CAP_E, LOW_D, 0}, 46 //yMMMMd 47 {LOW_Y, CAP_M, CAP_M, CAP_M, CAP_M, LOW_D, 0}, 48 //yMMMd 49 {LOW_Y, CAP_M, CAP_M, CAP_M, LOW_D, 0}, 50 //yMd 51 {LOW_Y, CAP_M, LOW_D, 0} }; 52 53 54 static const char gDateTimePatternsTag[]="DateTimePatterns"; 55 56 57 // latestFirst: 58 static const UChar gLaterFirstPrefix[] = {LOW_L, LOW_A, LOW_T, LOW_E, LOW_S,LOW_T, CAP_F, LOW_I, LOW_R, LOW_S, LOW_T, COLON}; 59 60 // earliestFirst: 61 static const UChar gEarlierFirstPrefix[] = {LOW_E, LOW_A, LOW_R, LOW_L, LOW_I, LOW_E, LOW_S, LOW_T, CAP_F, LOW_I, LOW_R, LOW_S, LOW_T, COLON}; 62 63 64 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(DateIntervalFormat) 65 66 67 68 DateIntervalFormat* U_EXPORT2 69 DateIntervalFormat::createInstance(const UnicodeString& skeleton, 70 UErrorCode& status) { 71 return createInstance(skeleton, Locale::getDefault(), status); 72 } 73 74 75 DateIntervalFormat* U_EXPORT2 76 DateIntervalFormat::createInstance(const UnicodeString& skeleton, 77 const Locale& locale, 78 UErrorCode& status) { 79 #ifdef DTITVFMT_DEBUG 80 char result[1000]; 81 char result_1[1000]; 82 char mesg[2000]; 83 skeleton.extract(0, skeleton.length(), result, "UTF-8"); 84 UnicodeString pat; 85 ((SimpleDateFormat*)dtfmt)->toPattern(pat); 86 pat.extract(0, pat.length(), result_1, "UTF-8"); 87 sprintf(mesg, "skeleton: %s; pattern: %s\n", result, result_1); 88 PRINTMESG(mesg) 89 #endif 90 91 DateIntervalInfo* dtitvinf = new DateIntervalInfo(locale, status); 92 return create(locale, dtitvinf, &skeleton, status); 93 } 94 95 96 97 DateIntervalFormat* U_EXPORT2 98 DateIntervalFormat::createInstance(const UnicodeString& skeleton, 99 const DateIntervalInfo& dtitvinf, 100 UErrorCode& status) { 101 return createInstance(skeleton, Locale::getDefault(), dtitvinf, status); 102 } 103 104 105 DateIntervalFormat* U_EXPORT2 106 DateIntervalFormat::createInstance(const UnicodeString& skeleton, 107 const Locale& locale, 108 const DateIntervalInfo& dtitvinf, 109 UErrorCode& status) { 110 DateIntervalInfo* ptn = dtitvinf.clone(); 111 return create(locale, ptn, &skeleton, status); 112 } 113 114 115 DateIntervalFormat::DateIntervalFormat() 116 : fInfo(NULL), 117 fDateFormat(NULL), 118 fFromCalendar(NULL), 119 fToCalendar(NULL), 120 fDtpng(NULL) 121 {} 122 123 124 DateIntervalFormat::DateIntervalFormat(const DateIntervalFormat& itvfmt) 125 : Format(itvfmt), 126 fInfo(NULL), 127 fDateFormat(NULL), 128 fFromCalendar(NULL), 129 fToCalendar(NULL), 130 fDtpng(NULL) { 131 *this = itvfmt; 132 } 133 134 135 DateIntervalFormat& 136 DateIntervalFormat::operator=(const DateIntervalFormat& itvfmt) { 137 if ( this != &itvfmt ) { 138 delete fDateFormat; 139 delete fInfo; 140 delete fFromCalendar; 141 delete fToCalendar; 142 delete fDtpng; 143 if ( itvfmt.fDateFormat ) { 144 fDateFormat = (SimpleDateFormat*)itvfmt.fDateFormat->clone(); 145 } else { 146 fDateFormat = NULL; 147 } 148 if ( itvfmt.fInfo ) { 149 fInfo = itvfmt.fInfo->clone(); 150 } else { 151 fInfo = NULL; 152 } 153 if ( itvfmt.fFromCalendar ) { 154 fFromCalendar = itvfmt.fFromCalendar->clone(); 155 } else { 156 fFromCalendar = NULL; 157 } 158 if ( itvfmt.fToCalendar ) { 159 fToCalendar = itvfmt.fToCalendar->clone(); 160 } else { 161 fToCalendar = NULL; 162 } 163 fSkeleton = itvfmt.fSkeleton; 164 int8_t i; 165 for ( i = 0; i< DateIntervalInfo::kIPI_MAX_INDEX; ++i ) { 166 fIntervalPatterns[i] = itvfmt.fIntervalPatterns[i]; 167 } 168 if (itvfmt.fDtpng) { 169 fDtpng = itvfmt.fDtpng->clone(); 170 } 171 } 172 return *this; 173 } 174 175 176 DateIntervalFormat::~DateIntervalFormat() { 177 delete fInfo; 178 delete fDateFormat; 179 delete fFromCalendar; 180 delete fToCalendar; 181 delete fDtpng; 182 } 183 184 185 Format* 186 DateIntervalFormat::clone(void) const { 187 return new DateIntervalFormat(*this); 188 } 189 190 191 UBool 192 DateIntervalFormat::operator==(const Format& other) const { 193 if (typeid(*this) == typeid(other)) { 194 const DateIntervalFormat* fmt = (DateIntervalFormat*)&other; 195 #ifdef DTITVFMT_DEBUG 196 UBool equal; 197 equal = (this == fmt); 198 199 equal = (*fInfo == *fmt->fInfo); 200 equal = (*fDateFormat == *fmt->fDateFormat); 201 equal = fFromCalendar->isEquivalentTo(*fmt->fFromCalendar) ; 202 equal = fToCalendar->isEquivalentTo(*fmt->fToCalendar) ; 203 equal = (fSkeleton == fmt->fSkeleton); 204 #endif 205 UBool res; 206 res = ( this == fmt ) || 207 ( Format::operator==(other) && 208 fInfo && 209 ( *fInfo == *fmt->fInfo ) && 210 fDateFormat && 211 ( *fDateFormat == *fmt->fDateFormat ) && 212 fFromCalendar && 213 fFromCalendar->isEquivalentTo(*fmt->fFromCalendar) && 214 fToCalendar && 215 fToCalendar->isEquivalentTo(*fmt->fToCalendar) && 216 fSkeleton == fmt->fSkeleton && 217 fDtpng && 218 (*fDtpng == *fmt->fDtpng) ); 219 int8_t i; 220 for (i = 0; i< DateIntervalInfo::kIPI_MAX_INDEX && res == TRUE; ++i ) { 221 res = ( fIntervalPatterns[i].firstPart == 222 fmt->fIntervalPatterns[i].firstPart) && 223 ( fIntervalPatterns[i].secondPart == 224 fmt->fIntervalPatterns[i].secondPart ) && 225 ( fIntervalPatterns[i].laterDateFirst == 226 fmt->fIntervalPatterns[i].laterDateFirst) ; 227 } 228 return res; 229 } 230 return FALSE; 231 } 232 233 234 235 UnicodeString& 236 DateIntervalFormat::format(const Formattable& obj, 237 UnicodeString& appendTo, 238 FieldPosition& fieldPosition, 239 UErrorCode& status) const { 240 if ( U_FAILURE(status) ) { 241 return appendTo; 242 } 243 244 if ( obj.getType() == Formattable::kObject ) { 245 const UObject* formatObj = obj.getObject(); 246 const DateInterval* interval = dynamic_cast<const DateInterval*>(formatObj); 247 if (interval != NULL){ 248 return format(interval, appendTo, fieldPosition, status); 249 } 250 } 251 status = U_ILLEGAL_ARGUMENT_ERROR; 252 return appendTo; 253 } 254 255 256 UnicodeString& 257 DateIntervalFormat::format(const DateInterval* dtInterval, 258 UnicodeString& appendTo, 259 FieldPosition& fieldPosition, 260 UErrorCode& status) const { 261 if ( U_FAILURE(status) ) { 262 return appendTo; 263 } 264 265 if ( fFromCalendar != NULL && fToCalendar != NULL && 266 fDateFormat != NULL && fInfo != NULL ) { 267 fFromCalendar->setTime(dtInterval->getFromDate(), status); 268 fToCalendar->setTime(dtInterval->getToDate(), status); 269 if ( U_SUCCESS(status) ) { 270 return format(*fFromCalendar, *fToCalendar, appendTo,fieldPosition, status); 271 } 272 } 273 return appendTo; 274 } 275 276 277 UnicodeString& 278 DateIntervalFormat::format(Calendar& fromCalendar, 279 Calendar& toCalendar, 280 UnicodeString& appendTo, 281 FieldPosition& pos, 282 UErrorCode& status) const { 283 if ( U_FAILURE(status) ) { 284 return appendTo; 285 } 286 287 // not support different calendar types and time zones 288 //if ( fromCalendar.getType() != toCalendar.getType() ) { 289 if ( !fromCalendar.isEquivalentTo(toCalendar) ) { 290 status = U_ILLEGAL_ARGUMENT_ERROR; 291 return appendTo; 292 } 293 294 // First, find the largest different calendar field. 295 UCalendarDateFields field = UCAL_FIELD_COUNT; 296 297 if ( fromCalendar.get(UCAL_ERA,status) != toCalendar.get(UCAL_ERA,status)) { 298 field = UCAL_ERA; 299 } else if ( fromCalendar.get(UCAL_YEAR, status) != 300 toCalendar.get(UCAL_YEAR, status) ) { 301 field = UCAL_YEAR; 302 } else if ( fromCalendar.get(UCAL_MONTH, status) != 303 toCalendar.get(UCAL_MONTH, status) ) { 304 field = UCAL_MONTH; 305 } else if ( fromCalendar.get(UCAL_DATE, status) != 306 toCalendar.get(UCAL_DATE, status) ) { 307 field = UCAL_DATE; 308 } else if ( fromCalendar.get(UCAL_AM_PM, status) != 309 toCalendar.get(UCAL_AM_PM, status) ) { 310 field = UCAL_AM_PM; 311 } else if ( fromCalendar.get(UCAL_HOUR, status) != 312 toCalendar.get(UCAL_HOUR, status) ) { 313 field = UCAL_HOUR; 314 } else if ( fromCalendar.get(UCAL_MINUTE, status) != 315 toCalendar.get(UCAL_MINUTE, status) ) { 316 field = UCAL_MINUTE; 317 } 318 319 if ( U_FAILURE(status) ) { 320 return appendTo; 321 } 322 if ( field == UCAL_FIELD_COUNT ) { 323 /* ignore the second/millisecond etc. small fields' difference. 324 * use single date when all the above are the same. 325 */ 326 return fDateFormat->format(fromCalendar, appendTo, pos); 327 } 328 329 // following call should not set wrong status, 330 // all the pass-in fields are valid till here 331 int32_t itvPtnIndex = DateIntervalInfo::calendarFieldToIntervalIndex(field, 332 status); 333 const PatternInfo& intervalPattern = fIntervalPatterns[itvPtnIndex]; 334 335 if ( intervalPattern.firstPart.isEmpty() && 336 intervalPattern.secondPart.isEmpty() ) { 337 if ( fDateFormat->isFieldUnitIgnored(field) ) { 338 /* the largest different calendar field is small than 339 * the smallest calendar field in pattern, 340 * return single date format. 341 */ 342 return fDateFormat->format(fromCalendar, appendTo, pos); 343 } 344 return fallbackFormat(fromCalendar, toCalendar, appendTo, pos, status); 345 } 346 // If the first part in interval pattern is empty, 347 // the 2nd part of it saves the full-pattern used in fall-back. 348 // For a 'real' interval pattern, the first part will never be empty. 349 if ( intervalPattern.firstPart.isEmpty() ) { 350 // fall back 351 UnicodeString originalPattern; 352 fDateFormat->toPattern(originalPattern); 353 fDateFormat->applyPattern(intervalPattern.secondPart); 354 appendTo = fallbackFormat(fromCalendar, toCalendar, appendTo, pos, status); 355 fDateFormat->applyPattern(originalPattern); 356 return appendTo; 357 } 358 Calendar* firstCal; 359 Calendar* secondCal; 360 if ( intervalPattern.laterDateFirst ) { 361 firstCal = &toCalendar; 362 secondCal = &fromCalendar; 363 } else { 364 firstCal = &fromCalendar; 365 secondCal = &toCalendar; 366 } 367 // break the interval pattern into 2 parts, 368 // first part should not be empty, 369 UnicodeString originalPattern; 370 fDateFormat->toPattern(originalPattern); 371 fDateFormat->applyPattern(intervalPattern.firstPart); 372 fDateFormat->format(*firstCal, appendTo, pos); 373 if ( !intervalPattern.secondPart.isEmpty() ) { 374 fDateFormat->applyPattern(intervalPattern.secondPart); 375 fDateFormat->format(*secondCal, appendTo, pos); 376 } 377 fDateFormat->applyPattern(originalPattern); 378 return appendTo; 379 } 380 381 382 383 void 384 DateIntervalFormat::parseObject(const UnicodeString& /* source */, 385 Formattable& /* result */, 386 ParsePosition& /* parse_pos */) const { 387 // parseObject(const UnicodeString&, Formattable&, UErrorCode&) const 388 // will set status as U_INVALID_FORMAT_ERROR if 389 // parse_pos is still 0 390 } 391 392 393 394 395 const DateIntervalInfo* 396 DateIntervalFormat::getDateIntervalInfo() const { 397 return fInfo; 398 } 399 400 401 void 402 DateIntervalFormat::setDateIntervalInfo(const DateIntervalInfo& newItvPattern, 403 UErrorCode& status) { 404 delete fInfo; 405 fInfo = new DateIntervalInfo(newItvPattern); 406 if ( fDateFormat ) { 407 initializePattern(status); 408 } 409 } 410 411 412 413 const DateFormat* 414 DateIntervalFormat::getDateFormat() const { 415 return fDateFormat; 416 } 417 418 419 void 420 DateIntervalFormat::adoptTimeZone(TimeZone* zone) 421 { 422 if (fDateFormat != NULL) { 423 fDateFormat->adoptTimeZone(zone); 424 } 425 // The fDateFormat has the master calendar for the DateIntervalFormat and has 426 // ownership of any adopted TimeZone; fFromCalendar and fToCalendar are internal 427 // work clones of that calendar (and should not also be given ownership of the 428 // adopted TimeZone). 429 if (fFromCalendar) { 430 fFromCalendar->setTimeZone(*zone); 431 } 432 if (fToCalendar) { 433 fToCalendar->setTimeZone(*zone); 434 } 435 } 436 437 void 438 DateIntervalFormat::setTimeZone(const TimeZone& zone) 439 { 440 if (fDateFormat != NULL) { 441 fDateFormat->setTimeZone(zone); 442 } 443 // The fDateFormat has the master calendar for the DateIntervalFormat; 444 // fFromCalendar and fToCalendar are internal work clones of that calendar. 445 if (fFromCalendar) { 446 fFromCalendar->setTimeZone(zone); 447 } 448 if (fToCalendar) { 449 fToCalendar->setTimeZone(zone); 450 } 451 } 452 453 const TimeZone& 454 DateIntervalFormat::getTimeZone() const 455 { 456 if (fDateFormat != NULL) { 457 return fDateFormat->getTimeZone(); 458 } 459 // If fDateFormat is NULL (unexpected), create default timezone. 460 return *(TimeZone::createDefault()); 461 } 462 463 DateIntervalFormat::DateIntervalFormat(const Locale& locale, 464 DateIntervalInfo* dtItvInfo, 465 const UnicodeString* skeleton, 466 UErrorCode& status) 467 : fInfo(NULL), 468 fDateFormat(NULL), 469 fFromCalendar(NULL), 470 fToCalendar(NULL), 471 fDtpng(NULL) 472 { 473 if ( U_FAILURE(status) ) { 474 delete dtItvInfo; 475 return; 476 } 477 fDtpng = DateTimePatternGenerator::createInstance(locale, status); 478 SimpleDateFormat* dtfmt = createSDFPatternInstance(*skeleton, locale, 479 fDtpng, status); 480 if ( U_FAILURE(status) ) { 481 delete dtItvInfo; 482 delete fDtpng; 483 delete dtfmt; 484 return; 485 } 486 if ( dtfmt == NULL || dtItvInfo == NULL || fDtpng == NULL ) { 487 status = U_MEMORY_ALLOCATION_ERROR; 488 // safe to delete NULL 489 delete dtfmt; 490 delete dtItvInfo; 491 delete fDtpng; 492 return; 493 } 494 if ( skeleton ) { 495 fSkeleton = *skeleton; 496 } 497 fInfo = dtItvInfo; 498 fDateFormat = dtfmt; 499 if ( dtfmt->getCalendar() ) { 500 fFromCalendar = dtfmt->getCalendar()->clone(); 501 fToCalendar = dtfmt->getCalendar()->clone(); 502 } else { 503 fFromCalendar = NULL; 504 fToCalendar = NULL; 505 } 506 initializePattern(status); 507 } 508 509 510 SimpleDateFormat* U_EXPORT2 511 DateIntervalFormat::createSDFPatternInstance(const UnicodeString& skeleton, 512 const Locale& locale, 513 DateTimePatternGenerator* dtpng, 514 UErrorCode& status) 515 { 516 if ( U_FAILURE(status) ) { 517 return NULL; 518 } 519 520 const UnicodeString pattern = dtpng->getBestPattern(skeleton, status); 521 if ( U_FAILURE(status) ) { 522 return NULL; 523 } 524 SimpleDateFormat* dtfmt = new SimpleDateFormat(pattern, locale, status); 525 if ( U_FAILURE(status) ) { 526 delete dtfmt; 527 return NULL; 528 } 529 return dtfmt; 530 } 531 532 533 DateIntervalFormat* U_EXPORT2 534 DateIntervalFormat::create(const Locale& locale, 535 DateIntervalInfo* dtitvinf, 536 const UnicodeString* skeleton, 537 UErrorCode& status) { 538 DateIntervalFormat* f = new DateIntervalFormat(locale, dtitvinf, 539 skeleton, status); 540 if ( f == NULL ) { 541 status = U_MEMORY_ALLOCATION_ERROR; 542 delete dtitvinf; 543 } else if ( U_FAILURE(status) ) { 544 // safe to delete f, although nothing acutally is saved 545 delete f; 546 f = 0; 547 } 548 return f; 549 } 550 551 552 553 /** 554 * Initialize interval patterns locale to this formatter 555 * 556 * This code is a bit complicated since 557 * 1. the interval patterns saved in resource bundle files are interval 558 * patterns based on date or time only. 559 * It does not have interval patterns based on both date and time. 560 * Interval patterns on both date and time are algorithm generated. 561 * 562 * For example, it has interval patterns on skeleton "dMy" and "hm", 563 * but it does not have interval patterns on skeleton "dMyhm". 564 * 565 * The rule to genearte interval patterns for both date and time skeleton are 566 * 1) when the year, month, or day differs, concatenate the two original 567 * expressions with a separator between, 568 * For example, interval pattern from "Jan 10, 2007 10:10 am" 569 * to "Jan 11, 2007 10:10am" is 570 * "Jan 10, 2007 10:10 am - Jan 11, 2007 10:10am" 571 * 572 * 2) otherwise, present the date followed by the range expression 573 * for the time. 574 * For example, interval pattern from "Jan 10, 2007 10:10 am" 575 * to "Jan 10, 2007 11:10am" is 576 * "Jan 10, 2007 10:10 am - 11:10am" 577 * 578 * 2. even a pattern does not request a certion calendar field, 579 * the interval pattern needs to include such field if such fields are 580 * different between 2 dates. 581 * For example, a pattern/skeleton is "hm", but the interval pattern 582 * includes year, month, and date when year, month, and date differs. 583 * 584 * @param status output param set to success/failure code on exit 585 * @stable ICU 4.0 586 */ 587 void 588 DateIntervalFormat::initializePattern(UErrorCode& status) { 589 if ( U_FAILURE(status) ) { 590 return; 591 } 592 const Locale& locale = fDateFormat->getSmpFmtLocale(); 593 if ( fSkeleton.isEmpty() ) { 594 UnicodeString fullPattern; 595 fDateFormat->toPattern(fullPattern); 596 #ifdef DTITVFMT_DEBUG 597 char result[1000]; 598 char result_1[1000]; 599 char mesg[2000]; 600 fSkeleton.extract(0, fSkeleton.length(), result, "UTF-8"); 601 sprintf(mesg, "in getBestSkeleton: fSkeleton: %s; \n", result); 602 PRINTMESG(mesg) 603 #endif 604 // fSkeleton is already set by createDateIntervalInstance() 605 // or by createInstance(UnicodeString skeleton, .... ) 606 fSkeleton = fDtpng->getSkeleton(fullPattern, status); 607 if ( U_FAILURE(status) ) { 608 return; 609 } 610 } 611 612 // initialize the fIntervalPattern ordering 613 int8_t i; 614 for ( i = 0; i < DateIntervalInfo::kIPI_MAX_INDEX; ++i ) { 615 fIntervalPatterns[i].laterDateFirst = fInfo->getDefaultOrder(); 616 } 617 618 /* Check whether the skeleton is a combination of date and time. 619 * For the complication reason 1 explained above. 620 */ 621 UnicodeString dateSkeleton; 622 UnicodeString timeSkeleton; 623 UnicodeString normalizedTimeSkeleton; 624 UnicodeString normalizedDateSkeleton; 625 626 627 /* the difference between time skeleton and normalizedTimeSkeleton are: 628 * 1. (Formerly, normalized time skeleton folded 'H' to 'h'; no longer true) 629 * 2. 'a' is omitted in normalized time skeleton. 630 * 3. there is only one appearance for 'h' or 'H', 'm','v', 'z' in normalized 631 * time skeleton 632 * 633 * The difference between date skeleton and normalizedDateSkeleton are: 634 * 1. both 'y' and 'd' appear only once in normalizeDateSkeleton 635 * 2. 'E' and 'EE' are normalized into 'EEE' 636 * 3. 'MM' is normalized into 'M' 637 */ 638 getDateTimeSkeleton(fSkeleton, dateSkeleton, normalizedDateSkeleton, 639 timeSkeleton, normalizedTimeSkeleton); 640 641 #ifdef DTITVFMT_DEBUG 642 char result[1000]; 643 char result_1[1000]; 644 char mesg[2000]; 645 fSkeleton.extract(0, fSkeleton.length(), result, "UTF-8"); 646 sprintf(mesg, "in getBestSkeleton: fSkeleton: %s; \n", result); 647 PRINTMESG(mesg) 648 #endif 649 650 651 UBool found = setSeparateDateTimePtn(normalizedDateSkeleton, 652 normalizedTimeSkeleton); 653 654 if ( found == false ) { 655 // use fallback 656 // TODO: if user asks "m"(minute), but "d"(day) differ 657 if ( timeSkeleton.length() != 0 ) { 658 if ( dateSkeleton.length() == 0 ) { 659 // prefix with yMd 660 timeSkeleton.insert(0, gDateFormatSkeleton[DateFormat::kShort], -1); 661 UnicodeString pattern = fDtpng->getBestPattern(timeSkeleton, status); 662 if ( U_FAILURE(status) ) { 663 return; 664 } 665 // for fall back interval patterns, 666 // the first part of the pattern is empty, 667 // the second part of the pattern is the full-pattern 668 // should be used in fall-back. 669 setPatternInfo(UCAL_DATE, NULL, &pattern, fInfo->getDefaultOrder()); 670 setPatternInfo(UCAL_MONTH, NULL, &pattern, fInfo->getDefaultOrder()); 671 setPatternInfo(UCAL_YEAR, NULL, &pattern, fInfo->getDefaultOrder()); 672 } else { 673 // TODO: fall back 674 } 675 } else { 676 // TODO: fall back 677 } 678 return; 679 } // end of skeleton not found 680 // interval patterns for skeleton are found in resource 681 if ( timeSkeleton.length() == 0 ) { 682 // done 683 } else if ( dateSkeleton.length() == 0 ) { 684 // prefix with yMd 685 timeSkeleton.insert(0, gDateFormatSkeleton[DateFormat::kShort], -1); 686 UnicodeString pattern = fDtpng->getBestPattern(timeSkeleton, status); 687 if ( U_FAILURE(status) ) { 688 return; 689 } 690 // for fall back interval patterns, 691 // the first part of the pattern is empty, 692 // the second part of the pattern is the full-pattern 693 // should be used in fall-back. 694 setPatternInfo(UCAL_DATE, NULL, &pattern, fInfo->getDefaultOrder()); 695 setPatternInfo(UCAL_MONTH, NULL, &pattern, fInfo->getDefaultOrder()); 696 setPatternInfo(UCAL_YEAR, NULL, &pattern, fInfo->getDefaultOrder()); 697 } else { 698 /* if both present, 699 * 1) when the year, month, or day differs, 700 * concatenate the two original expressions with a separator between, 701 * 2) otherwise, present the date followed by the 702 * range expression for the time. 703 */ 704 /* 705 * 1) when the year, month, or day differs, 706 * concatenate the two original expressions with a separator between, 707 */ 708 // if field exists, use fall back 709 UnicodeString skeleton = fSkeleton; 710 if ( !fieldExistsInSkeleton(UCAL_DATE, dateSkeleton) ) { 711 // prefix skeleton with 'd' 712 skeleton.insert(0, LOW_D); 713 setFallbackPattern(UCAL_DATE, skeleton, status); 714 } 715 if ( !fieldExistsInSkeleton(UCAL_MONTH, dateSkeleton) ) { 716 // then prefix skeleton with 'M' 717 skeleton.insert(0, CAP_M); 718 setFallbackPattern(UCAL_MONTH, skeleton, status); 719 } 720 if ( !fieldExistsInSkeleton(UCAL_YEAR, dateSkeleton) ) { 721 // then prefix skeleton with 'y' 722 skeleton.insert(0, LOW_Y); 723 setFallbackPattern(UCAL_YEAR, skeleton, status); 724 } 725 726 /* 727 * 2) otherwise, present the date followed by the 728 * range expression for the time. 729 */ 730 // Need the Date/Time pattern for concatnation the date with 731 // the time interval. 732 // The date/time pattern ( such as {0} {1} ) is saved in 733 // calendar, that is why need to get the CalendarData here. 734 CalendarData* calData = new CalendarData(locale, NULL, status); 735 736 if ( U_FAILURE(status) ) { 737 delete calData; 738 return; 739 } 740 741 if ( calData == NULL ) { 742 status = U_MEMORY_ALLOCATION_ERROR; 743 return; 744 } 745 746 const UResourceBundle* dateTimePatternsRes = calData->getByKey( 747 gDateTimePatternsTag, status); 748 int32_t dateTimeFormatLength; 749 const UChar* dateTimeFormat = ures_getStringByIndex( 750 dateTimePatternsRes, 751 (int32_t)DateFormat::kDateTime, 752 &dateTimeFormatLength, &status); 753 if ( U_FAILURE(status) ) { 754 return; 755 } 756 757 UnicodeString datePattern = fDtpng->getBestPattern(dateSkeleton, status); 758 759 concatSingleDate2TimeInterval(dateTimeFormat, dateTimeFormatLength, 760 datePattern, UCAL_AM_PM, status); 761 concatSingleDate2TimeInterval(dateTimeFormat, dateTimeFormatLength, 762 datePattern, UCAL_HOUR, status); 763 concatSingleDate2TimeInterval(dateTimeFormat, dateTimeFormatLength, 764 datePattern, UCAL_MINUTE, status); 765 delete calData; 766 } 767 } 768 769 770 771 void U_EXPORT2 772 DateIntervalFormat::getDateTimeSkeleton(const UnicodeString& skeleton, 773 UnicodeString& dateSkeleton, 774 UnicodeString& normalizedDateSkeleton, 775 UnicodeString& timeSkeleton, 776 UnicodeString& normalizedTimeSkeleton) { 777 // dateSkeleton follows the sequence of y*M*E*d* 778 // timeSkeleton follows the sequence of hm*[v|z]? 779 int32_t ECount = 0; 780 int32_t dCount = 0; 781 int32_t MCount = 0; 782 int32_t yCount = 0; 783 int32_t hCount = 0; 784 int32_t HCount = 0; 785 int32_t mCount = 0; 786 int32_t vCount = 0; 787 int32_t zCount = 0; 788 int32_t i; 789 790 for (i = 0; i < skeleton.length(); ++i) { 791 UChar ch = skeleton[i]; 792 switch ( ch ) { 793 case CAP_E: 794 dateSkeleton.append(ch); 795 ++ECount; 796 break; 797 case LOW_D: 798 dateSkeleton.append(ch); 799 ++dCount; 800 break; 801 case CAP_M: 802 dateSkeleton.append(ch); 803 ++MCount; 804 break; 805 case LOW_Y: 806 dateSkeleton.append(ch); 807 ++yCount; 808 break; 809 case CAP_G: 810 case CAP_Y: 811 case LOW_U: 812 case CAP_Q: 813 case LOW_Q: 814 case CAP_L: 815 case LOW_L: 816 case CAP_W: 817 case LOW_W: 818 case CAP_D: 819 case CAP_F: 820 case LOW_G: 821 case LOW_E: 822 case LOW_C: 823 normalizedDateSkeleton.append(ch); 824 dateSkeleton.append(ch); 825 break; 826 case LOW_A: 827 // 'a' is implicitly handled 828 timeSkeleton.append(ch); 829 break; 830 case LOW_H: 831 timeSkeleton.append(ch); 832 ++hCount; 833 break; 834 case CAP_H: 835 timeSkeleton.append(ch); 836 ++HCount; 837 break; 838 case LOW_M: 839 timeSkeleton.append(ch); 840 ++mCount; 841 break; 842 case LOW_Z: 843 ++zCount; 844 timeSkeleton.append(ch); 845 break; 846 case LOW_V: 847 ++vCount; 848 timeSkeleton.append(ch); 849 break; 850 case CAP_V: 851 case CAP_Z: 852 case LOW_K: 853 case CAP_K: 854 case LOW_J: 855 case LOW_S: 856 case CAP_S: 857 case CAP_A: 858 timeSkeleton.append(ch); 859 normalizedTimeSkeleton.append(ch); 860 break; 861 } 862 } 863 864 /* generate normalized form for date*/ 865 if ( yCount != 0 ) { 866 normalizedDateSkeleton.append(LOW_Y); 867 } 868 if ( MCount != 0 ) { 869 if ( MCount < 3 ) { 870 normalizedDateSkeleton.append(CAP_M); 871 } else { 872 int32_t i; 873 for ( i = 0; i < MCount && i < MAX_M_COUNT; ++i ) { 874 normalizedDateSkeleton.append(CAP_M); 875 } 876 } 877 } 878 if ( ECount != 0 ) { 879 if ( ECount <= 3 ) { 880 normalizedDateSkeleton.append(CAP_E); 881 } else { 882 int32_t i; 883 for ( i = 0; i < ECount && i < MAX_E_COUNT; ++i ) { 884 normalizedDateSkeleton.append(CAP_E); 885 } 886 } 887 } 888 if ( dCount != 0 ) { 889 normalizedDateSkeleton.append(LOW_D); 890 } 891 892 /* generate normalized form for time */ 893 if ( HCount != 0 ) { 894 normalizedTimeSkeleton.append(CAP_H); 895 } 896 else if ( hCount != 0 ) { 897 normalizedTimeSkeleton.append(LOW_H); 898 } 899 if ( mCount != 0 ) { 900 normalizedTimeSkeleton.append(LOW_M); 901 } 902 if ( zCount != 0 ) { 903 normalizedTimeSkeleton.append(LOW_Z); 904 } 905 if ( vCount != 0 ) { 906 normalizedTimeSkeleton.append(LOW_V); 907 } 908 } 909 910 911 /** 912 * Generate date or time interval pattern from resource, 913 * and set them into the interval pattern locale to this formatter. 914 * 915 * It needs to handle the following: 916 * 1. need to adjust field width. 917 * For example, the interval patterns saved in DateIntervalInfo 918 * includes "dMMMy", but not "dMMMMy". 919 * Need to get interval patterns for dMMMMy from dMMMy. 920 * Another example, the interval patterns saved in DateIntervalInfo 921 * includes "hmv", but not "hmz". 922 * Need to get interval patterns for "hmz' from 'hmv' 923 * 924 * 2. there might be no pattern for 'y' differ for skeleton "Md", 925 * in order to get interval patterns for 'y' differ, 926 * need to look for it from skeleton 'yMd' 927 * 928 * @param dateSkeleton normalized date skeleton 929 * @param timeSkeleton normalized time skeleton 930 * @return whether the resource is found for the skeleton. 931 * TRUE if interval pattern found for the skeleton, 932 * FALSE otherwise. 933 * @stable ICU 4.0 934 */ 935 UBool 936 DateIntervalFormat::setSeparateDateTimePtn( 937 const UnicodeString& dateSkeleton, 938 const UnicodeString& timeSkeleton) { 939 const UnicodeString* skeleton; 940 // if both date and time skeleton present, 941 // the final interval pattern might include time interval patterns 942 // ( when, am_pm, hour, minute differ ), 943 // but not date interval patterns ( when year, month, day differ ). 944 // For year/month/day differ, it falls back to fall-back pattern. 945 if ( timeSkeleton.length() != 0 ) { 946 skeleton = &timeSkeleton; 947 } else { 948 skeleton = &dateSkeleton; 949 } 950 951 /* interval patterns for skeleton "dMMMy" (but not "dMMMMy") 952 * are defined in resource, 953 * interval patterns for skeleton "dMMMMy" are calculated by 954 * 1. get the best match skeleton for "dMMMMy", which is "dMMMy" 955 * 2. get the interval patterns for "dMMMy", 956 * 3. extend "MMM" to "MMMM" in above interval patterns for "dMMMMy" 957 * getBestSkeleton() is step 1. 958 */ 959 // best skeleton, and the difference information 960 int8_t differenceInfo = 0; 961 const UnicodeString* bestSkeleton = fInfo->getBestSkeleton(*skeleton, 962 differenceInfo); 963 /* best skeleton could be NULL. 964 For example: in "ca" resource file, 965 interval format is defined as following 966 intervalFormats{ 967 fallback{"{0} - {1}"} 968 } 969 there is no skeletons/interval patterns defined, 970 and the best skeleton match could be NULL 971 */ 972 if ( bestSkeleton == NULL ) { 973 return false; 974 } 975 976 // difference: 977 // 0 means the best matched skeleton is the same as input skeleton 978 // 1 means the fields are the same, but field width are different 979 // 2 means the only difference between fields are v/z, 980 // -1 means there are other fields difference 981 if ( differenceInfo == -1 ) { 982 // skeleton has different fields, not only v/z difference 983 return false; 984 } 985 986 if ( timeSkeleton.length() == 0 ) { 987 UnicodeString extendedSkeleton; 988 UnicodeString extendedBestSkeleton; 989 // only has date skeleton 990 setIntervalPattern(UCAL_DATE, skeleton, bestSkeleton, differenceInfo, 991 &extendedSkeleton, &extendedBestSkeleton); 992 993 UBool extended = setIntervalPattern(UCAL_MONTH, skeleton, bestSkeleton, 994 differenceInfo, 995 &extendedSkeleton, &extendedBestSkeleton); 996 997 if ( extended ) { 998 bestSkeleton = &extendedBestSkeleton; 999 skeleton = &extendedSkeleton; 1000 } 1001 setIntervalPattern(UCAL_YEAR, skeleton, bestSkeleton, differenceInfo, 1002 &extendedSkeleton, &extendedBestSkeleton); 1003 } else { 1004 setIntervalPattern(UCAL_MINUTE, skeleton, bestSkeleton, differenceInfo); 1005 setIntervalPattern(UCAL_HOUR, skeleton, bestSkeleton, differenceInfo); 1006 setIntervalPattern(UCAL_AM_PM, skeleton, bestSkeleton, differenceInfo); 1007 } 1008 return true; 1009 } 1010 1011 1012 1013 void 1014 DateIntervalFormat::setFallbackPattern(UCalendarDateFields field, 1015 const UnicodeString& skeleton, 1016 UErrorCode& status) { 1017 if ( U_FAILURE(status) ) { 1018 return; 1019 } 1020 UnicodeString pattern = fDtpng->getBestPattern(skeleton, status); 1021 if ( U_FAILURE(status) ) { 1022 return; 1023 } 1024 setPatternInfo(field, NULL, &pattern, fInfo->getDefaultOrder()); 1025 } 1026 1027 1028 1029 1030 void 1031 DateIntervalFormat::setPatternInfo(UCalendarDateFields field, 1032 const UnicodeString* firstPart, 1033 const UnicodeString* secondPart, 1034 UBool laterDateFirst) { 1035 // for fall back interval patterns, 1036 // the first part of the pattern is empty, 1037 // the second part of the pattern is the full-pattern 1038 // should be used in fall-back. 1039 UErrorCode status = U_ZERO_ERROR; 1040 // following should not set any wrong status. 1041 int32_t itvPtnIndex = DateIntervalInfo::calendarFieldToIntervalIndex(field, 1042 status); 1043 if ( U_FAILURE(status) ) { 1044 return; 1045 } 1046 PatternInfo& ptn = fIntervalPatterns[itvPtnIndex]; 1047 if ( firstPart ) { 1048 ptn.firstPart = *firstPart; 1049 } 1050 if ( secondPart ) { 1051 ptn.secondPart = *secondPart; 1052 } 1053 ptn.laterDateFirst = laterDateFirst; 1054 } 1055 1056 void 1057 DateIntervalFormat::setIntervalPattern(UCalendarDateFields field, 1058 const UnicodeString& intervalPattern) { 1059 UBool order = fInfo->getDefaultOrder(); 1060 setIntervalPattern(field, intervalPattern, order); 1061 } 1062 1063 1064 void 1065 DateIntervalFormat::setIntervalPattern(UCalendarDateFields field, 1066 const UnicodeString& intervalPattern, 1067 UBool laterDateFirst) { 1068 const UnicodeString* pattern = &intervalPattern; 1069 UBool order = laterDateFirst; 1070 // check for "latestFirst:" or "earliestFirst:" prefix 1071 int8_t prefixLength = sizeof(gLaterFirstPrefix)/sizeof(gLaterFirstPrefix[0]); 1072 int8_t earliestFirstLength = sizeof(gEarlierFirstPrefix)/sizeof(gEarlierFirstPrefix[0]); 1073 UnicodeString realPattern; 1074 if ( intervalPattern.startsWith(gLaterFirstPrefix, prefixLength) ) { 1075 order = true; 1076 intervalPattern.extract(prefixLength, 1077 intervalPattern.length() - prefixLength, 1078 realPattern); 1079 pattern = &realPattern; 1080 } else if ( intervalPattern.startsWith(gEarlierFirstPrefix, 1081 earliestFirstLength) ) { 1082 order = false; 1083 intervalPattern.extract(earliestFirstLength, 1084 intervalPattern.length() - earliestFirstLength, 1085 realPattern); 1086 pattern = &realPattern; 1087 } 1088 1089 int32_t splitPoint = splitPatternInto2Part(*pattern); 1090 1091 UnicodeString firstPart; 1092 UnicodeString secondPart; 1093 pattern->extract(0, splitPoint, firstPart); 1094 if ( splitPoint < pattern->length() ) { 1095 pattern->extract(splitPoint, pattern->length()-splitPoint, secondPart); 1096 } 1097 setPatternInfo(field, &firstPart, &secondPart, order); 1098 } 1099 1100 1101 1102 1103 /** 1104 * Generate interval pattern from existing resource 1105 * 1106 * It not only save the interval patterns, 1107 * but also return the extended skeleton and its best match skeleton. 1108 * 1109 * @param field largest different calendar field 1110 * @param skeleton skeleton 1111 * @param bestSkeleton the best match skeleton which has interval pattern 1112 * defined in resource 1113 * @param differenceInfo the difference between skeleton and best skeleton 1114 * 0 means the best matched skeleton is the same as input skeleton 1115 * 1 means the fields are the same, but field width are different 1116 * 2 means the only difference between fields are v/z, 1117 * -1 means there are other fields difference 1118 * 1119 * @param extendedSkeleton extended skeleton 1120 * @param extendedBestSkeleton extended best match skeleton 1121 * @return whether the interval pattern is found 1122 * through extending skeleton or not. 1123 * TRUE if interval pattern is found by 1124 * extending skeleton, FALSE otherwise. 1125 * @stable ICU 4.0 1126 */ 1127 UBool 1128 DateIntervalFormat::setIntervalPattern(UCalendarDateFields field, 1129 const UnicodeString* skeleton, 1130 const UnicodeString* bestSkeleton, 1131 int8_t differenceInfo, 1132 UnicodeString* extendedSkeleton, 1133 UnicodeString* extendedBestSkeleton) { 1134 UErrorCode status = U_ZERO_ERROR; 1135 // following getIntervalPattern() should not generate error status 1136 UnicodeString pattern; 1137 fInfo->getIntervalPattern(*bestSkeleton, field, pattern, status); 1138 if ( pattern.isEmpty() ) { 1139 // single date 1140 if ( SimpleDateFormat::isFieldUnitIgnored(*bestSkeleton, field) ) { 1141 // do nothing, format will handle it 1142 return false; 1143 } 1144 1145 // for 24 hour system, interval patterns in resource file 1146 // might not include pattern when am_pm differ, 1147 // which should be the same as hour differ. 1148 // add it here for simplicity 1149 if ( field == UCAL_AM_PM ) { 1150 fInfo->getIntervalPattern(*bestSkeleton, UCAL_HOUR, pattern,status); 1151 if ( !pattern.isEmpty() ) { 1152 setIntervalPattern(field, pattern); 1153 } 1154 return false; 1155 } 1156 // else, looking for pattern when 'y' differ for 'dMMMM' skeleton, 1157 // first, get best match pattern "MMMd", 1158 // since there is no pattern for 'y' differs for skeleton 'MMMd', 1159 // need to look for it from skeleton 'yMMMd', 1160 // if found, adjust field width in interval pattern from 1161 // "MMM" to "MMMM". 1162 UChar fieldLetter = fgCalendarFieldToPatternLetter[field]; 1163 if ( extendedSkeleton ) { 1164 *extendedSkeleton = *skeleton; 1165 *extendedBestSkeleton = *bestSkeleton; 1166 extendedSkeleton->insert(0, fieldLetter); 1167 extendedBestSkeleton->insert(0, fieldLetter); 1168 // for example, looking for patterns when 'y' differ for 1169 // skeleton "MMMM". 1170 fInfo->getIntervalPattern(*extendedBestSkeleton,field,pattern,status); 1171 if ( pattern.isEmpty() && differenceInfo == 0 ) { 1172 // if there is no skeleton "yMMMM" defined, 1173 // look for the best match skeleton, for example: "yMMM" 1174 const UnicodeString* tmpBest = fInfo->getBestSkeleton( 1175 *extendedBestSkeleton, differenceInfo); 1176 if ( tmpBest != 0 && differenceInfo != -1 ) { 1177 fInfo->getIntervalPattern(*tmpBest, field, pattern, status); 1178 bestSkeleton = tmpBest; 1179 } 1180 } 1181 } 1182 } 1183 if ( !pattern.isEmpty() ) { 1184 if ( differenceInfo != 0 ) { 1185 UnicodeString adjustIntervalPattern; 1186 adjustFieldWidth(*skeleton, *bestSkeleton, pattern, differenceInfo, 1187 adjustIntervalPattern); 1188 setIntervalPattern(field, adjustIntervalPattern); 1189 } else { 1190 setIntervalPattern(field, pattern); 1191 } 1192 if ( extendedSkeleton && !extendedSkeleton->isEmpty() ) { 1193 return TRUE; 1194 } 1195 } 1196 return FALSE; 1197 } 1198 1199 1200 1201 int32_t U_EXPORT2 1202 DateIntervalFormat::splitPatternInto2Part(const UnicodeString& intervalPattern) { 1203 UBool inQuote = false; 1204 UChar prevCh = 0; 1205 int32_t count = 0; 1206 1207 /* repeatedPattern used to record whether a pattern has already seen. 1208 It is a pattern applies to first calendar if it is first time seen, 1209 otherwise, it is a pattern applies to the second calendar 1210 */ 1211 UBool patternRepeated[] = 1212 { 1213 // A B C D E F G H I J K L M N O 1214 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1215 // P Q R S T U V W X Y Z 1216 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1217 // a b c d e f g h i j k l m n o 1218 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1219 // p q r s t u v w x y z 1220 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 1221 }; 1222 1223 int8_t PATTERN_CHAR_BASE = 0x41; 1224 1225 /* loop through the pattern string character by character looking for 1226 * the first repeated pattern letter, which breaks the interval pattern 1227 * into 2 parts. 1228 */ 1229 int32_t i; 1230 UBool foundRepetition = false; 1231 for (i = 0; i < intervalPattern.length(); ++i) { 1232 UChar ch = intervalPattern.charAt(i); 1233 1234 if (ch != prevCh && count > 0) { 1235 // check the repeativeness of pattern letter 1236 UBool repeated = patternRepeated[(int)(prevCh - PATTERN_CHAR_BASE)]; 1237 if ( repeated == FALSE ) { 1238 patternRepeated[prevCh - PATTERN_CHAR_BASE] = TRUE; 1239 } else { 1240 foundRepetition = true; 1241 break; 1242 } 1243 count = 0; 1244 } 1245 if (ch == '\'') { 1246 // Consecutive single quotes are a single quote literal, 1247 // either outside of quotes or between quotes 1248 if ((i+1) < intervalPattern.length() && 1249 intervalPattern.charAt(i+1) == '\'') { 1250 ++i; 1251 } else { 1252 inQuote = ! inQuote; 1253 } 1254 } 1255 else if (!inQuote && ((ch >= 0x0061 /*'a'*/ && ch <= 0x007A /*'z'*/) 1256 || (ch >= 0x0041 /*'A'*/ && ch <= 0x005A /*'Z'*/))) { 1257 // ch is a date-time pattern character 1258 prevCh = ch; 1259 ++count; 1260 } 1261 } 1262 // check last pattern char, distinguish 1263 // "dd MM" ( no repetition ), 1264 // "d-d"(last char repeated ), and 1265 // "d-d MM" ( repetition found ) 1266 if ( count > 0 && foundRepetition == FALSE ) { 1267 if ( patternRepeated[(int)(prevCh - PATTERN_CHAR_BASE)] == FALSE ) { 1268 count = 0; 1269 } 1270 } 1271 return (i - count); 1272 } 1273 1274 1275 1276 UnicodeString& 1277 DateIntervalFormat::fallbackFormat(Calendar& fromCalendar, 1278 Calendar& toCalendar, 1279 UnicodeString& appendTo, 1280 FieldPosition& pos, 1281 UErrorCode& status) const { 1282 if ( U_FAILURE(status) ) { 1283 return appendTo; 1284 } 1285 // the fall back 1286 // no need delete earlierDate and laterDate since they are adopted 1287 UnicodeString* earlierDate = new UnicodeString(); 1288 *earlierDate = fDateFormat->format(fromCalendar, *earlierDate, pos); 1289 UnicodeString* laterDate = new UnicodeString(); 1290 *laterDate = fDateFormat->format(toCalendar, *laterDate, pos); 1291 UnicodeString fallbackPattern; 1292 fInfo->getFallbackIntervalPattern(fallbackPattern); 1293 Formattable fmtArray[2]; 1294 fmtArray[0].adoptString(earlierDate); 1295 fmtArray[1].adoptString(laterDate); 1296 1297 UnicodeString fallback; 1298 MessageFormat::format(fallbackPattern, fmtArray, 2, fallback, status); 1299 if ( U_SUCCESS(status) ) { 1300 appendTo.append(fallback); 1301 } 1302 return appendTo; 1303 } 1304 1305 1306 1307 1308 UBool U_EXPORT2 1309 DateIntervalFormat::fieldExistsInSkeleton(UCalendarDateFields field, 1310 const UnicodeString& skeleton) 1311 { 1312 const UChar fieldChar = fgCalendarFieldToPatternLetter[field]; 1313 return ( (skeleton.indexOf(fieldChar) == -1)?FALSE:TRUE ) ; 1314 } 1315 1316 1317 1318 void U_EXPORT2 1319 DateIntervalFormat::adjustFieldWidth(const UnicodeString& inputSkeleton, 1320 const UnicodeString& bestMatchSkeleton, 1321 const UnicodeString& bestIntervalPattern, 1322 int8_t differenceInfo, 1323 UnicodeString& adjustedPtn) { 1324 adjustedPtn = bestIntervalPattern; 1325 int32_t inputSkeletonFieldWidth[] = 1326 { 1327 // A B C D E F G H I J K L M N O 1328 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1329 // P Q R S T U V W X Y Z 1330 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1331 // a b c d e f g h i j k l m n o 1332 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1333 // p q r s t u v w x y z 1334 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 1335 }; 1336 1337 int32_t bestMatchSkeletonFieldWidth[] = 1338 { 1339 // A B C D E F G H I J K L M N O 1340 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1341 // P Q R S T U V W X Y Z 1342 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1343 // a b c d e f g h i j k l m n o 1344 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1345 // p q r s t u v w x y z 1346 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 1347 }; 1348 1349 DateIntervalInfo::parseSkeleton(inputSkeleton, inputSkeletonFieldWidth); 1350 DateIntervalInfo::parseSkeleton(bestMatchSkeleton, bestMatchSkeletonFieldWidth); 1351 if ( differenceInfo == 2 ) { 1352 adjustedPtn.findAndReplace(UnicodeString((UChar)0x76 /* v */), 1353 UnicodeString((UChar)0x7a /* z */)); 1354 } 1355 1356 UBool inQuote = false; 1357 UChar prevCh = 0; 1358 int32_t count = 0; 1359 1360 const int8_t PATTERN_CHAR_BASE = 0x41; 1361 1362 // loop through the pattern string character by character 1363 int32_t adjustedPtnLength = adjustedPtn.length(); 1364 int32_t i; 1365 for (i = 0; i < adjustedPtnLength; ++i) { 1366 UChar ch = adjustedPtn.charAt(i); 1367 if (ch != prevCh && count > 0) { 1368 // check the repeativeness of pattern letter 1369 UChar skeletonChar = prevCh; 1370 if ( skeletonChar == CAP_L ) { 1371 // there is no "L" (always be "M") in skeleton, 1372 // but there is "L" in pattern. 1373 // for skeleton "M+", the pattern might be "...L..." 1374 skeletonChar = CAP_M; 1375 } 1376 int32_t fieldCount = bestMatchSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)]; 1377 int32_t inputFieldCount = inputSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)]; 1378 if ( fieldCount == count && inputFieldCount > fieldCount ) { 1379 count = inputFieldCount - fieldCount; 1380 int32_t j; 1381 for ( j = 0; j < count; ++j ) { 1382 adjustedPtn.insert(i, prevCh); 1383 } 1384 i += count; 1385 adjustedPtnLength += count; 1386 } 1387 count = 0; 1388 } 1389 if (ch == '\'') { 1390 // Consecutive single quotes are a single quote literal, 1391 // either outside of quotes or between quotes 1392 if ((i+1) < adjustedPtn.length() && adjustedPtn.charAt(i+1) == '\'') { 1393 ++i; 1394 } else { 1395 inQuote = ! inQuote; 1396 } 1397 } 1398 else if ( ! inQuote && ((ch >= 0x0061 /*'a'*/ && ch <= 0x007A /*'z'*/) 1399 || (ch >= 0x0041 /*'A'*/ && ch <= 0x005A /*'Z'*/))) { 1400 // ch is a date-time pattern character 1401 prevCh = ch; 1402 ++count; 1403 } 1404 } 1405 if ( count > 0 ) { 1406 // last item 1407 // check the repeativeness of pattern letter 1408 UChar skeletonChar = prevCh; 1409 if ( skeletonChar == CAP_L ) { 1410 // there is no "L" (always be "M") in skeleton, 1411 // but there is "L" in pattern. 1412 // for skeleton "M+", the pattern might be "...L..." 1413 skeletonChar = CAP_M; 1414 } 1415 int32_t fieldCount = bestMatchSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)]; 1416 int32_t inputFieldCount = inputSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)]; 1417 if ( fieldCount == count && inputFieldCount > fieldCount ) { 1418 count = inputFieldCount - fieldCount; 1419 int32_t j; 1420 for ( j = 0; j < count; ++j ) { 1421 adjustedPtn.append(prevCh); 1422 } 1423 } 1424 } 1425 } 1426 1427 1428 1429 void 1430 DateIntervalFormat::concatSingleDate2TimeInterval(const UChar* format, 1431 int32_t formatLen, 1432 const UnicodeString& datePattern, 1433 UCalendarDateFields field, 1434 UErrorCode& status) { 1435 // following should not set wrong status 1436 int32_t itvPtnIndex = DateIntervalInfo::calendarFieldToIntervalIndex(field, 1437 status); 1438 if ( U_FAILURE(status) ) { 1439 return; 1440 } 1441 PatternInfo& timeItvPtnInfo = fIntervalPatterns[itvPtnIndex]; 1442 if ( !timeItvPtnInfo.firstPart.isEmpty() ) { 1443 // UnicodeString allocated here is adopted, so no need to delete 1444 UnicodeString* timeIntervalPattern = new UnicodeString(timeItvPtnInfo.firstPart); 1445 timeIntervalPattern->append(timeItvPtnInfo.secondPart); 1446 UnicodeString* dateStr = new UnicodeString(datePattern); 1447 Formattable fmtArray[2]; 1448 fmtArray[0].adoptString(timeIntervalPattern); 1449 fmtArray[1].adoptString(dateStr); 1450 UnicodeString combinedPattern; 1451 MessageFormat::format(UnicodeString(TRUE, format, formatLen), 1452 fmtArray, 2, combinedPattern, status); 1453 if ( U_FAILURE(status) ) { 1454 return; 1455 } 1456 setIntervalPattern(field, combinedPattern, timeItvPtnInfo.laterDateFirst); 1457 } 1458 // else: fall back 1459 // it should not happen if the interval format defined is valid 1460 } 1461 1462 1463 1464 const UChar 1465 DateIntervalFormat::fgCalendarFieldToPatternLetter[] = 1466 { 1467 /*GyM*/ CAP_G, LOW_Y, CAP_M, 1468 /*wWd*/ LOW_W, CAP_W, LOW_D, 1469 /*DEF*/ CAP_D, CAP_E, CAP_F, 1470 /*ahH*/ LOW_A, LOW_H, CAP_H, 1471 /*m..*/ LOW_M, 1472 }; 1473 1474 1475 U_NAMESPACE_END 1476 1477 #endif 1478
