1 /******************************************************************************* 2 * Copyright (C) 2008-2010, International Business Machines Corporation and 3 * others. All Rights Reserved. 4 ******************************************************************************* 5 * 6 * File DTITVFMT.CPP 7 * 8 ******************************************************************************* 9 */ 10 11 #include "unicode/utypeinfo.h" // 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 DateIntervalFormat::DateIntervalFormat(const Locale& locale, 420 DateIntervalInfo* dtItvInfo, 421 const UnicodeString* skeleton, 422 UErrorCode& status) 423 : fInfo(NULL), 424 fDateFormat(NULL), 425 fFromCalendar(NULL), 426 fToCalendar(NULL), 427 fDtpng(NULL) 428 { 429 if ( U_FAILURE(status) ) { 430 delete dtItvInfo; 431 return; 432 } 433 fDtpng = DateTimePatternGenerator::createInstance(locale, status); 434 SimpleDateFormat* dtfmt = createSDFPatternInstance(*skeleton, locale, 435 fDtpng, status); 436 if ( U_FAILURE(status) ) { 437 delete dtItvInfo; 438 delete fDtpng; 439 delete dtfmt; 440 return; 441 } 442 if ( dtfmt == NULL || dtItvInfo == NULL || fDtpng == NULL ) { 443 status = U_MEMORY_ALLOCATION_ERROR; 444 // safe to delete NULL 445 delete dtfmt; 446 delete dtItvInfo; 447 delete fDtpng; 448 return; 449 } 450 if ( skeleton ) { 451 fSkeleton = *skeleton; 452 } 453 fInfo = dtItvInfo; 454 fDateFormat = dtfmt; 455 if ( dtfmt->getCalendar() ) { 456 fFromCalendar = dtfmt->getCalendar()->clone(); 457 fToCalendar = dtfmt->getCalendar()->clone(); 458 } else { 459 fFromCalendar = NULL; 460 fToCalendar = NULL; 461 } 462 initializePattern(status); 463 } 464 465 466 SimpleDateFormat* U_EXPORT2 467 DateIntervalFormat::createSDFPatternInstance(const UnicodeString& skeleton, 468 const Locale& locale, 469 DateTimePatternGenerator* dtpng, 470 UErrorCode& status) 471 { 472 if ( U_FAILURE(status) ) { 473 return NULL; 474 } 475 476 const UnicodeString pattern = dtpng->getBestPattern(skeleton, status); 477 if ( U_FAILURE(status) ) { 478 return NULL; 479 } 480 SimpleDateFormat* dtfmt = new SimpleDateFormat(pattern, locale, status); 481 if ( U_FAILURE(status) ) { 482 delete dtfmt; 483 return NULL; 484 } 485 return dtfmt; 486 } 487 488 489 DateIntervalFormat* U_EXPORT2 490 DateIntervalFormat::create(const Locale& locale, 491 DateIntervalInfo* dtitvinf, 492 const UnicodeString* skeleton, 493 UErrorCode& status) { 494 DateIntervalFormat* f = new DateIntervalFormat(locale, dtitvinf, 495 skeleton, status); 496 if ( f == NULL ) { 497 status = U_MEMORY_ALLOCATION_ERROR; 498 delete dtitvinf; 499 } else if ( U_FAILURE(status) ) { 500 // safe to delete f, although nothing acutally is saved 501 delete f; 502 f = 0; 503 } 504 return f; 505 } 506 507 508 509 /** 510 * Initialize interval patterns locale to this formatter 511 * 512 * This code is a bit complicated since 513 * 1. the interval patterns saved in resource bundle files are interval 514 * patterns based on date or time only. 515 * It does not have interval patterns based on both date and time. 516 * Interval patterns on both date and time are algorithm generated. 517 * 518 * For example, it has interval patterns on skeleton "dMy" and "hm", 519 * but it does not have interval patterns on skeleton "dMyhm". 520 * 521 * The rule to genearte interval patterns for both date and time skeleton are 522 * 1) when the year, month, or day differs, concatenate the two original 523 * expressions with a separator between, 524 * For example, interval pattern from "Jan 10, 2007 10:10 am" 525 * to "Jan 11, 2007 10:10am" is 526 * "Jan 10, 2007 10:10 am - Jan 11, 2007 10:10am" 527 * 528 * 2) otherwise, present the date followed by the range expression 529 * for the time. 530 * For example, interval pattern from "Jan 10, 2007 10:10 am" 531 * to "Jan 10, 2007 11:10am" is 532 * "Jan 10, 2007 10:10 am - 11:10am" 533 * 534 * 2. even a pattern does not request a certion calendar field, 535 * the interval pattern needs to include such field if such fields are 536 * different between 2 dates. 537 * For example, a pattern/skeleton is "hm", but the interval pattern 538 * includes year, month, and date when year, month, and date differs. 539 * 540 * @param status output param set to success/failure code on exit 541 * @stable ICU 4.0 542 */ 543 void 544 DateIntervalFormat::initializePattern(UErrorCode& status) { 545 if ( U_FAILURE(status) ) { 546 return; 547 } 548 const Locale& locale = fDateFormat->getSmpFmtLocale(); 549 if ( fSkeleton.isEmpty() ) { 550 UnicodeString fullPattern; 551 fDateFormat->toPattern(fullPattern); 552 #ifdef DTITVFMT_DEBUG 553 char result[1000]; 554 char result_1[1000]; 555 char mesg[2000]; 556 fSkeleton.extract(0, fSkeleton.length(), result, "UTF-8"); 557 sprintf(mesg, "in getBestSkeleton: fSkeleton: %s; \n", result); 558 PRINTMESG(mesg) 559 #endif 560 // fSkeleton is already set by createDateIntervalInstance() 561 // or by createInstance(UnicodeString skeleton, .... ) 562 fSkeleton = fDtpng->getSkeleton(fullPattern, status); 563 if ( U_FAILURE(status) ) { 564 return; 565 } 566 } 567 568 // initialize the fIntervalPattern ordering 569 int8_t i; 570 for ( i = 0; i < DateIntervalInfo::kIPI_MAX_INDEX; ++i ) { 571 fIntervalPatterns[i].laterDateFirst = fInfo->getDefaultOrder(); 572 } 573 574 /* Check whether the skeleton is a combination of date and time. 575 * For the complication reason 1 explained above. 576 */ 577 UnicodeString dateSkeleton; 578 UnicodeString timeSkeleton; 579 UnicodeString normalizedTimeSkeleton; 580 UnicodeString normalizedDateSkeleton; 581 582 583 /* the difference between time skeleton and normalizedTimeSkeleton are: 584 * 1. (Formerly, normalized time skeleton folded 'H' to 'h'; no longer true) 585 * 2. 'a' is omitted in normalized time skeleton. 586 * 3. there is only one appearance for 'h' or 'H', 'm','v', 'z' in normalized 587 * time skeleton 588 * 589 * The difference between date skeleton and normalizedDateSkeleton are: 590 * 1. both 'y' and 'd' appear only once in normalizeDateSkeleton 591 * 2. 'E' and 'EE' are normalized into 'EEE' 592 * 3. 'MM' is normalized into 'M' 593 */ 594 getDateTimeSkeleton(fSkeleton, dateSkeleton, normalizedDateSkeleton, 595 timeSkeleton, normalizedTimeSkeleton); 596 597 #ifdef DTITVFMT_DEBUG 598 char result[1000]; 599 char result_1[1000]; 600 char mesg[2000]; 601 fSkeleton.extract(0, fSkeleton.length(), result, "UTF-8"); 602 sprintf(mesg, "in getBestSkeleton: fSkeleton: %s; \n", result); 603 PRINTMESG(mesg) 604 #endif 605 606 607 UBool found = setSeparateDateTimePtn(normalizedDateSkeleton, 608 normalizedTimeSkeleton); 609 610 if ( found == false ) { 611 // use fallback 612 // TODO: if user asks "m"(minute), but "d"(day) differ 613 if ( timeSkeleton.length() != 0 ) { 614 if ( dateSkeleton.length() == 0 ) { 615 // prefix with yMd 616 timeSkeleton.insert(0, gDateFormatSkeleton[DateFormat::kShort]); 617 UnicodeString pattern = fDtpng->getBestPattern(timeSkeleton, status); 618 if ( U_FAILURE(status) ) { 619 return; 620 } 621 // for fall back interval patterns, 622 // the first part of the pattern is empty, 623 // the second part of the pattern is the full-pattern 624 // should be used in fall-back. 625 setPatternInfo(UCAL_DATE, NULL, &pattern, fInfo->getDefaultOrder()); 626 setPatternInfo(UCAL_MONTH, NULL, &pattern, fInfo->getDefaultOrder()); 627 setPatternInfo(UCAL_YEAR, NULL, &pattern, fInfo->getDefaultOrder()); 628 } else { 629 // TODO: fall back 630 } 631 } else { 632 // TODO: fall back 633 } 634 return; 635 } // end of skeleton not found 636 // interval patterns for skeleton are found in resource 637 if ( timeSkeleton.length() == 0 ) { 638 // done 639 } else if ( dateSkeleton.length() == 0 ) { 640 // prefix with yMd 641 timeSkeleton.insert(0, gDateFormatSkeleton[DateFormat::kShort]); 642 UnicodeString pattern = fDtpng->getBestPattern(timeSkeleton, status); 643 if ( U_FAILURE(status) ) { 644 return; 645 } 646 // for fall back interval patterns, 647 // the first part of the pattern is empty, 648 // the second part of the pattern is the full-pattern 649 // should be used in fall-back. 650 setPatternInfo(UCAL_DATE, NULL, &pattern, fInfo->getDefaultOrder()); 651 setPatternInfo(UCAL_MONTH, NULL, &pattern, fInfo->getDefaultOrder()); 652 setPatternInfo(UCAL_YEAR, NULL, &pattern, fInfo->getDefaultOrder()); 653 } else { 654 /* if both present, 655 * 1) when the year, month, or day differs, 656 * concatenate the two original expressions with a separator between, 657 * 2) otherwise, present the date followed by the 658 * range expression for the time. 659 */ 660 /* 661 * 1) when the year, month, or day differs, 662 * concatenate the two original expressions with a separator between, 663 */ 664 // if field exists, use fall back 665 UnicodeString skeleton = fSkeleton; 666 if ( !fieldExistsInSkeleton(UCAL_DATE, dateSkeleton) ) { 667 // prefix skeleton with 'd' 668 skeleton.insert(0, LOW_D); 669 setFallbackPattern(UCAL_DATE, skeleton, status); 670 } 671 if ( !fieldExistsInSkeleton(UCAL_MONTH, dateSkeleton) ) { 672 // then prefix skeleton with 'M' 673 skeleton.insert(0, CAP_M); 674 setFallbackPattern(UCAL_MONTH, skeleton, status); 675 } 676 if ( !fieldExistsInSkeleton(UCAL_YEAR, dateSkeleton) ) { 677 // then prefix skeleton with 'y' 678 skeleton.insert(0, LOW_Y); 679 setFallbackPattern(UCAL_YEAR, skeleton, status); 680 } 681 682 /* 683 * 2) otherwise, present the date followed by the 684 * range expression for the time. 685 */ 686 // Need the Date/Time pattern for concatnation the date with 687 // the time interval. 688 // The date/time pattern ( such as {0} {1} ) is saved in 689 // calendar, that is why need to get the CalendarData here. 690 CalendarData* calData = new CalendarData(locale, NULL, status); 691 692 if ( U_FAILURE(status) ) { 693 delete calData; 694 return; 695 } 696 697 if ( calData == NULL ) { 698 status = U_MEMORY_ALLOCATION_ERROR; 699 return; 700 } 701 702 const UResourceBundle* dateTimePatternsRes = calData->getByKey( 703 gDateTimePatternsTag, status); 704 int32_t dateTimeFormatLength; 705 const UChar* dateTimeFormat = ures_getStringByIndex( 706 dateTimePatternsRes, 707 (int32_t)DateFormat::kDateTime, 708 &dateTimeFormatLength, &status); 709 if ( U_FAILURE(status) ) { 710 return; 711 } 712 713 UnicodeString datePattern = fDtpng->getBestPattern(dateSkeleton, status); 714 715 concatSingleDate2TimeInterval(dateTimeFormat, dateTimeFormatLength, 716 datePattern, UCAL_AM_PM, status); 717 concatSingleDate2TimeInterval(dateTimeFormat, dateTimeFormatLength, 718 datePattern, UCAL_HOUR, status); 719 concatSingleDate2TimeInterval(dateTimeFormat, dateTimeFormatLength, 720 datePattern, UCAL_MINUTE, status); 721 delete calData; 722 } 723 } 724 725 726 727 void U_EXPORT2 728 DateIntervalFormat::getDateTimeSkeleton(const UnicodeString& skeleton, 729 UnicodeString& dateSkeleton, 730 UnicodeString& normalizedDateSkeleton, 731 UnicodeString& timeSkeleton, 732 UnicodeString& normalizedTimeSkeleton) { 733 // dateSkeleton follows the sequence of y*M*E*d* 734 // timeSkeleton follows the sequence of hm*[v|z]? 735 int32_t ECount = 0; 736 int32_t dCount = 0; 737 int32_t MCount = 0; 738 int32_t yCount = 0; 739 int32_t hCount = 0; 740 int32_t HCount = 0; 741 int32_t mCount = 0; 742 int32_t vCount = 0; 743 int32_t zCount = 0; 744 int32_t i; 745 746 for (i = 0; i < skeleton.length(); ++i) { 747 UChar ch = skeleton[i]; 748 switch ( ch ) { 749 case CAP_E: 750 dateSkeleton.append(ch); 751 ++ECount; 752 break; 753 case LOW_D: 754 dateSkeleton.append(ch); 755 ++dCount; 756 break; 757 case CAP_M: 758 dateSkeleton.append(ch); 759 ++MCount; 760 break; 761 case LOW_Y: 762 dateSkeleton.append(ch); 763 ++yCount; 764 break; 765 case CAP_G: 766 case CAP_Y: 767 case LOW_U: 768 case CAP_Q: 769 case LOW_Q: 770 case CAP_L: 771 case LOW_L: 772 case CAP_W: 773 case LOW_W: 774 case CAP_D: 775 case CAP_F: 776 case LOW_G: 777 case LOW_E: 778 case LOW_C: 779 normalizedDateSkeleton.append(ch); 780 dateSkeleton.append(ch); 781 break; 782 case LOW_A: 783 // 'a' is implicitly handled 784 timeSkeleton.append(ch); 785 break; 786 case LOW_H: 787 timeSkeleton.append(ch); 788 ++hCount; 789 break; 790 case CAP_H: 791 timeSkeleton.append(ch); 792 ++HCount; 793 break; 794 case LOW_M: 795 timeSkeleton.append(ch); 796 ++mCount; 797 break; 798 case LOW_Z: 799 ++zCount; 800 timeSkeleton.append(ch); 801 break; 802 case LOW_V: 803 ++vCount; 804 timeSkeleton.append(ch); 805 break; 806 case CAP_V: 807 case CAP_Z: 808 case LOW_K: 809 case CAP_K: 810 case LOW_J: 811 case LOW_S: 812 case CAP_S: 813 case CAP_A: 814 timeSkeleton.append(ch); 815 normalizedTimeSkeleton.append(ch); 816 break; 817 } 818 } 819 820 /* generate normalized form for date*/ 821 if ( yCount != 0 ) { 822 normalizedDateSkeleton.append(LOW_Y); 823 } 824 if ( MCount != 0 ) { 825 if ( MCount < 3 ) { 826 normalizedDateSkeleton.append(CAP_M); 827 } else { 828 int32_t i; 829 for ( i = 0; i < MCount && i < MAX_M_COUNT; ++i ) { 830 normalizedDateSkeleton.append(CAP_M); 831 } 832 } 833 } 834 if ( ECount != 0 ) { 835 if ( ECount <= 3 ) { 836 normalizedDateSkeleton.append(CAP_E); 837 } else { 838 int32_t i; 839 for ( i = 0; i < ECount && i < MAX_E_COUNT; ++i ) { 840 normalizedDateSkeleton.append(CAP_E); 841 } 842 } 843 } 844 if ( dCount != 0 ) { 845 normalizedDateSkeleton.append(LOW_D); 846 } 847 848 /* generate normalized form for time */ 849 if ( HCount != 0 ) { 850 normalizedTimeSkeleton.append(CAP_H); 851 } 852 else if ( hCount != 0 ) { 853 normalizedTimeSkeleton.append(LOW_H); 854 } 855 if ( mCount != 0 ) { 856 normalizedTimeSkeleton.append(LOW_M); 857 } 858 if ( zCount != 0 ) { 859 normalizedTimeSkeleton.append(LOW_Z); 860 } 861 if ( vCount != 0 ) { 862 normalizedTimeSkeleton.append(LOW_V); 863 } 864 } 865 866 867 /** 868 * Generate date or time interval pattern from resource, 869 * and set them into the interval pattern locale to this formatter. 870 * 871 * It needs to handle the following: 872 * 1. need to adjust field width. 873 * For example, the interval patterns saved in DateIntervalInfo 874 * includes "dMMMy", but not "dMMMMy". 875 * Need to get interval patterns for dMMMMy from dMMMy. 876 * Another example, the interval patterns saved in DateIntervalInfo 877 * includes "hmv", but not "hmz". 878 * Need to get interval patterns for "hmz' from 'hmv' 879 * 880 * 2. there might be no pattern for 'y' differ for skeleton "Md", 881 * in order to get interval patterns for 'y' differ, 882 * need to look for it from skeleton 'yMd' 883 * 884 * @param dateSkeleton normalized date skeleton 885 * @param timeSkeleton normalized time skeleton 886 * @return whether the resource is found for the skeleton. 887 * TRUE if interval pattern found for the skeleton, 888 * FALSE otherwise. 889 * @stable ICU 4.0 890 */ 891 UBool 892 DateIntervalFormat::setSeparateDateTimePtn( 893 const UnicodeString& dateSkeleton, 894 const UnicodeString& timeSkeleton) { 895 const UnicodeString* skeleton; 896 // if both date and time skeleton present, 897 // the final interval pattern might include time interval patterns 898 // ( when, am_pm, hour, minute differ ), 899 // but not date interval patterns ( when year, month, day differ ). 900 // For year/month/day differ, it falls back to fall-back pattern. 901 if ( timeSkeleton.length() != 0 ) { 902 skeleton = &timeSkeleton; 903 } else { 904 skeleton = &dateSkeleton; 905 } 906 907 /* interval patterns for skeleton "dMMMy" (but not "dMMMMy") 908 * are defined in resource, 909 * interval patterns for skeleton "dMMMMy" are calculated by 910 * 1. get the best match skeleton for "dMMMMy", which is "dMMMy" 911 * 2. get the interval patterns for "dMMMy", 912 * 3. extend "MMM" to "MMMM" in above interval patterns for "dMMMMy" 913 * getBestSkeleton() is step 1. 914 */ 915 // best skeleton, and the difference information 916 int8_t differenceInfo = 0; 917 const UnicodeString* bestSkeleton = fInfo->getBestSkeleton(*skeleton, 918 differenceInfo); 919 /* best skeleton could be NULL. 920 For example: in "ca" resource file, 921 interval format is defined as following 922 intervalFormats{ 923 fallback{"{0} - {1}"} 924 } 925 there is no skeletons/interval patterns defined, 926 and the best skeleton match could be NULL 927 */ 928 if ( bestSkeleton == NULL ) { 929 return false; 930 } 931 932 // difference: 933 // 0 means the best matched skeleton is the same as input skeleton 934 // 1 means the fields are the same, but field width are different 935 // 2 means the only difference between fields are v/z, 936 // -1 means there are other fields difference 937 if ( differenceInfo == -1 ) { 938 // skeleton has different fields, not only v/z difference 939 return false; 940 } 941 942 if ( timeSkeleton.length() == 0 ) { 943 UnicodeString extendedSkeleton; 944 UnicodeString extendedBestSkeleton; 945 // only has date skeleton 946 setIntervalPattern(UCAL_DATE, skeleton, bestSkeleton, differenceInfo, 947 &extendedSkeleton, &extendedBestSkeleton); 948 949 UBool extended = setIntervalPattern(UCAL_MONTH, skeleton, bestSkeleton, 950 differenceInfo, 951 &extendedSkeleton, &extendedBestSkeleton); 952 953 if ( extended ) { 954 bestSkeleton = &extendedBestSkeleton; 955 skeleton = &extendedSkeleton; 956 } 957 setIntervalPattern(UCAL_YEAR, skeleton, bestSkeleton, differenceInfo, 958 &extendedSkeleton, &extendedBestSkeleton); 959 } else { 960 setIntervalPattern(UCAL_MINUTE, skeleton, bestSkeleton, differenceInfo); 961 setIntervalPattern(UCAL_HOUR, skeleton, bestSkeleton, differenceInfo); 962 setIntervalPattern(UCAL_AM_PM, skeleton, bestSkeleton, differenceInfo); 963 } 964 return true; 965 } 966 967 968 969 void 970 DateIntervalFormat::setFallbackPattern(UCalendarDateFields field, 971 const UnicodeString& skeleton, 972 UErrorCode& status) { 973 if ( U_FAILURE(status) ) { 974 return; 975 } 976 UnicodeString pattern = fDtpng->getBestPattern(skeleton, status); 977 if ( U_FAILURE(status) ) { 978 return; 979 } 980 setPatternInfo(field, NULL, &pattern, fInfo->getDefaultOrder()); 981 } 982 983 984 985 986 void 987 DateIntervalFormat::setPatternInfo(UCalendarDateFields field, 988 const UnicodeString* firstPart, 989 const UnicodeString* secondPart, 990 UBool laterDateFirst) { 991 // for fall back interval patterns, 992 // the first part of the pattern is empty, 993 // the second part of the pattern is the full-pattern 994 // should be used in fall-back. 995 UErrorCode status = U_ZERO_ERROR; 996 // following should not set any wrong status. 997 int32_t itvPtnIndex = DateIntervalInfo::calendarFieldToIntervalIndex(field, 998 status); 999 if ( U_FAILURE(status) ) { 1000 return; 1001 } 1002 PatternInfo& ptn = fIntervalPatterns[itvPtnIndex]; 1003 if ( firstPart ) { 1004 ptn.firstPart = *firstPart; 1005 } 1006 if ( secondPart ) { 1007 ptn.secondPart = *secondPart; 1008 } 1009 ptn.laterDateFirst = laterDateFirst; 1010 } 1011 1012 void 1013 DateIntervalFormat::setIntervalPattern(UCalendarDateFields field, 1014 const UnicodeString& intervalPattern) { 1015 UBool order = fInfo->getDefaultOrder(); 1016 setIntervalPattern(field, intervalPattern, order); 1017 } 1018 1019 1020 void 1021 DateIntervalFormat::setIntervalPattern(UCalendarDateFields field, 1022 const UnicodeString& intervalPattern, 1023 UBool laterDateFirst) { 1024 const UnicodeString* pattern = &intervalPattern; 1025 UBool order = laterDateFirst; 1026 // check for "latestFirst:" or "earliestFirst:" prefix 1027 int8_t prefixLength = sizeof(gLaterFirstPrefix)/sizeof(gLaterFirstPrefix[0]); 1028 int8_t earliestFirstLength = sizeof(gEarlierFirstPrefix)/sizeof(gEarlierFirstPrefix[0]); 1029 UnicodeString realPattern; 1030 if ( intervalPattern.startsWith(gLaterFirstPrefix, prefixLength) ) { 1031 order = true; 1032 intervalPattern.extract(prefixLength, 1033 intervalPattern.length() - prefixLength, 1034 realPattern); 1035 pattern = &realPattern; 1036 } else if ( intervalPattern.startsWith(gEarlierFirstPrefix, 1037 earliestFirstLength) ) { 1038 order = false; 1039 intervalPattern.extract(earliestFirstLength, 1040 intervalPattern.length() - earliestFirstLength, 1041 realPattern); 1042 pattern = &realPattern; 1043 } 1044 1045 int32_t splitPoint = splitPatternInto2Part(*pattern); 1046 1047 UnicodeString firstPart; 1048 UnicodeString secondPart; 1049 pattern->extract(0, splitPoint, firstPart); 1050 if ( splitPoint < pattern->length() ) { 1051 pattern->extract(splitPoint, pattern->length()-splitPoint, secondPart); 1052 } 1053 setPatternInfo(field, &firstPart, &secondPart, order); 1054 } 1055 1056 1057 1058 1059 /** 1060 * Generate interval pattern from existing resource 1061 * 1062 * It not only save the interval patterns, 1063 * but also return the extended skeleton and its best match skeleton. 1064 * 1065 * @param field largest different calendar field 1066 * @param skeleton skeleton 1067 * @param bestSkeleton the best match skeleton which has interval pattern 1068 * defined in resource 1069 * @param differenceInfo the difference between skeleton and best skeleton 1070 * 0 means the best matched skeleton is the same as input skeleton 1071 * 1 means the fields are the same, but field width are different 1072 * 2 means the only difference between fields are v/z, 1073 * -1 means there are other fields difference 1074 * 1075 * @param extendedSkeleton extended skeleton 1076 * @param extendedBestSkeleton extended best match skeleton 1077 * @return whether the interval pattern is found 1078 * through extending skeleton or not. 1079 * TRUE if interval pattern is found by 1080 * extending skeleton, FALSE otherwise. 1081 * @stable ICU 4.0 1082 */ 1083 UBool 1084 DateIntervalFormat::setIntervalPattern(UCalendarDateFields field, 1085 const UnicodeString* skeleton, 1086 const UnicodeString* bestSkeleton, 1087 int8_t differenceInfo, 1088 UnicodeString* extendedSkeleton, 1089 UnicodeString* extendedBestSkeleton) { 1090 UErrorCode status = U_ZERO_ERROR; 1091 // following getIntervalPattern() should not generate error status 1092 UnicodeString pattern; 1093 fInfo->getIntervalPattern(*bestSkeleton, field, pattern, status); 1094 if ( pattern.isEmpty() ) { 1095 // single date 1096 if ( SimpleDateFormat::isFieldUnitIgnored(*bestSkeleton, field) ) { 1097 // do nothing, format will handle it 1098 return false; 1099 } 1100 1101 // for 24 hour system, interval patterns in resource file 1102 // might not include pattern when am_pm differ, 1103 // which should be the same as hour differ. 1104 // add it here for simplicity 1105 if ( field == UCAL_AM_PM ) { 1106 fInfo->getIntervalPattern(*bestSkeleton, UCAL_HOUR, pattern,status); 1107 if ( !pattern.isEmpty() ) { 1108 setIntervalPattern(field, pattern); 1109 } 1110 return false; 1111 } 1112 // else, looking for pattern when 'y' differ for 'dMMMM' skeleton, 1113 // first, get best match pattern "MMMd", 1114 // since there is no pattern for 'y' differs for skeleton 'MMMd', 1115 // need to look for it from skeleton 'yMMMd', 1116 // if found, adjust field width in interval pattern from 1117 // "MMM" to "MMMM". 1118 UChar fieldLetter = fgCalendarFieldToPatternLetter[field]; 1119 if ( extendedSkeleton ) { 1120 *extendedSkeleton = *skeleton; 1121 *extendedBestSkeleton = *bestSkeleton; 1122 extendedSkeleton->insert(0, fieldLetter); 1123 extendedBestSkeleton->insert(0, fieldLetter); 1124 // for example, looking for patterns when 'y' differ for 1125 // skeleton "MMMM". 1126 fInfo->getIntervalPattern(*extendedBestSkeleton,field,pattern,status); 1127 if ( pattern.isEmpty() && differenceInfo == 0 ) { 1128 // if there is no skeleton "yMMMM" defined, 1129 // look for the best match skeleton, for example: "yMMM" 1130 const UnicodeString* tmpBest = fInfo->getBestSkeleton( 1131 *extendedBestSkeleton, differenceInfo); 1132 if ( tmpBest != 0 && differenceInfo != -1 ) { 1133 fInfo->getIntervalPattern(*tmpBest, field, pattern, status); 1134 bestSkeleton = tmpBest; 1135 } 1136 } 1137 } 1138 } 1139 if ( !pattern.isEmpty() ) { 1140 if ( differenceInfo != 0 ) { 1141 UnicodeString adjustIntervalPattern; 1142 adjustFieldWidth(*skeleton, *bestSkeleton, pattern, differenceInfo, 1143 adjustIntervalPattern); 1144 setIntervalPattern(field, adjustIntervalPattern); 1145 } else { 1146 setIntervalPattern(field, pattern); 1147 } 1148 if ( extendedSkeleton && !extendedSkeleton->isEmpty() ) { 1149 return TRUE; 1150 } 1151 } 1152 return FALSE; 1153 } 1154 1155 1156 1157 int32_t U_EXPORT2 1158 DateIntervalFormat::splitPatternInto2Part(const UnicodeString& intervalPattern) { 1159 UBool inQuote = false; 1160 UChar prevCh = 0; 1161 int32_t count = 0; 1162 1163 /* repeatedPattern used to record whether a pattern has already seen. 1164 It is a pattern applies to first calendar if it is first time seen, 1165 otherwise, it is a pattern applies to the second calendar 1166 */ 1167 UBool patternRepeated[] = 1168 { 1169 // A B C D E F G H I J K L M N O 1170 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1171 // P Q R S T U V W X Y Z 1172 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1173 // a b c d e f g h i j k l m n o 1174 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1175 // p q r s t u v w x y z 1176 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 1177 }; 1178 1179 int8_t PATTERN_CHAR_BASE = 0x41; 1180 1181 /* loop through the pattern string character by character looking for 1182 * the first repeated pattern letter, which breaks the interval pattern 1183 * into 2 parts. 1184 */ 1185 int32_t i; 1186 UBool foundRepetition = false; 1187 for (i = 0; i < intervalPattern.length(); ++i) { 1188 UChar ch = intervalPattern.charAt(i); 1189 1190 if (ch != prevCh && count > 0) { 1191 // check the repeativeness of pattern letter 1192 UBool repeated = patternRepeated[(int)(prevCh - PATTERN_CHAR_BASE)]; 1193 if ( repeated == FALSE ) { 1194 patternRepeated[prevCh - PATTERN_CHAR_BASE] = TRUE; 1195 } else { 1196 foundRepetition = true; 1197 break; 1198 } 1199 count = 0; 1200 } 1201 if (ch == '\'') { 1202 // Consecutive single quotes are a single quote literal, 1203 // either outside of quotes or between quotes 1204 if ((i+1) < intervalPattern.length() && 1205 intervalPattern.charAt(i+1) == '\'') { 1206 ++i; 1207 } else { 1208 inQuote = ! inQuote; 1209 } 1210 } 1211 else if (!inQuote && ((ch >= 0x0061 /*'a'*/ && ch <= 0x007A /*'z'*/) 1212 || (ch >= 0x0041 /*'A'*/ && ch <= 0x005A /*'Z'*/))) { 1213 // ch is a date-time pattern character 1214 prevCh = ch; 1215 ++count; 1216 } 1217 } 1218 // check last pattern char, distinguish 1219 // "dd MM" ( no repetition ), 1220 // "d-d"(last char repeated ), and 1221 // "d-d MM" ( repetition found ) 1222 if ( count > 0 && foundRepetition == FALSE ) { 1223 if ( patternRepeated[(int)(prevCh - PATTERN_CHAR_BASE)] == FALSE ) { 1224 count = 0; 1225 } 1226 } 1227 return (i - count); 1228 } 1229 1230 1231 1232 UnicodeString& 1233 DateIntervalFormat::fallbackFormat(Calendar& fromCalendar, 1234 Calendar& toCalendar, 1235 UnicodeString& appendTo, 1236 FieldPosition& pos, 1237 UErrorCode& status) const { 1238 if ( U_FAILURE(status) ) { 1239 return appendTo; 1240 } 1241 // the fall back 1242 // no need delete earlierDate and laterDate since they are adopted 1243 UnicodeString* earlierDate = new UnicodeString(); 1244 *earlierDate = fDateFormat->format(fromCalendar, *earlierDate, pos); 1245 UnicodeString* laterDate = new UnicodeString(); 1246 *laterDate = fDateFormat->format(toCalendar, *laterDate, pos); 1247 UnicodeString fallbackPattern; 1248 fInfo->getFallbackIntervalPattern(fallbackPattern); 1249 Formattable fmtArray[2]; 1250 fmtArray[0].adoptString(earlierDate); 1251 fmtArray[1].adoptString(laterDate); 1252 1253 UnicodeString fallback; 1254 MessageFormat::format(fallbackPattern, fmtArray, 2, fallback, status); 1255 if ( U_SUCCESS(status) ) { 1256 appendTo.append(fallback); 1257 } 1258 return appendTo; 1259 } 1260 1261 1262 1263 1264 UBool U_EXPORT2 1265 DateIntervalFormat::fieldExistsInSkeleton(UCalendarDateFields field, 1266 const UnicodeString& skeleton) 1267 { 1268 const UChar fieldChar = fgCalendarFieldToPatternLetter[field]; 1269 return ( (skeleton.indexOf(fieldChar) == -1)?FALSE:TRUE ) ; 1270 } 1271 1272 1273 1274 void U_EXPORT2 1275 DateIntervalFormat::adjustFieldWidth(const UnicodeString& inputSkeleton, 1276 const UnicodeString& bestMatchSkeleton, 1277 const UnicodeString& bestIntervalPattern, 1278 int8_t differenceInfo, 1279 UnicodeString& adjustedPtn) { 1280 adjustedPtn = bestIntervalPattern; 1281 int32_t inputSkeletonFieldWidth[] = 1282 { 1283 // A B C D E F G H I J K L M N O 1284 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1285 // P Q R S T U V W X Y Z 1286 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1287 // a b c d e f g h i j k l m n o 1288 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1289 // p q r s t u v w x y z 1290 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 1291 }; 1292 1293 int32_t bestMatchSkeletonFieldWidth[] = 1294 { 1295 // A B C D E F G H I J K L M N O 1296 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1297 // P Q R S T U V W X Y Z 1298 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1299 // a b c d e f g h i j k l m n o 1300 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1301 // p q r s t u v w x y z 1302 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 1303 }; 1304 1305 DateIntervalInfo::parseSkeleton(inputSkeleton, inputSkeletonFieldWidth); 1306 DateIntervalInfo::parseSkeleton(bestMatchSkeleton, bestMatchSkeletonFieldWidth); 1307 if ( differenceInfo == 2 ) { 1308 adjustedPtn.findAndReplace("v", "z"); 1309 } 1310 1311 UBool inQuote = false; 1312 UChar prevCh = 0; 1313 int32_t count = 0; 1314 1315 const int8_t PATTERN_CHAR_BASE = 0x41; 1316 1317 // loop through the pattern string character by character 1318 int32_t adjustedPtnLength = adjustedPtn.length(); 1319 int32_t i; 1320 for (i = 0; i < adjustedPtnLength; ++i) { 1321 UChar ch = adjustedPtn.charAt(i); 1322 if (ch != prevCh && count > 0) { 1323 // check the repeativeness of pattern letter 1324 UChar skeletonChar = prevCh; 1325 if ( skeletonChar == CAP_L ) { 1326 // there is no "L" (always be "M") in skeleton, 1327 // but there is "L" in pattern. 1328 // for skeleton "M+", the pattern might be "...L..." 1329 skeletonChar = CAP_M; 1330 } 1331 int32_t fieldCount = bestMatchSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)]; 1332 int32_t inputFieldCount = inputSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)]; 1333 if ( fieldCount == count && inputFieldCount > fieldCount ) { 1334 count = inputFieldCount - fieldCount; 1335 int32_t j; 1336 for ( j = 0; j < count; ++j ) { 1337 adjustedPtn.insert(i, prevCh); 1338 } 1339 i += count; 1340 adjustedPtnLength += count; 1341 } 1342 count = 0; 1343 } 1344 if (ch == '\'') { 1345 // Consecutive single quotes are a single quote literal, 1346 // either outside of quotes or between quotes 1347 if ((i+1) < adjustedPtn.length() && adjustedPtn.charAt(i+1) == '\'') { 1348 ++i; 1349 } else { 1350 inQuote = ! inQuote; 1351 } 1352 } 1353 else if ( ! inQuote && ((ch >= 0x0061 /*'a'*/ && ch <= 0x007A /*'z'*/) 1354 || (ch >= 0x0041 /*'A'*/ && ch <= 0x005A /*'Z'*/))) { 1355 // ch is a date-time pattern character 1356 prevCh = ch; 1357 ++count; 1358 } 1359 } 1360 if ( count > 0 ) { 1361 // last item 1362 // check the repeativeness of pattern letter 1363 UChar skeletonChar = prevCh; 1364 if ( skeletonChar == CAP_L ) { 1365 // there is no "L" (always be "M") in skeleton, 1366 // but there is "L" in pattern. 1367 // for skeleton "M+", the pattern might be "...L..." 1368 skeletonChar = CAP_M; 1369 } 1370 int32_t fieldCount = bestMatchSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)]; 1371 int32_t inputFieldCount = inputSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)]; 1372 if ( fieldCount == count && inputFieldCount > fieldCount ) { 1373 count = inputFieldCount - fieldCount; 1374 int32_t j; 1375 for ( j = 0; j < count; ++j ) { 1376 adjustedPtn.append(prevCh); 1377 } 1378 } 1379 } 1380 } 1381 1382 1383 1384 void 1385 DateIntervalFormat::concatSingleDate2TimeInterval(const UChar* format, 1386 int32_t formatLen, 1387 const UnicodeString& datePattern, 1388 UCalendarDateFields field, 1389 UErrorCode& status) { 1390 // following should not set wrong status 1391 int32_t itvPtnIndex = DateIntervalInfo::calendarFieldToIntervalIndex(field, 1392 status); 1393 if ( U_FAILURE(status) ) { 1394 return; 1395 } 1396 PatternInfo& timeItvPtnInfo = fIntervalPatterns[itvPtnIndex]; 1397 if ( !timeItvPtnInfo.firstPart.isEmpty() ) { 1398 // UnicodeString allocated here is adopted, so no need to delete 1399 UnicodeString* timeIntervalPattern = new UnicodeString(timeItvPtnInfo.firstPart); 1400 timeIntervalPattern->append(timeItvPtnInfo.secondPart); 1401 UnicodeString* dateStr = new UnicodeString(datePattern); 1402 Formattable fmtArray[2]; 1403 fmtArray[0].adoptString(timeIntervalPattern); 1404 fmtArray[1].adoptString(dateStr); 1405 UnicodeString combinedPattern; 1406 MessageFormat::format(UnicodeString(TRUE, format, formatLen), 1407 fmtArray, 2, combinedPattern, status); 1408 if ( U_FAILURE(status) ) { 1409 return; 1410 } 1411 setIntervalPattern(field, combinedPattern, timeItvPtnInfo.laterDateFirst); 1412 } 1413 // else: fall back 1414 // it should not happen if the interval format defined is valid 1415 } 1416 1417 1418 1419 const UChar 1420 DateIntervalFormat::fgCalendarFieldToPatternLetter[] = 1421 { 1422 /*GyM*/ CAP_G, LOW_Y, CAP_M, 1423 /*wWd*/ LOW_W, CAP_W, LOW_D, 1424 /*DEF*/ CAP_D, CAP_E, CAP_F, 1425 /*ahH*/ LOW_A, LOW_H, CAP_H, 1426 /*m..*/ LOW_M, 1427 }; 1428 1429 1430 U_NAMESPACE_END 1431 1432 #endif 1433
