icuSources/i18n/datefmt.cpp

   1 /*
   2  *******************************************************************************
   3  * Copyright (C) 1997-2011, 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 "reldtfmt.h"
  29
  30 #include "cstring.h"
  31 #include "windtfmt.h"
  32
  33 #if defined( U_DEBUG_CALSVC ) || defined (U_DEBUG_CAL)
  34 #include <stdio.h>
  35 #endif
  36
  37 // *****************************************************************************
  38 // class DateFormat
  39 // *****************************************************************************
  40
  41 U_NAMESPACE_BEGIN
  42
  43 DateFormat::DateFormat()
  44 :   fCalendar(0),
  45     fNumberFormat(0)
  46 {
  47 }
  48
  49 //----------------------------------------------------------------------
  50
  51 DateFormat::DateFormat(const DateFormat& other)
  52 :   Format(other),
  53     fCalendar(0),
  54     fNumberFormat(0)
  55 {
  56     *this = other;
  57 }
  58
  59 //----------------------------------------------------------------------
  60
  61 DateFormat& DateFormat::operator=(const DateFormat& other)
  62 {
  63     if (this != &other)
  64     {
  65         delete fCalendar;
  66         delete fNumberFormat;
  67         if(other.fCalendar) {
  68           fCalendar = other.fCalendar->clone();
  69         } else {
  70           fCalendar = NULL;
  71         }
  72         if(other.fNumberFormat) {
  73           fNumberFormat = (NumberFormat*)other.fNumberFormat->clone();
  74         } else {
  75           fNumberFormat = NULL;
  76         }
  77     }
  78     return *this;
  79 }
  80
  81 //----------------------------------------------------------------------
  82
  83 DateFormat::~DateFormat()
  84 {
  85     delete fCalendar;
  86     delete fNumberFormat;
  87 }
  88
  89 //----------------------------------------------------------------------
  90
  91 UBool
  92 DateFormat::operator==(const Format& other) const
  93 {
  94     // This protected comparison operator should only be called by subclasses
  95     // which have confirmed that the other object being compared against is
  96     // an instance of a sublcass of DateFormat.  THIS IS IMPORTANT.
  97
  98     // Format::operator== guarantees that this cast is safe
  99     DateFormat* fmt = (DateFormat*)&other;
 100
 101     return (this == fmt) ||
 102         (Format::operator==(other) &&
 103          fCalendar&&(fCalendar->isEquivalentTo(*fmt->fCalendar)) &&
 104          (fNumberFormat && *fNumberFormat == *fmt->fNumberFormat));
 105 }
 106
 107 //----------------------------------------------------------------------
 108
 109 UnicodeString&
 110 DateFormat::format(const Formattable& obj,
 111                    UnicodeString& appendTo,
 112                    FieldPosition& fieldPosition,
 113                    UErrorCode& status) const
 114 {
 115     if (U_FAILURE(status)) return appendTo;
 116
 117     // if the type of the Formattable is double or long, treat it as if it were a Date
 118     UDate date = 0;
 119     switch (obj.getType())
 120     {
 121     case Formattable::kDate:
 122         date = obj.getDate();
 123         break;
 124     case Formattable::kDouble:
 125         date = (UDate)obj.getDouble();
 126         break;
 127     case Formattable::kLong:
 128         date = (UDate)obj.getLong();
 129         break;
 130     default:
 131         status = U_ILLEGAL_ARGUMENT_ERROR;
 132         return appendTo;
 133     }
 134
 135     // Is this right?
 136     //if (fieldPosition.getBeginIndex() == fieldPosition.getEndIndex())
 137     //  status = U_ILLEGAL_ARGUMENT_ERROR;
 138
 139     return format(date, appendTo, fieldPosition);
 140 }
 141
 142 //----------------------------------------------------------------------
 143
 144 UnicodeString&
 145 DateFormat::format(const Formattable& obj,
 146                    UnicodeString& appendTo,
 147                    FieldPositionIterator* posIter,
 148                    UErrorCode& status) const
 149 {
 150     if (U_FAILURE(status)) return appendTo;
 151
 152     // if the type of the Formattable is double or long, treat it as if it were a Date
 153     UDate date = 0;
 154     switch (obj.getType())
 155     {
 156     case Formattable::kDate:
 157         date = obj.getDate();
 158         break;
 159     case Formattable::kDouble:
 160         date = (UDate)obj.getDouble();
 161         break;
 162     case Formattable::kLong:
 163         date = (UDate)obj.getLong();
 164         break;
 165     default:
 166         status = U_ILLEGAL_ARGUMENT_ERROR;
 167         return appendTo;
 168     }
 169
 170     // Is this right?
 171     //if (fieldPosition.getBeginIndex() == fieldPosition.getEndIndex())
 172     //  status = U_ILLEGAL_ARGUMENT_ERROR;
 173
 174     return format(date, appendTo, posIter, status);
 175 }
 176
 177 //----------------------------------------------------------------------
 178
 179 // Default implementation for backwards compatibility, subclasses should implement.
 180 UnicodeString&
 181 DateFormat::format(Calendar& /* unused cal */,
 182                    UnicodeString& appendTo,
 183                    FieldPositionIterator* /* unused posIter */,
 184                    UErrorCode& status) const {
 185     if (U_SUCCESS(status)) {
 186         status = U_UNSUPPORTED_ERROR;
 187     }
 188     return appendTo;
 189 }
 190
 191 //----------------------------------------------------------------------
 192
 193 UnicodeString&
 194 DateFormat::format(UDate date, UnicodeString& appendTo, FieldPosition& fieldPosition) const {
 195     if (fCalendar != NULL) {
 196         // Use a clone of our calendar instance
 197         Calendar* calClone = fCalendar->clone();
 198         if (calClone != NULL) {
 199             UErrorCode ec = U_ZERO_ERROR;
 200             calClone->setTime(date, ec);
 201             if (U_SUCCESS(ec)) {
 202                 format(*calClone, appendTo, fieldPosition);
 203             }
 204             delete calClone;
 205         }
 206     }
 207     return appendTo;
 208 }
 209
 210 //----------------------------------------------------------------------
 211
 212 UnicodeString&
 213 DateFormat::format(UDate date, UnicodeString& appendTo, FieldPositionIterator* posIter,
 214                    UErrorCode& status) const {
 215     if (fCalendar != NULL) {
 216         Calendar* calClone = fCalendar->clone();
 217         if (calClone != NULL) {
 218             calClone->setTime(date, status);
 219             if (U_SUCCESS(status)) {
 220                format(*calClone, appendTo, posIter, status);
 221             }
 222             delete calClone;
 223         }
 224     }
 225     return appendTo;
 226 }
 227
 228 //----------------------------------------------------------------------
 229
 230 UnicodeString&
 231 DateFormat::format(UDate date, UnicodeString& appendTo) const
 232 {
 233     // Note that any error information is just lost.  That's okay
 234     // for this convenience method.
 235     FieldPosition fpos(0);
 236     return format(date, appendTo, fpos);
 237 }
 238
 239 //----------------------------------------------------------------------
 240
 241 UDate
 242 DateFormat::parse(const UnicodeString& text,
 243                   ParsePosition& pos) const
 244 {
 245     UDate d = 0; // Error return UDate is 0 (the epoch)
 246     if (fCalendar != NULL) {
 247         Calendar* calClone = fCalendar->clone();
 248         if (calClone != NULL) {
 249             int32_t start = pos.getIndex();
 250             calClone->clear();
 251             parse(text, *calClone, pos);
 252             if (pos.getIndex() != start) {
 253                 UErrorCode ec = U_ZERO_ERROR;
 254                 d = calClone->getTime(ec);
 255                 if (U_FAILURE(ec)) {
 256                     // We arrive here if fCalendar => calClone is non-lenient and
 257                     // there is an out-of-range field.  We don't know which field
 258                     // was illegal so we set the error index to the start.
 259                     pos.setIndex(start);
 260                     pos.setErrorIndex(start);
 261                     d = 0;
 262                 }
 263             }
 264             delete calClone;
 265         }
 266     }
 267     return d;
 268 }
 269
 270 //----------------------------------------------------------------------
 271
 272 UDate
 273 DateFormat::parse(const UnicodeString& text,
 274                   UErrorCode& status) const
 275 {
 276     if (U_FAILURE(status)) return 0;
 277
 278     ParsePosition pos(0);
 279     UDate result = parse(text, pos);
 280     if (pos.getIndex() == 0) {
 281 #if defined (U_DEBUG_CAL)
 282       fprintf(stderr, "%s:%d - - failed to parse  - err index %d\n"
 283               , __FILE__, __LINE__, pos.getErrorIndex() );
 284 #endif
 285       status = U_ILLEGAL_ARGUMENT_ERROR;
 286     }
 287     return result;
 288 }
 289
 290 //----------------------------------------------------------------------
 291
 292 void
 293 DateFormat::parseObject(const UnicodeString& source,
 294                         Formattable& result,
 295                         ParsePosition& pos) const
 296 {
 297     result.setDate(parse(source, pos));
 298 }
 299
 300 //----------------------------------------------------------------------
 301
 302 DateFormat* U_EXPORT2
 303 DateFormat::createTimeInstance(DateFormat::EStyle style,
 304                                const Locale& aLocale)
 305 {
 306     return create(style, kNone, aLocale);
 307 }
 308
 309 //----------------------------------------------------------------------
 310
 311 DateFormat* U_EXPORT2
 312 DateFormat::createDateInstance(DateFormat::EStyle style,
 313                                const Locale& aLocale)
 314 {
 315     // +4 to set the correct index for getting data out of
 316     // LocaleElements.
 317     if(style != kNone)
 318     {
 319         style = (EStyle) (style + kDateOffset);
 320     }
 321     return create(kNone, (EStyle) (style), 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 create(kShort, (EStyle) (kShort + kDateOffset), Locale::getDefault());
 344 }
 345
 346 //----------------------------------------------------------------------
 347
 348 DateFormat* U_EXPORT2
 349 DateFormat::create(EStyle timeStyle, EStyle dateStyle, const Locale& locale)
 350 {
 351     UErrorCode status = U_ZERO_ERROR;
 352 #if U_PLATFORM_HAS_WIN32_API
 353     char buffer[8];
 354     int32_t count = locale.getKeywordValue("compat", buffer, sizeof(buffer), status);
 355
 356     // if the locale has "@compat=host", create a host-specific DateFormat...
 357     if (count > 0 && uprv_strcmp(buffer, "host") == 0) {
 358         Win32DateFormat *f = new Win32DateFormat(timeStyle, dateStyle, locale, status);
 359
 360         if (U_SUCCESS(status)) {
 361             return f;
 362         }
 363
 364         delete f;
 365     }
 366 #endif
 367
 368     // is it relative?
 369     if(/*((timeStyle!=UDAT_NONE)&&(timeStyle & UDAT_RELATIVE)) || */((dateStyle!=kNone)&&((dateStyle-kDateOffset) & UDAT_RELATIVE))) {
 370         RelativeDateFormat *r = new RelativeDateFormat((UDateFormatStyle)timeStyle, (UDateFormatStyle)(dateStyle-kDateOffset), locale, status);
 371         if(U_SUCCESS(status)) return r;
 372         delete r;
 373         status = U_ZERO_ERROR;
 374     }
 375
 376     // Try to create a SimpleDateFormat of the desired style.
 377     SimpleDateFormat *f = new SimpleDateFormat(timeStyle, dateStyle, locale, status);
 378     if (U_SUCCESS(status)) return f;
 379     delete f;
 380
 381     // If that fails, try to create a format using the default pattern and
 382     // the DateFormatSymbols for this locale.
 383     status = U_ZERO_ERROR;
 384     f = new SimpleDateFormat(locale, status);
 385     if (U_SUCCESS(status)) return f;
 386     delete f;
 387
 388     // This should never really happen, because the preceding constructor
 389     // should always succeed.  If the resource data is unavailable, a last
 390     // resort object should be returned.
 391     return 0;
 392 }
 393
 394 //----------------------------------------------------------------------
 395
 396 const Locale* U_EXPORT2
 397 DateFormat::getAvailableLocales(int32_t& count)
 398 {
 399     // Get the list of installed locales.
 400     // Even if root has the correct date format for this locale,
 401     // it's still a valid locale (we don't worry about data fallbacks).
 402     return Locale::getAvailableLocales(count);
 403 }
 404
 405 //----------------------------------------------------------------------
 406
 407 void
 408 DateFormat::adoptCalendar(Calendar* newCalendar)
 409 {
 410     delete fCalendar;
 411     fCalendar = newCalendar;
 412 }
 413
 414 //----------------------------------------------------------------------
 415 void
 416 DateFormat::setCalendar(const Calendar& newCalendar)
 417 {
 418     Calendar* newCalClone = newCalendar.clone();
 419     if (newCalClone != NULL) {
 420         adoptCalendar(newCalClone);
 421     }
 422 }
 423
 424 //----------------------------------------------------------------------
 425
 426 const Calendar*
 427 DateFormat::getCalendar() const
 428 {
 429     return fCalendar;
 430 }
 431
 432 //----------------------------------------------------------------------
 433
 434 void
 435 DateFormat::adoptNumberFormat(NumberFormat* newNumberFormat)
 436 {
 437     delete fNumberFormat;
 438     fNumberFormat = newNumberFormat;
 439     newNumberFormat->setParseIntegerOnly(TRUE);
 440 }
 441 //----------------------------------------------------------------------
 442
 443 void
 444 DateFormat::setNumberFormat(const NumberFormat& newNumberFormat)
 445 {
 446     NumberFormat* newNumFmtClone = (NumberFormat*)newNumberFormat.clone();
 447     if (newNumFmtClone != NULL) {
 448         adoptNumberFormat(newNumFmtClone);
 449     }
 450 }
 451
 452 //----------------------------------------------------------------------
 453
 454 const NumberFormat*
 455 DateFormat::getNumberFormat() const
 456 {
 457     return fNumberFormat;
 458 }
 459
 460 //----------------------------------------------------------------------
 461
 462 void
 463 DateFormat::adoptTimeZone(TimeZone* zone)
 464 {
 465     if (fCalendar != NULL) {
 466         fCalendar->adoptTimeZone(zone);
 467     }
 468 }
 469 //----------------------------------------------------------------------
 470
 471 void
 472 DateFormat::setTimeZone(const TimeZone& zone)
 473 {
 474     if (fCalendar != NULL) {
 475         fCalendar->setTimeZone(zone);
 476     }
 477 }
 478
 479 //----------------------------------------------------------------------
 480
 481 const TimeZone&
 482 DateFormat::getTimeZone() const
 483 {
 484     if (fCalendar != NULL) {
 485         return fCalendar->getTimeZone();
 486     }
 487     // If calendar doesn't exists, create default timezone.
 488     // fCalendar is rarely null
 489     return *(TimeZone::createDefault());
 490 }
 491
 492 //----------------------------------------------------------------------
 493
 494 void
 495 DateFormat::setLenient(UBool lenient)
 496 {
 497     if (fCalendar != NULL) {
 498         fCalendar->setLenient(lenient);
 499     }
 500 }
 501
 502 //----------------------------------------------------------------------
 503
 504 UBool
 505 DateFormat::isLenient() const
 506 {
 507     if (fCalendar != NULL) {
 508         return fCalendar->isLenient();
 509     }
 510     // fCalendar is rarely null
 511     return FALSE;
 512 }
 513
 514 U_NAMESPACE_END
 515
 516 #endif /* #if !UCONFIG_NO_FORMATTING */
 517
 518 //eof