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