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