icuSources/i18n/reldtfmt.cpp

   1 /*
   2 *******************************************************************************
   3 * Copyright (C) 2007-2014, International Business Machines Corporation and
   4 * others. All Rights Reserved.
   5 *******************************************************************************
   6 */
   7
   8 #include "unicode/utypes.h"
   9
  10 #if !UCONFIG_NO_FORMATTING
  11
  12 #include <stdlib.h>
  13
  14 #include "reldtfmt.h"
  15 #include "unicode/datefmt.h"
  16 #include "unicode/smpdtfmt.h"
  17 #include "unicode/msgfmt.h"
  18 #include "unicode/udisplaycontext.h"
  19 #include "unicode/uchar.h"
  20 #include "unicode/brkiter.h"
  21
  22 #include "gregoimp.h" // for CalendarData
  23 #include "cmemory.h"
  24 #include "uresimp.h"
  25
  26 U_NAMESPACE_BEGIN
  27
  28
  29 /**
  30  * An array of URelativeString structs is used to store the resource data loaded out of the bundle.
  31  */
  32 struct URelativeString {
  33     int32_t offset;         /** offset of this item, such as, the relative date **/
  34     int32_t len;            /** length of the string **/
  35     const UChar* string;    /** string, or NULL if not set **/
  36 };
  37
  38 static const char DT_DateTimePatternsTag[]="DateTimePatterns";
  39
  40
  41 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(RelativeDateFormat)
  42
  43 RelativeDateFormat::RelativeDateFormat(const RelativeDateFormat& other) :
  44  DateFormat(other), fDateTimeFormatter(NULL), fDatePattern(other.fDatePattern),
  45  fTimePattern(other.fTimePattern), fCombinedFormat(NULL),
  46  fDateStyle(other.fDateStyle), fLocale(other.fLocale),
  47  fDayMin(other.fDayMin), fDayMax(other.fDayMax),
  48  fDatesLen(other.fDatesLen), fDates(NULL),
  49  fCombinedHasDateAtStart(other.fCombinedHasDateAtStart),
  50  fCapitalizationInfoSet(other.fCapitalizationInfoSet),
  51  fCapitalizationOfRelativeUnitsForUIListMenu(other.fCapitalizationOfRelativeUnitsForUIListMenu),
  52  fCapitalizationOfRelativeUnitsForStandAlone(other.fCapitalizationOfRelativeUnitsForStandAlone),
  53  fCapitalizationBrkIter(NULL)
  54 {
  55     if(other.fDateTimeFormatter != NULL) {
  56         fDateTimeFormatter = (SimpleDateFormat*)other.fDateTimeFormatter->clone();
  57     }
  58     if(other.fCombinedFormat != NULL) {
  59         fCombinedFormat = (MessageFormat*)other.fCombinedFormat->clone();
  60     }
  61     if (fDatesLen > 0) {
  62         fDates = (URelativeString*) uprv_malloc(sizeof(fDates[0])*fDatesLen);
  63         uprv_memcpy(fDates, other.fDates, sizeof(fDates[0])*fDatesLen);
  64     }
  65 #if !UCONFIG_NO_BREAK_ITERATION
  66     if (other.fCapitalizationBrkIter != NULL) {
  67         fCapitalizationBrkIter = (other.fCapitalizationBrkIter)->clone();
  68     }
  69 #endif
  70 }
  71
  72 RelativeDateFormat::RelativeDateFormat( UDateFormatStyle timeStyle, UDateFormatStyle dateStyle,
  73                                         const Locale& locale, UErrorCode& status) :
  74  DateFormat(), fDateTimeFormatter(NULL), fDatePattern(), fTimePattern(), fCombinedFormat(NULL),
  75  fDateStyle(dateStyle), fLocale(locale), fDayMin(0), fDayMax(0), fDatesLen(0), fDates(NULL),
  76  fCombinedHasDateAtStart(FALSE), fCapitalizationInfoSet(FALSE),
  77  fCapitalizationOfRelativeUnitsForUIListMenu(FALSE), fCapitalizationOfRelativeUnitsForStandAlone(FALSE),
  78  fCapitalizationBrkIter(NULL)
  79 {
  80     if(U_FAILURE(status) ) {
  81         return;
  82     }
  83
  84     if (timeStyle < UDAT_NONE || timeStyle > UDAT_SHORT) {
  85         // don't support other time styles (e.g. relative styles), for now
  86         status = U_ILLEGAL_ARGUMENT_ERROR;
  87         return;
  88     }
  89     UDateFormatStyle baseDateStyle = (dateStyle > UDAT_SHORT)? (UDateFormatStyle)(dateStyle & ~UDAT_RELATIVE): dateStyle;
  90     DateFormat * df;
  91     // Get fDateTimeFormatter from either date or time style (does not matter, we will override the pattern).
  92     // We do need to get separate patterns for the date & time styles.
  93     if (baseDateStyle != UDAT_NONE) {
  94         df = createDateInstance((EStyle)baseDateStyle, locale);
  95         fDateTimeFormatter=dynamic_cast<SimpleDateFormat *>(df);
  96         if (fDateTimeFormatter == NULL) {
  97             status = U_UNSUPPORTED_ERROR;
  98              return;
  99         }
 100         fDateTimeFormatter->toPattern(fDatePattern);
 101         if (timeStyle != UDAT_NONE) {
 102             df = createTimeInstance((EStyle)timeStyle, locale);
 103             SimpleDateFormat *sdf = dynamic_cast<SimpleDateFormat *>(df);
 104             if (sdf != NULL) {
 105                 sdf->toPattern(fTimePattern);
 106                 delete sdf;
 107             }
 108         }
 109     } else {
 110         // does not matter whether timeStyle is UDAT_NONE, we need something for fDateTimeFormatter
 111         df = createTimeInstance((EStyle)timeStyle, locale);
 112         fDateTimeFormatter=dynamic_cast<SimpleDateFormat *>(df);
 113         if (fDateTimeFormatter == NULL) {
 114             status = U_UNSUPPORTED_ERROR;
 115             return;
 116         }
 117         fDateTimeFormatter->toPattern(fTimePattern);
 118     }
 119
 120     // Initialize the parent fCalendar, so that parse() works correctly.
 121     initializeCalendar(NULL, locale, status);
 122     loadDates(status);
 123 }
 124
 125 RelativeDateFormat::~RelativeDateFormat() {
 126     delete fDateTimeFormatter;
 127     delete fCombinedFormat;
 128     uprv_free(fDates);
 129 #if !UCONFIG_NO_BREAK_ITERATION
 130     delete fCapitalizationBrkIter;
 131 #endif
 132 }
 133
 134
 135 Format* RelativeDateFormat::clone(void) const {
 136     return new RelativeDateFormat(*this);
 137 }
 138
 139 UBool RelativeDateFormat::operator==(const Format& other) const {
 140     if(DateFormat::operator==(other)) {
 141         // The DateFormat::operator== check for fCapitalizationContext equality above
 142         //   is sufficient to check equality of all derived context-related data.
 143         // DateFormat::operator== guarantees following cast is safe
 144         RelativeDateFormat* that = (RelativeDateFormat*)&other;
 145         return (fDateStyle==that->fDateStyle   &&
 146                 fDatePattern==that->fDatePattern   &&
 147                 fTimePattern==that->fTimePattern   &&
 148                 fLocale==that->fLocale );
 149     }
 150     return FALSE;
 151 }
 152
 153 static const UChar APOSTROPHE = (UChar)0x0027;
 154
 155 UnicodeString& RelativeDateFormat::format(  Calendar& cal,
 156                                 UnicodeString& appendTo,
 157                                 FieldPosition& pos) const {
 158
 159     UErrorCode status = U_ZERO_ERROR;
 160     UnicodeString relativeDayString;
 161     UDisplayContext capitalizationContext = getContext(UDISPCTX_TYPE_CAPITALIZATION, status);
 162
 163     // calculate the difference, in days, between 'cal' and now.
 164     int dayDiff = dayDifference(cal, status);
 165
 166     // look up string
 167     int32_t len = 0;
 168     const UChar *theString = getStringForDay(dayDiff, len, status);
 169     if(U_SUCCESS(status) && (theString!=NULL)) {
 170         // found a relative string
 171         relativeDayString.setTo(theString, len);
 172     }
 173
 174     if ( relativeDayString.length() > 0 && !fDatePattern.isEmpty() &&
 175          (fTimePattern.isEmpty() || fCombinedFormat == NULL || fCombinedHasDateAtStart)) {
 176 #if !UCONFIG_NO_BREAK_ITERATION
 177         // capitalize relativeDayString according to context for relative, set formatter no context
 178         if ( u_islower(relativeDayString.char32At(0)) && fCapitalizationBrkIter!= NULL &&
 179              ( capitalizationContext==UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE ||
 180                (capitalizationContext==UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU && fCapitalizationOfRelativeUnitsForUIListMenu) ||
 181                (capitalizationContext==UDISPCTX_CAPITALIZATION_FOR_STANDALONE && fCapitalizationOfRelativeUnitsForStandAlone) ) ) {
 182             // titlecase first word of relativeDayString
 183             relativeDayString.toTitle(fCapitalizationBrkIter, fLocale, U_TITLECASE_NO_LOWERCASE | U_TITLECASE_NO_BREAK_ADJUSTMENT);
 184         }
 185 #endif
 186         fDateTimeFormatter->setContext(UDISPCTX_CAPITALIZATION_NONE, status);
 187     } else {
 188         // set our context for the formatter
 189         fDateTimeFormatter->setContext(capitalizationContext, status);
 190     }
 191
 192     if (fDatePattern.isEmpty()) {
 193         fDateTimeFormatter->applyPattern(fTimePattern);
 194         fDateTimeFormatter->format(cal,appendTo,pos);
 195     } else if (fTimePattern.isEmpty() || fCombinedFormat == NULL) {
 196         if (relativeDayString.length() > 0) {
 197             appendTo.append(relativeDayString);
 198         } else {
 199             fDateTimeFormatter->applyPattern(fDatePattern);
 200             fDateTimeFormatter->format(cal,appendTo,pos);
 201         }
 202     } else {
 203         UnicodeString datePattern;
 204         if (relativeDayString.length() > 0) {
 205             // Need to quote the relativeDayString to make it a legal date pattern
 206             relativeDayString.findAndReplace(UNICODE_STRING("'", 1), UNICODE_STRING("''", 2)); // double any existing APOSTROPHE
 207             relativeDayString.insert(0, APOSTROPHE); // add APOSTROPHE at beginning...
 208             relativeDayString.append(APOSTROPHE); // and at end
 209             datePattern.setTo(relativeDayString);
 210         } else {
 211             datePattern.setTo(fDatePattern);
 212         }
 213         UnicodeString combinedPattern;
 214         Formattable timeDatePatterns[] = { fTimePattern, datePattern };
 215         fCombinedFormat->format(timeDatePatterns, 2, combinedPattern, pos, status); // pos is ignored by this
 216         fDateTimeFormatter->applyPattern(combinedPattern);
 217         fDateTimeFormatter->format(cal,appendTo,pos);
 218     }
 219
 220     return appendTo;
 221 }
 222
 223
 224
 225 UnicodeString&
 226 RelativeDateFormat::format(const Formattable& obj,
 227                          UnicodeString& appendTo,
 228                          FieldPosition& pos,
 229                          UErrorCode& status) const
 230 {
 231     // this is just here to get around the hiding problem
 232     // (the previous format() override would hide the version of
 233     // format() on DateFormat that this function correspond to, so we
 234     // have to redefine it here)
 235     return DateFormat::format(obj, appendTo, pos, status);
 236 }
 237
 238
 239 void RelativeDateFormat::parse( const UnicodeString& text,
 240                     Calendar& cal,
 241                     ParsePosition& pos) const {
 242
 243     int32_t startIndex = pos.getIndex();
 244     if (fDatePattern.isEmpty()) {
 245         // no date pattern, try parsing as time
 246         fDateTimeFormatter->applyPattern(fTimePattern);
 247         fDateTimeFormatter->parse(text,cal,pos);
 248     } else if (fTimePattern.isEmpty() || fCombinedFormat == NULL) {
 249         // no time pattern or way to combine, try parsing as date
 250         // first check whether text matches a relativeDayString
 251         UBool matchedRelative = FALSE;
 252         for (int n=0; n < fDatesLen && !matchedRelative; n++) {
 253             if (fDates[n].string != NULL &&
 254                     text.compare(startIndex, fDates[n].len, fDates[n].string) == 0) {
 255                 // it matched, handle the relative day string
 256                 UErrorCode status = U_ZERO_ERROR;
 257                 matchedRelative = TRUE;
 258
 259                 // Set the calendar to now+offset
 260                 cal.setTime(Calendar::getNow(),status);
 261                 cal.add(UCAL_DATE,fDates[n].offset, status);
 262
 263                 if(U_FAILURE(status)) {
 264                     // failure in setting calendar field, set offset to beginning of rel day string
 265                     pos.setErrorIndex(startIndex);
 266                 } else {
 267                     pos.setIndex(startIndex + fDates[n].len);
 268                 }
 269             }
 270         }
 271         if (!matchedRelative) {
 272             // just parse as normal date
 273             fDateTimeFormatter->applyPattern(fDatePattern);
 274             fDateTimeFormatter->parse(text,cal,pos);
 275         }
 276     } else {
 277         // Here we replace any relativeDayString in text with the equivalent date
 278         // formatted per fDatePattern, then parse text normally using the combined pattern.
 279         UnicodeString modifiedText(text);
 280         FieldPosition fPos;
 281         int32_t dateStart = 0, origDateLen = 0, modDateLen = 0;
 282         UErrorCode status = U_ZERO_ERROR;
 283         for (int n=0; n < fDatesLen; n++) {
 284             int32_t relativeStringOffset;
 285             if (fDates[n].string != NULL &&
 286                     (relativeStringOffset = modifiedText.indexOf(fDates[n].string, fDates[n].len, startIndex)) >= startIndex) {
 287                 // it matched, replace the relative date with a real one for parsing
 288                 UnicodeString dateString;
 289                 Calendar * tempCal = cal.clone();
 290
 291                 // Set the calendar to now+offset
 292                 tempCal->setTime(Calendar::getNow(),status);
 293                 tempCal->add(UCAL_DATE,fDates[n].offset, status);
 294                 if(U_FAILURE(status)) {
 295                     pos.setErrorIndex(startIndex);
 296                     delete tempCal;
 297                     return;
 298                 }
 299
 300                 fDateTimeFormatter->applyPattern(fDatePattern);
 301                 fDateTimeFormatter->format(*tempCal, dateString, fPos);
 302                 dateStart = relativeStringOffset;
 303                 origDateLen = fDates[n].len;
 304                 modDateLen = dateString.length();
 305                 modifiedText.replace(dateStart, origDateLen, dateString);
 306                 delete tempCal;
 307                 break;
 308             }
 309         }
 310         UnicodeString combinedPattern;
 311         Formattable timeDatePatterns[] = { fTimePattern, fDatePattern };
 312         fCombinedFormat->format(timeDatePatterns, 2, combinedPattern, fPos, status); // pos is ignored by this
 313         fDateTimeFormatter->applyPattern(combinedPattern);
 314         fDateTimeFormatter->parse(modifiedText,cal,pos);
 315
 316         // Adjust offsets
 317         UBool noError = (pos.getErrorIndex() < 0);
 318         int32_t offset = (noError)? pos.getIndex(): pos.getErrorIndex();
 319         if (offset >= dateStart + modDateLen) {
 320             // offset at or after the end of the replaced text,
 321             // correct by the difference between original and replacement
 322             offset -= (modDateLen - origDateLen);
 323         } else if (offset >= dateStart) {
 324             // offset in the replaced text, set it to the beginning of that text
 325             // (i.e. the beginning of the relative day string)
 326             offset = dateStart;
 327         }
 328         if (noError) {
 329             pos.setIndex(offset);
 330         } else {
 331             pos.setErrorIndex(offset);
 332         }
 333     }
 334 }
 335
 336 UDate
 337 RelativeDateFormat::parse( const UnicodeString& text,
 338                          ParsePosition& pos) const {
 339     // redefined here because the other parse() function hides this function's
 340     // cunterpart on DateFormat
 341     return DateFormat::parse(text, pos);
 342 }
 343
 344 UDate
 345 RelativeDateFormat::parse(const UnicodeString& text, UErrorCode& status) const
 346 {
 347     // redefined here because the other parse() function hides this function's
 348     // counterpart on DateFormat
 349     return DateFormat::parse(text, status);
 350 }
 351
 352
 353 const UChar *RelativeDateFormat::getStringForDay(int32_t day, int32_t &len, UErrorCode &status) const {
 354     if(U_FAILURE(status)) {
 355         return NULL;
 356     }
 357
 358     // Is it outside the resource bundle's range?
 359     if(day < fDayMin || day > fDayMax) {
 360         return NULL; // don't have it.
 361     }
 362
 363     // Linear search the held strings
 364     for(int n=0;n<fDatesLen;n++) {
 365         if(fDates[n].offset == day) {
 366             len = fDates[n].len;
 367             return fDates[n].string;
 368         }
 369     }
 370
 371     return NULL;  // not found.
 372 }
 373
 374 UnicodeString&
 375 RelativeDateFormat::toPattern(UnicodeString& result, UErrorCode& status) const
 376 {
 377     if (!U_FAILURE(status)) {
 378         result.remove();
 379         if (fDatePattern.isEmpty()) {
 380             result.setTo(fTimePattern);
 381         } else if (fTimePattern.isEmpty() || fCombinedFormat == NULL) {
 382             result.setTo(fDatePattern);
 383         } else {
 384             Formattable timeDatePatterns[] = { fTimePattern, fDatePattern };
 385             FieldPosition pos;
 386             fCombinedFormat->format(timeDatePatterns, 2, result, pos, status);
 387         }
 388     }
 389     return result;
 390 }
 391
 392 UnicodeString&
 393 RelativeDateFormat::toPatternDate(UnicodeString& result, UErrorCode& status) const
 394 {
 395     if (!U_FAILURE(status)) {
 396         result.remove();
 397         result.setTo(fDatePattern);
 398     }
 399     return result;
 400 }
 401
 402 UnicodeString&
 403 RelativeDateFormat::toPatternTime(UnicodeString& result, UErrorCode& status) const
 404 {
 405     if (!U_FAILURE(status)) {
 406         result.remove();
 407         result.setTo(fTimePattern);
 408     }
 409     return result;
 410 }
 411
 412 void
 413 RelativeDateFormat::applyPatterns(const UnicodeString& datePattern, const UnicodeString& timePattern, UErrorCode &status)
 414 {
 415     if (!U_FAILURE(status)) {
 416         fDatePattern.setTo(datePattern);
 417         fTimePattern.setTo(timePattern);
 418     }
 419 }
 420
 421 const DateFormatSymbols*
 422 RelativeDateFormat::getDateFormatSymbols() const
 423 {
 424     return fDateTimeFormatter->getDateFormatSymbols();
 425 }
 426
 427 // override the DateFormat implementation in order to
 428 // lazily initialize relevant items
 429 void
 430 RelativeDateFormat::setContext(UDisplayContext value, UErrorCode& status)
 431 {
 432     DateFormat::setContext(value, status);
 433     if (U_SUCCESS(status)) {
 434         if (!fCapitalizationInfoSet &&
 435                 (value==UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU || value==UDISPCTX_CAPITALIZATION_FOR_STANDALONE)) {
 436             initCapitalizationContextInfo(fLocale);
 437             fCapitalizationInfoSet = TRUE;
 438         }
 439 #if !UCONFIG_NO_BREAK_ITERATION
 440         if ( fCapitalizationBrkIter == NULL && (value==UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE ||
 441                 (value==UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU && fCapitalizationOfRelativeUnitsForUIListMenu) ||
 442                 (value==UDISPCTX_CAPITALIZATION_FOR_STANDALONE && fCapitalizationOfRelativeUnitsForStandAlone)) ) {
 443             UErrorCode status = U_ZERO_ERROR;
 444             fCapitalizationBrkIter = BreakIterator::createSentenceInstance(fLocale, status);
 445             if (U_FAILURE(status)) {
 446                 delete fCapitalizationBrkIter;
 447                 fCapitalizationBrkIter = NULL;
 448             }
 449         }
 450 #endif
 451     }
 452 }
 453
 454 void
 455 RelativeDateFormat::initCapitalizationContextInfo(const Locale& thelocale)
 456 {
 457 #if !UCONFIG_NO_BREAK_ITERATION
 458     const char * localeID = (thelocale != NULL)? thelocale.getBaseName(): NULL;
 459     UErrorCode status = U_ZERO_ERROR;
 460     UResourceBundle *rb = ures_open(NULL, localeID, &status);
 461     rb = ures_getByKeyWithFallback(rb, "contextTransforms", rb, &status);
 462     rb = ures_getByKeyWithFallback(rb, "relative", rb, &status);
 463     if (U_SUCCESS(status) && rb != NULL) {
 464         int32_t len = 0;
 465         const int32_t * intVector = ures_getIntVector(rb, &len, &status);
 466         if (U_SUCCESS(status) && intVector != NULL && len >= 2) {
 467             fCapitalizationOfRelativeUnitsForUIListMenu = intVector[0];
 468             fCapitalizationOfRelativeUnitsForStandAlone = intVector[1];
 469         }
 470     }
 471     ures_close(rb);
 472 #endif
 473 }
 474
 475 static const UChar patItem1[] = {0x7B,0x31,0x7D}; // "{1}"
 476 static const int32_t patItem1Len = 3;
 477
 478 void RelativeDateFormat::loadDates(UErrorCode &status) {
 479     CalendarData calData(fLocale, "gregorian", status);
 480
 481     UErrorCode tempStatus = status;
 482     UResourceBundle *dateTimePatterns = calData.getByKey(DT_DateTimePatternsTag, tempStatus);
 483     if(U_SUCCESS(tempStatus)) {
 484         int32_t patternsSize = ures_getSize(dateTimePatterns);
 485         if (patternsSize > kDateTime) {
 486             int32_t resStrLen = 0;
 487
 488             int32_t glueIndex = kDateTime;
 489             if (patternsSize >= (DateFormat::kDateTimeOffset + DateFormat::kShort + 1)) {
 490                 // Get proper date time format
 491                 switch (fDateStyle) {
 492                 case kFullRelative:
 493                 case kFull:
 494                     glueIndex = kDateTimeOffset + kFull;
 495                     break;
 496                 case kLongRelative:
 497                 case kLong:
 498                     glueIndex = kDateTimeOffset + kLong;
 499                     break;
 500                 case kMediumRelative:
 501                 case kMedium:
 502                     glueIndex = kDateTimeOffset + kMedium;
 503                     break;
 504                 case kShortRelative:
 505                 case kShort:
 506                     glueIndex = kDateTimeOffset + kShort;
 507                     break;
 508                 default:
 509                     break;
 510                 }
 511             }
 512
 513             const UChar *resStr = ures_getStringByIndex(dateTimePatterns, glueIndex, &resStrLen, &tempStatus);
 514             if (U_SUCCESS(tempStatus) && resStrLen >= patItem1Len && u_strncmp(resStr,patItem1,patItem1Len)==0) {
 515                 fCombinedHasDateAtStart = TRUE;
 516             }
 517             fCombinedFormat = new MessageFormat(UnicodeString(TRUE, resStr, resStrLen), fLocale, tempStatus);
 518         }
 519     }
 520
 521     UResourceBundle *rb = ures_open(NULL, fLocale.getBaseName(), &status);
 522     rb = ures_getByKeyWithFallback(rb, "fields", rb, &status);
 523     rb = ures_getByKeyWithFallback(rb, "day", rb, &status);
 524     rb = ures_getByKeyWithFallback(rb, "relative", rb, &status);
 525     // set up min/max
 526     fDayMin=-1;
 527     fDayMax=1;
 528
 529     if(U_FAILURE(status)) {
 530         fDatesLen=0;
 531         ures_close(rb);
 532         return;
 533     }
 534
 535     fDatesLen = ures_getSize(rb);
 536     fDates = (URelativeString*) uprv_malloc(sizeof(fDates[0])*fDatesLen);
 537
 538     // Load in each item into the array...
 539     int n = 0;
 540
 541     UResourceBundle *subString = NULL;
 542
 543     while(ures_hasNext(rb) && U_SUCCESS(status)) {  // iterate over items
 544         subString = ures_getNextResource(rb, subString, &status);
 545
 546         if(U_FAILURE(status) || (subString==NULL)) break;
 547
 548         // key = offset #
 549         const char *key = ures_getKey(subString);
 550
 551         // load the string and length
 552         int32_t aLen;
 553         const UChar* aString = ures_getString(subString, &aLen, &status);
 554
 555         if(U_FAILURE(status) || aString == NULL) break;
 556
 557         // calculate the offset
 558         int32_t offset = atoi(key);
 559
 560         // set min/max
 561         if(offset < fDayMin) {
 562             fDayMin = offset;
 563         }
 564         if(offset > fDayMax) {
 565             fDayMax = offset;
 566         }
 567
 568         // copy the string pointer
 569         fDates[n].offset = offset;
 570         fDates[n].string = aString;
 571         fDates[n].len = aLen;
 572
 573         n++;
 574     }
 575     ures_close(subString);
 576     ures_close(rb);
 577
 578     // the fDates[] array could be sorted here, for direct access.
 579 }
 580
 581 //----------------------------------------------------------------------
 582
 583 // this should to be in DateFormat, instead it was copied from SimpleDateFormat.
 584
 585 Calendar*
 586 RelativeDateFormat::initializeCalendar(TimeZone* adoptZone, const Locale& locale, UErrorCode& status)
 587 {
 588     if(!U_FAILURE(status)) {
 589         fCalendar = Calendar::createInstance(adoptZone?adoptZone:TimeZone::createDefault(), locale, status);
 590     }
 591     if (U_SUCCESS(status) && fCalendar == NULL) {
 592         status = U_MEMORY_ALLOCATION_ERROR;
 593     }
 594     return fCalendar;
 595 }
 596
 597 int32_t RelativeDateFormat::dayDifference(Calendar &cal, UErrorCode &status) {
 598     if(U_FAILURE(status)) {
 599         return 0;
 600     }
 601     // TODO: Cache the nowCal to avoid heap allocs? Would be difficult, don't know the calendar type
 602     Calendar *nowCal = cal.clone();
 603     nowCal->setTime(Calendar::getNow(), status);
 604
 605     // For the day difference, we are interested in the difference in the (modified) julian day number
 606     // which is midnight to midnight.  Using fieldDifference() is NOT correct here, because
 607     // 6pm Jan 4th  to 10am Jan 5th should be considered "tomorrow".
 608     int32_t dayDiff = cal.get(UCAL_JULIAN_DAY, status) - nowCal->get(UCAL_JULIAN_DAY, status);
 609
 610     delete nowCal;
 611     return dayDiff;
 612 }
 613
 614 U_NAMESPACE_END
 615
 616 #endif
 617