icuSources/i18n/datefmt.cpp

   1 /*
   2  *******************************************************************************
   3  * Copyright (C) 1997-2014, International Business Machines Corporation and    *
   4  * others. All Rights Reserved.                                                *
   5  *******************************************************************************
   6  *
   7  * File DATEFMT.CPP
   8  *
   9  * Modification History:
  10  *
  11  *   Date        Name        Description
  12  *   02/19/97    aliu        Converted from java.
  13  *   03/31/97    aliu        Modified extensively to work with 50 locales.
  14  *   04/01/97    aliu        Added support for centuries.
  15  *   08/12/97    aliu        Fixed operator== to use Calendar::equivalentTo.
  16  *   07/20/98    stephen     Changed ParsePosition initialization
  17  ********************************************************************************
  18  */
  19
  20 #include "unicode/utypes.h"
  21
  22 #if !UCONFIG_NO_FORMATTING
  23
  24 #include "unicode/ures.h"
  25 #include "unicode/datefmt.h"
  26 #include "unicode/smpdtfmt.h"
  27 #include "unicode/dtptngen.h"
  28 #include "unicode/udisplaycontext.h"
  29 #include "reldtfmt.h"
  30
  31 #include "cstring.h"
  32 #include "windtfmt.h"
  33
  34 #if defined( U_DEBUG_CALSVC ) || defined (U_DEBUG_CAL)
  35 #include <stdio.h>
  36 #endif
  37
  38 // *****************************************************************************
  39 // class DateFormat
  40 // *****************************************************************************
  41
  42 U_NAMESPACE_BEGIN
  43
  44 DateFormat::DateFormat()
  45 :   fCalendar(0),
  46     fNumberFormat(0),
  47     fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
  48 {
  49 }
  50
  51 //----------------------------------------------------------------------
  52
  53 DateFormat::DateFormat(const DateFormat& other)
  54 :   Format(other),
  55     fCalendar(0),
  56     fNumberFormat(0),
  57     fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
  58 {
  59     *this = other;
  60 }
  61
  62 //----------------------------------------------------------------------
  63
  64 DateFormat& DateFormat::operator=(const DateFormat& other)
  65 {
  66     if (this != &other)
  67     {
  68         delete fCalendar;
  69         delete fNumberFormat;
  70         if(other.fCalendar) {
  71           fCalendar = other.fCalendar->clone();
  72         } else {
  73           fCalendar = NULL;
  74         }
  75         if(other.fNumberFormat) {
  76           fNumberFormat = (NumberFormat*)other.fNumberFormat->clone();
  77         } else {
  78           fNumberFormat = NULL;
  79         }
  80         fBoolFlags = other.fBoolFlags;
  81         fCapitalizationContext = other.fCapitalizationContext;
  82     }
  83     return *this;
  84 }
  85
  86 //----------------------------------------------------------------------
  87
  88 DateFormat::~DateFormat()
  89 {
  90     delete fCalendar;
  91     delete fNumberFormat;
  92 }
  93
  94 //----------------------------------------------------------------------
  95
  96 UBool
  97 DateFormat::operator==(const Format& other) const
  98 {
  99     // This protected comparison operator should only be called by subclasses
 100     // which have confirmed that the other object being compared against is
 101     // an instance of a sublcass of DateFormat.  THIS IS IMPORTANT.
 102
 103     // Format::operator== guarantees that this cast is safe
 104     DateFormat* fmt = (DateFormat*)&other;
 105
 106     return (this == fmt) ||
 107         (Format::operator==(other) &&
 108          fCalendar&&(fCalendar->isEquivalentTo(*fmt->fCalendar)) &&
 109          (fNumberFormat && *fNumberFormat == *fmt->fNumberFormat) &&
 110          (fCapitalizationContext == fmt->fCapitalizationContext) );
 111 }
 112
 113 //----------------------------------------------------------------------
 114
 115 UnicodeString&
 116 DateFormat::format(const Formattable& obj,
 117                    UnicodeString& appendTo,
 118                    FieldPosition& fieldPosition,
 119                    UErrorCode& status) const
 120 {
 121     if (U_FAILURE(status)) return appendTo;
 122
 123     // if the type of the Formattable is double or long, treat it as if it were a Date
 124     UDate date = 0;
 125     switch (obj.getType())
 126     {
 127     case Formattable::kDate:
 128         date = obj.getDate();
 129         break;
 130     case Formattable::kDouble:
 131         date = (UDate)obj.getDouble();
 132         break;
 133     case Formattable::kLong:
 134         date = (UDate)obj.getLong();
 135         break;
 136     default:
 137         status = U_ILLEGAL_ARGUMENT_ERROR;
 138         return appendTo;
 139     }
 140
 141     // Is this right?
 142     //if (fieldPosition.getBeginIndex() == fieldPosition.getEndIndex())
 143     //  status = U_ILLEGAL_ARGUMENT_ERROR;
 144
 145     return format(date, appendTo, fieldPosition);
 146 }
 147
 148 //----------------------------------------------------------------------
 149
 150 UnicodeString&
 151 DateFormat::format(const Formattable& obj,
 152                    UnicodeString& appendTo,
 153                    FieldPositionIterator* posIter,
 154                    UErrorCode& status) const
 155 {
 156     if (U_FAILURE(status)) return appendTo;
 157
 158     // if the type of the Formattable is double or long, treat it as if it were a Date
 159     UDate date = 0;
 160     switch (obj.getType())
 161     {
 162     case Formattable::kDate:
 163         date = obj.getDate();
 164         break;
 165     case Formattable::kDouble:
 166         date = (UDate)obj.getDouble();
 167         break;
 168     case Formattable::kLong:
 169         date = (UDate)obj.getLong();
 170         break;
 171     default:
 172         status = U_ILLEGAL_ARGUMENT_ERROR;
 173         return appendTo;
 174     }
 175
 176     // Is this right?
 177     //if (fieldPosition.getBeginIndex() == fieldPosition.getEndIndex())
 178     //  status = U_ILLEGAL_ARGUMENT_ERROR;
 179
 180     return format(date, appendTo, posIter, status);
 181 }
 182
 183 //----------------------------------------------------------------------
 184
 185 // Default implementation for backwards compatibility, subclasses should implement.
 186 UnicodeString&
 187 DateFormat::format(Calendar& /* unused cal */,
 188                    UnicodeString& appendTo,
 189                    FieldPositionIterator* /* unused posIter */,
 190                    UErrorCode& status) const {
 191     if (U_SUCCESS(status)) {
 192         status = U_UNSUPPORTED_ERROR;
 193     }
 194     return appendTo;
 195 }
 196
 197 //----------------------------------------------------------------------
 198
 199 UnicodeString&
 200 DateFormat::format(UDate date, UnicodeString& appendTo, FieldPosition& fieldPosition) const {
 201     if (fCalendar != NULL) {
 202         // Use a clone of our calendar instance
 203         Calendar* calClone = fCalendar->clone();
 204         if (calClone != NULL) {
 205             UErrorCode ec = U_ZERO_ERROR;
 206             calClone->setTime(date, ec);
 207             if (U_SUCCESS(ec)) {
 208                 format(*calClone, appendTo, fieldPosition);
 209             }
 210             delete calClone;
 211         }
 212     }
 213     return appendTo;
 214 }
 215
 216 //----------------------------------------------------------------------
 217
 218 UnicodeString&
 219 DateFormat::format(UDate date, UnicodeString& appendTo, FieldPositionIterator* posIter,
 220                    UErrorCode& status) const {
 221     if (fCalendar != NULL) {
 222         Calendar* calClone = fCalendar->clone();
 223         if (calClone != NULL) {
 224             calClone->setTime(date, status);
 225             if (U_SUCCESS(status)) {
 226                format(*calClone, appendTo, posIter, status);
 227             }
 228             delete calClone;
 229         }
 230     }
 231     return appendTo;
 232 }
 233
 234 //----------------------------------------------------------------------
 235
 236 UnicodeString&
 237 DateFormat::format(UDate date, UnicodeString& appendTo) const
 238 {
 239     // Note that any error information is just lost.  That's okay
 240     // for this convenience method.
 241     FieldPosition fpos(0);
 242     return format(date, appendTo, fpos);
 243 }
 244
 245 //----------------------------------------------------------------------
 246
 247 UDate
 248 DateFormat::parse(const UnicodeString& text,
 249                   ParsePosition& pos) const
 250 {
 251     UDate d = 0; // Error return UDate is 0 (the epoch)
 252     if (fCalendar != NULL) {
 253         Calendar* calClone = fCalendar->clone();
 254         if (calClone != NULL) {
 255             int32_t start = pos.getIndex();
 256             calClone->clear();
 257             parse(text, *calClone, pos);
 258             if (pos.getIndex() != start) {
 259                 UErrorCode ec = U_ZERO_ERROR;
 260                 d = calClone->getTime(ec);
 261                 if (U_FAILURE(ec)) {
 262                     // We arrive here if fCalendar => calClone is non-lenient and
 263                     // there is an out-of-range field.  We don't know which field
 264                     // was illegal so we set the error index to the start.
 265                     pos.setIndex(start);
 266                     pos.setErrorIndex(start);
 267                     d = 0;
 268                 }
 269             }
 270             delete calClone;
 271         }
 272     }
 273     return d;
 274 }
 275
 276 //----------------------------------------------------------------------
 277
 278 UDate
 279 DateFormat::parse(const UnicodeString& text,
 280                   UErrorCode& status) const
 281 {
 282     if (U_FAILURE(status)) return 0;
 283
 284     ParsePosition pos(0);
 285     UDate result = parse(text, pos);
 286     if (pos.getIndex() == 0) {
 287 #if defined (U_DEBUG_CAL)
 288       fprintf(stderr, "%s:%d - - failed to parse  - err index %d\n"
 289               , __FILE__, __LINE__, pos.getErrorIndex() );
 290 #endif
 291       status = U_ILLEGAL_ARGUMENT_ERROR;
 292     }
 293     return result;
 294 }
 295
 296 //----------------------------------------------------------------------
 297
 298 void
 299 DateFormat::parseObject(const UnicodeString& source,
 300                         Formattable& result,
 301                         ParsePosition& pos) const
 302 {
 303     result.setDate(parse(source, pos));
 304 }
 305
 306 //----------------------------------------------------------------------
 307
 308 DateFormat* U_EXPORT2
 309 DateFormat::createTimeInstance(DateFormat::EStyle style,
 310                                const Locale& aLocale)
 311 {
 312     return createDateTimeInstance(kNone, style, aLocale);
 313 }
 314
 315 //----------------------------------------------------------------------
 316
 317 DateFormat* U_EXPORT2
 318 DateFormat::createDateInstance(DateFormat::EStyle style,
 319                                const Locale& aLocale)
 320 {
 321     return createDateTimeInstance(style, kNone, aLocale);
 322 }
 323
 324 //----------------------------------------------------------------------
 325
 326 DateFormat* U_EXPORT2
 327 DateFormat::createDateTimeInstance(EStyle dateStyle,
 328                                    EStyle timeStyle,
 329                                    const Locale& aLocale)
 330 {
 331    if(dateStyle != kNone)
 332    {
 333        dateStyle = (EStyle) (dateStyle + kDateOffset);
 334    }
 335    return create(timeStyle, dateStyle, aLocale);
 336 }
 337
 338 //----------------------------------------------------------------------
 339
 340 DateFormat* U_EXPORT2
 341 DateFormat::createInstance()
 342 {
 343     return createDateTimeInstance(kShort, kShort, Locale::getDefault());
 344 }
 345
 346 //----------------------------------------------------------------------
 347
 348 DateFormat* U_EXPORT2
 349 DateFormat::createInstanceForSkeleton(
 350         Calendar *calendarToAdopt,
 351         const UnicodeString& skeleton,
 352         const Locale &locale,
 353         UErrorCode &status) {
 354     LocalPointer<Calendar> calendar(calendarToAdopt);
 355     if (U_FAILURE(status)) {
 356         return NULL;
 357     }
 358     if (calendar.isNull()) {
 359         status = U_ILLEGAL_ARGUMENT_ERROR;
 360         return NULL;
 361     }
 362     DateFormat *result = createInstanceForSkeleton(skeleton, locale, status);
 363     if (U_FAILURE(status)) {
 364         return NULL;
 365     }
 366     result->adoptCalendar(calendar.orphan());
 367     return result;
 368 }
 369
 370 DateFormat* U_EXPORT2
 371 DateFormat::createInstanceForSkeleton(
 372         const UnicodeString& skeleton,
 373         const Locale &locale,
 374         UErrorCode &status) {
 375     LocalPointer<DateTimePatternGenerator> gen(
 376             DateTimePatternGenerator::createInstance(locale, status));
 377     if (U_FAILURE(status)) {
 378         return NULL;
 379     }
 380     return internalCreateInstanceForSkeleton(
 381             skeleton, locale, *gen, status);
 382 }
 383
 384 DateFormat* U_EXPORT2
 385 DateFormat::createInstanceForSkeleton(
 386         const UnicodeString& skeleton,
 387         UErrorCode &status) {
 388     return createInstanceForSkeleton(
 389             skeleton, Locale::getDefault(), status);
 390 }
 391
 392 DateFormat* U_EXPORT2
 393 DateFormat::internalCreateInstanceForSkeleton(
 394         const UnicodeString& skeleton,
 395         const Locale &locale,
 396         DateTimePatternGenerator &gen,
 397         UErrorCode &status) {
 398     if (U_FAILURE(status)) {
 399         return NULL;
 400     }
 401     DateFormat *fmt = new SimpleDateFormat(
 402                gen.getBestPattern(skeleton, status),
 403                locale,
 404                status);
 405    if (fmt == NULL) {
 406        status = U_MEMORY_ALLOCATION_ERROR;
 407        return NULL;
 408    }
 409    if (U_FAILURE(status)) {
 410        delete fmt;
 411        return NULL;
 412    }
 413    return fmt;
 414 }
 415
 416 //----------------------------------------------------------------------
 417
 418 DateFormat* U_EXPORT2
 419 DateFormat::create(EStyle timeStyle, EStyle dateStyle, const Locale& locale)
 420 {
 421     UErrorCode status = U_ZERO_ERROR;
 422 #if U_PLATFORM_HAS_WIN32_API
 423     char buffer[8];
 424     int32_t count = locale.getKeywordValue("compat", buffer, sizeof(buffer), status);
 425
 426     // if the locale has "@compat=host", create a host-specific DateFormat...
 427     if (count > 0 && uprv_strcmp(buffer, "host") == 0) {
 428         Win32DateFormat *f = new Win32DateFormat(timeStyle, dateStyle, locale, status);
 429
 430         if (U_SUCCESS(status)) {
 431             return f;
 432         }
 433
 434         delete f;
 435     }
 436 #endif
 437
 438     // is it relative?
 439     if(/*((timeStyle!=UDAT_NONE)&&(timeStyle & UDAT_RELATIVE)) || */((dateStyle!=kNone)&&((dateStyle-kDateOffset) & UDAT_RELATIVE))) {
 440         RelativeDateFormat *r = new RelativeDateFormat((UDateFormatStyle)timeStyle, (UDateFormatStyle)(dateStyle-kDateOffset), locale, status);
 441         if(U_SUCCESS(status)) return r;
 442         delete r;
 443         status = U_ZERO_ERROR;
 444     }
 445
 446     // Try to create a SimpleDateFormat of the desired style.
 447     SimpleDateFormat *f = new SimpleDateFormat(timeStyle, dateStyle, locale, status);
 448     if (U_SUCCESS(status)) return f;
 449     delete f;
 450
 451     // If that fails, try to create a format using the default pattern and
 452     // the DateFormatSymbols for this locale.
 453     status = U_ZERO_ERROR;
 454     f = new SimpleDateFormat(locale, status);
 455     if (U_SUCCESS(status)) return f;
 456     delete f;
 457
 458     // This should never really happen, because the preceding constructor
 459     // should always succeed.  If the resource data is unavailable, a last
 460     // resort object should be returned.
 461     return 0;
 462 }
 463
 464 //----------------------------------------------------------------------
 465
 466 const Locale* U_EXPORT2
 467 DateFormat::getAvailableLocales(int32_t& count)
 468 {
 469     // Get the list of installed locales.
 470     // Even if root has the correct date format for this locale,
 471     // it's still a valid locale (we don't worry about data fallbacks).
 472     return Locale::getAvailableLocales(count);
 473 }
 474
 475 //----------------------------------------------------------------------
 476
 477 void
 478 DateFormat::adoptCalendar(Calendar* newCalendar)
 479 {
 480     delete fCalendar;
 481     fCalendar = newCalendar;
 482 }
 483
 484 //----------------------------------------------------------------------
 485 void
 486 DateFormat::setCalendar(const Calendar& newCalendar)
 487 {
 488     Calendar* newCalClone = newCalendar.clone();
 489     if (newCalClone != NULL) {
 490         adoptCalendar(newCalClone);
 491     }
 492 }
 493
 494 //----------------------------------------------------------------------
 495
 496 const Calendar*
 497 DateFormat::getCalendar() const
 498 {
 499     return fCalendar;
 500 }
 501
 502 //----------------------------------------------------------------------
 503
 504 void
 505 DateFormat::adoptNumberFormat(NumberFormat* newNumberFormat)
 506 {
 507     delete fNumberFormat;
 508     fNumberFormat = newNumberFormat;
 509     newNumberFormat->setParseIntegerOnly(TRUE);
 510 }
 511 //----------------------------------------------------------------------
 512
 513 void
 514 DateFormat::setNumberFormat(const NumberFormat& newNumberFormat)
 515 {
 516     NumberFormat* newNumFmtClone = (NumberFormat*)newNumberFormat.clone();
 517     if (newNumFmtClone != NULL) {
 518         adoptNumberFormat(newNumFmtClone);
 519     }
 520 }
 521
 522 //----------------------------------------------------------------------
 523
 524 const NumberFormat*
 525 DateFormat::getNumberFormat() const
 526 {
 527     return fNumberFormat;
 528 }
 529
 530 //----------------------------------------------------------------------
 531
 532 void
 533 DateFormat::adoptTimeZone(TimeZone* zone)
 534 {
 535     if (fCalendar != NULL) {
 536         fCalendar->adoptTimeZone(zone);
 537     }
 538 }
 539 //----------------------------------------------------------------------
 540
 541 void
 542 DateFormat::setTimeZone(const TimeZone& zone)
 543 {
 544     if (fCalendar != NULL) {
 545         fCalendar->setTimeZone(zone);
 546     }
 547 }
 548
 549 //----------------------------------------------------------------------
 550
 551 const TimeZone&
 552 DateFormat::getTimeZone() const
 553 {
 554     if (fCalendar != NULL) {
 555         return fCalendar->getTimeZone();
 556     }
 557     // If calendar doesn't exists, create default timezone.
 558     // fCalendar is rarely null
 559     return *(TimeZone::createDefault());
 560 }
 561
 562 //----------------------------------------------------------------------
 563
 564 void
 565 DateFormat::setLenient(UBool lenient)
 566 {
 567     if (fCalendar != NULL) {
 568         fCalendar->setLenient(lenient);
 569     }
 570     UErrorCode status = U_ZERO_ERROR;
 571     setBooleanAttribute(UDAT_PARSE_ALLOW_WHITESPACE, lenient, status);
 572     setBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, lenient, status);
 573 }
 574
 575 //----------------------------------------------------------------------
 576
 577 UBool
 578 DateFormat::isLenient() const
 579 {
 580     UBool lenient = TRUE;
 581     if (fCalendar != NULL) {
 582         lenient = fCalendar->isLenient();
 583     }
 584     UErrorCode status = U_ZERO_ERROR;
 585     return lenient
 586         && getBooleanAttribute(UDAT_PARSE_ALLOW_WHITESPACE, status)
 587         && getBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, status);
 588 }
 589
 590 void
 591 DateFormat::setCalendarLenient(UBool lenient)
 592 {
 593     if (fCalendar != NULL) {
 594         fCalendar->setLenient(lenient);
 595     }
 596 }
 597
 598 //----------------------------------------------------------------------
 599
 600 UBool
 601 DateFormat::isCalendarLenient() const
 602 {
 603     if (fCalendar != NULL) {
 604         return fCalendar->isLenient();
 605     }
 606     // fCalendar is rarely null
 607     return FALSE;
 608 }
 609
 610
 611 //----------------------------------------------------------------------
 612
 613
 614 void DateFormat::setContext(UDisplayContext value, UErrorCode& status)
 615 {
 616     if (U_FAILURE(status))
 617         return;
 618     if ( (UDisplayContextType)((uint32_t)value >> 8) == UDISPCTX_TYPE_CAPITALIZATION ) {
 619         fCapitalizationContext = value;
 620     } else {
 621         status = U_ILLEGAL_ARGUMENT_ERROR;
 622    }
 623 }
 624
 625
 626 //----------------------------------------------------------------------
 627
 628
 629 UDisplayContext DateFormat::getContext(UDisplayContextType type, UErrorCode& status) const
 630 {
 631     if (U_FAILURE(status))
 632         return (UDisplayContext)0;
 633     if (type != UDISPCTX_TYPE_CAPITALIZATION) {
 634         status = U_ILLEGAL_ARGUMENT_ERROR;
 635         return (UDisplayContext)0;
 636     }
 637     return fCapitalizationContext;
 638 }
 639
 640
 641 //----------------------------------------------------------------------
 642
 643
 644 DateFormat&
 645 DateFormat::setBooleanAttribute(UDateFormatBooleanAttribute attr,
 646                                                                         UBool newValue,
 647                                                                         UErrorCode &status) {
 648     if(!fBoolFlags.isValidValue(newValue)) {
 649         status = U_ILLEGAL_ARGUMENT_ERROR;
 650     } else {
 651         fBoolFlags.set(attr, newValue);
 652     }
 653
 654     return *this;
 655 }
 656
 657 //----------------------------------------------------------------------
 658
 659 UBool
 660 DateFormat::getBooleanAttribute(UDateFormatBooleanAttribute attr, UErrorCode &/*status*/) const {
 661
 662     return fBoolFlags.get(attr);
 663 }
 664
 665 U_NAMESPACE_END
 666
 667 #endif /* #if !UCONFIG_NO_FORMATTING */
 668
 669 //eof