The Tor Browser: intl/icu/source/i18n/datefmt.cpp@6474c204b198 (annotated)

intl/icu/source/i18n/datefmt.cpp@6474c204b198 (annotated)

intl/icu/source/i18n/datefmt.cpp

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /*
  *******************************************************************************
  * Copyright (C) 1997-2013, International Business Machines Corporation and    *
  * others. All Rights Reserved.                                                *
  *******************************************************************************
  *
  * File DATEFMT.CPP
  *
  * Modification History:
  *
  *   Date        Name        Description
  *   02/19/97    aliu        Converted from java.
  *   03/31/97    aliu        Modified extensively to work with 50 locales.
  *   04/01/97    aliu        Added support for centuries.
  *   08/12/97    aliu        Fixed operator== to use Calendar::equivalentTo.
  *   07/20/98    stephen     Changed ParsePosition initialization
  ********************************************************************************
  */
 #include "unicode/utypes.h"
 #if !UCONFIG_NO_FORMATTING
 #include "unicode/ures.h"
 #include "unicode/datefmt.h"
 #include "unicode/smpdtfmt.h"
 #include "unicode/dtptngen.h"
 #include "reldtfmt.h"
 #include "cstring.h"
 #include "windtfmt.h"
 #if defined( U_DEBUG_CALSVC ) || defined (U_DEBUG_CAL)
 #include <stdio.h>
 #endif
 // *****************************************************************************
 // class DateFormat
 // *****************************************************************************
 U_NAMESPACE_BEGIN
 DateFormat::DateFormat()
 :   fCalendar(0),
     fNumberFormat(0)
 {
 }
 //----------------------------------------------------------------------
 DateFormat::DateFormat(const DateFormat& other)
 :   Format(other),
     fCalendar(0),
     fNumberFormat(0)
 {
     *this = other;
 }
 //----------------------------------------------------------------------
 DateFormat& DateFormat::operator=(const DateFormat& other)
 {
     if (this != &other)
     {
         delete fCalendar;
         delete fNumberFormat;
         if(other.fCalendar) {
           fCalendar = other.fCalendar->clone();
         } else {
           fCalendar = NULL;
         }
         if(other.fNumberFormat) {
           fNumberFormat = (NumberFormat*)other.fNumberFormat->clone();
         } else {
           fNumberFormat = NULL;
         }
         fBoolFlags = other.fBoolFlags;
     }
     return *this;
 }
 //----------------------------------------------------------------------
 DateFormat::~DateFormat()
 {
     delete fCalendar;
     delete fNumberFormat;
 }
 //----------------------------------------------------------------------
 UBool
 DateFormat::operator==(const Format& other) const
 {
     // This protected comparison operator should only be called by subclasses
     // which have confirmed that the other object being compared against is
     // an instance of a sublcass of DateFormat.  THIS IS IMPORTANT.
     // Format::operator== guarantees that this cast is safe
     DateFormat* fmt = (DateFormat*)&other;
     return (this == fmt) ||
         (Format::operator==(other) &&
          fCalendar&&(fCalendar->isEquivalentTo(*fmt->fCalendar)) &&
          (fNumberFormat && *fNumberFormat == *fmt->fNumberFormat));
 }
 //----------------------------------------------------------------------
 UnicodeString&
 DateFormat::format(const Formattable& obj,
                    UnicodeString& appendTo,
                    FieldPosition& fieldPosition,
                    UErrorCode& status) const
 {
     if (U_FAILURE(status)) return appendTo;
     // if the type of the Formattable is double or long, treat it as if it were a Date
     UDate date = 0;
     switch (obj.getType())
     {
     case Formattable::kDate:
         date = obj.getDate();
         break;
     case Formattable::kDouble:
         date = (UDate)obj.getDouble();
         break;
     case Formattable::kLong:
         date = (UDate)obj.getLong();
         break;
     default:
         status = U_ILLEGAL_ARGUMENT_ERROR;
         return appendTo;
     }
     // Is this right?
     //if (fieldPosition.getBeginIndex() == fieldPosition.getEndIndex())
     //  status = U_ILLEGAL_ARGUMENT_ERROR;
     return format(date, appendTo, fieldPosition);
 }
 //----------------------------------------------------------------------
 UnicodeString&
 DateFormat::format(const Formattable& obj,
                    UnicodeString& appendTo,
                    FieldPositionIterator* posIter,
                    UErrorCode& status) const
 {
     if (U_FAILURE(status)) return appendTo;
     // if the type of the Formattable is double or long, treat it as if it were a Date
     UDate date = 0;
     switch (obj.getType())
     {
     case Formattable::kDate:
         date = obj.getDate();
         break;
     case Formattable::kDouble:
         date = (UDate)obj.getDouble();
         break;
     case Formattable::kLong:
         date = (UDate)obj.getLong();
         break;
     default:
         status = U_ILLEGAL_ARGUMENT_ERROR;
         return appendTo;
     }
     // Is this right?
     //if (fieldPosition.getBeginIndex() == fieldPosition.getEndIndex())
     //  status = U_ILLEGAL_ARGUMENT_ERROR;
     return format(date, appendTo, posIter, status);
 }
 //----------------------------------------------------------------------
 // Default implementation for backwards compatibility, subclasses should implement.
 UnicodeString&
 DateFormat::format(Calendar& /* unused cal */,
                    UnicodeString& appendTo,
                    FieldPositionIterator* /* unused posIter */,
                    UErrorCode& status) const {
     if (U_SUCCESS(status)) {
         status = U_UNSUPPORTED_ERROR;
     }
     return appendTo;
 }
 //----------------------------------------------------------------------
 UnicodeString&
 DateFormat::format(UDate date, UnicodeString& appendTo, FieldPosition& fieldPosition) const {
     if (fCalendar != NULL) {
         // Use a clone of our calendar instance
         Calendar* calClone = fCalendar->clone();
         if (calClone != NULL) {
             UErrorCode ec = U_ZERO_ERROR;
             calClone->setTime(date, ec);
             if (U_SUCCESS(ec)) {
                 format(*calClone, appendTo, fieldPosition);
             }
             delete calClone;
         }
     }
     return appendTo;
 }
 //----------------------------------------------------------------------
 UnicodeString&
 DateFormat::format(UDate date, UnicodeString& appendTo, FieldPositionIterator* posIter,
                    UErrorCode& status) const {
     if (fCalendar != NULL) {
         Calendar* calClone = fCalendar->clone();
         if (calClone != NULL) {
             calClone->setTime(date, status);
             if (U_SUCCESS(status)) {
                format(*calClone, appendTo, posIter, status);
             }
             delete calClone;
         }
     }
     return appendTo;
 }
 //----------------------------------------------------------------------
 UnicodeString&
 DateFormat::format(UDate date, UnicodeString& appendTo) const
 {
     // Note that any error information is just lost.  That's okay
     // for this convenience method.
     FieldPosition fpos(0);
     return format(date, appendTo, fpos);
 }
 //----------------------------------------------------------------------
 UDate
 DateFormat::parse(const UnicodeString& text,
                   ParsePosition& pos) const
 {
     UDate d = 0; // Error return UDate is 0 (the epoch)
     if (fCalendar != NULL) {
         Calendar* calClone = fCalendar->clone();
         if (calClone != NULL) {
             int32_t start = pos.getIndex();
             calClone->clear();
             parse(text, *calClone, pos);
             if (pos.getIndex() != start) {
                 UErrorCode ec = U_ZERO_ERROR;
                 d = calClone->getTime(ec);
                 if (U_FAILURE(ec)) {
                     // We arrive here if fCalendar => calClone is non-lenient and
                     // there is an out-of-range field.  We don't know which field
                     // was illegal so we set the error index to the start.
                     pos.setIndex(start);
                     pos.setErrorIndex(start);
                     d = 0;
                 }
             }
             delete calClone;
         }
     }
     return d;
 }
 //----------------------------------------------------------------------
 UDate
 DateFormat::parse(const UnicodeString& text,
                   UErrorCode& status) const
 {
     if (U_FAILURE(status)) return 0;
     ParsePosition pos(0);
     UDate result = parse(text, pos);
     if (pos.getIndex() == 0) {
 #if defined (U_DEBUG_CAL)
       fprintf(stderr, "%s:%d - - failed to parse  - err index %d\n"
               , __FILE__, __LINE__, pos.getErrorIndex() );
 #endif
       status = U_ILLEGAL_ARGUMENT_ERROR;
     }
     return result;
 }
 //----------------------------------------------------------------------
 void
 DateFormat::parseObject(const UnicodeString& source,
                         Formattable& result,
                         ParsePosition& pos) const
 {
     result.setDate(parse(source, pos));
 }
 //----------------------------------------------------------------------
 DateFormat* U_EXPORT2
 DateFormat::createTimeInstance(DateFormat::EStyle style,
                                const Locale& aLocale)
 {
     return create(style, kNone, aLocale);
 }
 //----------------------------------------------------------------------
 DateFormat* U_EXPORT2
 DateFormat::createDateInstance(DateFormat::EStyle style,
                                const Locale& aLocale)
 {
     // +4 to set the correct index for getting data out of
     // LocaleElements.
     if(style != kNone)
     {
         style = (EStyle) (style + kDateOffset);
     }
     return create(kNone, (EStyle) (style), aLocale);
 }
 //----------------------------------------------------------------------
 DateFormat* U_EXPORT2
 DateFormat::createDateTimeInstance(EStyle dateStyle,
                                    EStyle timeStyle,
                                    const Locale& aLocale)
 {
     if(dateStyle != kNone)
     {
         dateStyle = (EStyle) (dateStyle + kDateOffset);
     }
     return create(timeStyle, dateStyle, aLocale);
 }
 //----------------------------------------------------------------------
 DateFormat* U_EXPORT2
 DateFormat::createInstance()
 {
     return create(kShort, (EStyle) (kShort + kDateOffset), Locale::getDefault());
 }
 //----------------------------------------------------------------------
 DateFormat* U_EXPORT2
 DateFormat::create(EStyle timeStyle, EStyle dateStyle, const Locale& locale)
 {
     UErrorCode status = U_ZERO_ERROR;
 #if U_PLATFORM_HAS_WIN32_API
     char buffer[8];
     int32_t count = locale.getKeywordValue("compat", buffer, sizeof(buffer), status);
     // if the locale has "@compat=host", create a host-specific DateFormat...
     if (count > 0 && uprv_strcmp(buffer, "host") == 0) {
         Win32DateFormat *f = new Win32DateFormat(timeStyle, dateStyle, locale, status);
         if (U_SUCCESS(status)) {
             return f;
         }
         delete f;
     }
 #endif
     // is it relative?
     if(/*((timeStyle!=UDAT_NONE)&&(timeStyle & UDAT_RELATIVE)) || */((dateStyle!=kNone)&&((dateStyle-kDateOffset) & UDAT_RELATIVE))) {
         RelativeDateFormat *r = new RelativeDateFormat((UDateFormatStyle)timeStyle, (UDateFormatStyle)(dateStyle-kDateOffset), locale, status);
         if(U_SUCCESS(status)) return r;
         delete r;
         status = U_ZERO_ERROR;
     }
     // Try to create a SimpleDateFormat of the desired style.
     SimpleDateFormat *f = new SimpleDateFormat(timeStyle, dateStyle, locale, status);
     if (U_SUCCESS(status)) return f;
     delete f;
     // If that fails, try to create a format using the default pattern and
     // the DateFormatSymbols for this locale.
     status = U_ZERO_ERROR;
     f = new SimpleDateFormat(locale, status);
     if (U_SUCCESS(status)) return f;
     delete f;
     // This should never really happen, because the preceding constructor
     // should always succeed.  If the resource data is unavailable, a last
     // resort object should be returned.
     return 0;
 }
 //----------------------------------------------------------------------
 const Locale* U_EXPORT2
 DateFormat::getAvailableLocales(int32_t& count)
 {
     // Get the list of installed locales.
     // Even if root has the correct date format for this locale,
     // it's still a valid locale (we don't worry about data fallbacks).
     return Locale::getAvailableLocales(count);
 }
 //----------------------------------------------------------------------
 void
 DateFormat::adoptCalendar(Calendar* newCalendar)
 {
     delete fCalendar;
     fCalendar = newCalendar;
 }
 //----------------------------------------------------------------------
 void
 DateFormat::setCalendar(const Calendar& newCalendar)
 {
     Calendar* newCalClone = newCalendar.clone();
     if (newCalClone != NULL) {
         adoptCalendar(newCalClone);
     }
 }
 //----------------------------------------------------------------------
 const Calendar*
 DateFormat::getCalendar() const
 {
     return fCalendar;
 }
 //----------------------------------------------------------------------
 void
 DateFormat::adoptNumberFormat(NumberFormat* newNumberFormat)
 {
     delete fNumberFormat;
     fNumberFormat = newNumberFormat;
     newNumberFormat->setParseIntegerOnly(TRUE);
 }
 //----------------------------------------------------------------------
 void
 DateFormat::setNumberFormat(const NumberFormat& newNumberFormat)
 {
     NumberFormat* newNumFmtClone = (NumberFormat*)newNumberFormat.clone();
     if (newNumFmtClone != NULL) {
         adoptNumberFormat(newNumFmtClone);
     }
 }
 //----------------------------------------------------------------------
 const NumberFormat*
 DateFormat::getNumberFormat() const
 {
     return fNumberFormat;
 }
 //----------------------------------------------------------------------
 void
 DateFormat::adoptTimeZone(TimeZone* zone)
 {
     if (fCalendar != NULL) {
         fCalendar->adoptTimeZone(zone);
     }
 }
 //----------------------------------------------------------------------
 void
 DateFormat::setTimeZone(const TimeZone& zone)
 {
     if (fCalendar != NULL) {
         fCalendar->setTimeZone(zone);
     }
 }
 //----------------------------------------------------------------------
 const TimeZone&
 DateFormat::getTimeZone() const
 {
     if (fCalendar != NULL) {
         return fCalendar->getTimeZone();
     }
     // If calendar doesn't exists, create default timezone.
     // fCalendar is rarely null
     return *(TimeZone::createDefault());
 }
 //----------------------------------------------------------------------
 void
 DateFormat::setLenient(UBool lenient)
 {
     if (fCalendar != NULL) {
         fCalendar->setLenient(lenient);
     }
 }
 //----------------------------------------------------------------------
 UBool
 DateFormat::isLenient() const
 {
     if (fCalendar != NULL) {
         return fCalendar->isLenient();
     }
     // fCalendar is rarely null
     return FALSE;
 }
 //----------------------------------------------------------------------
 DateFormat&
 DateFormat::setBooleanAttribute(UDateFormatBooleanAttribute attr,
     									UBool newValue,
     									UErrorCode &status) {
     if(!fBoolFlags.isValidValue(newValue)) {
         status = U_ILLEGAL_ARGUMENT_ERROR;
     } else {
         fBoolFlags.set(attr, newValue);
     }
     return *this;
 }
 //----------------------------------------------------------------------
 UBool
 DateFormat::getBooleanAttribute(UDateFormatBooleanAttribute attr, UErrorCode &/*status*/) const {
     return fBoolFlags.get(attr);
 }
 U_NAMESPACE_END
 #endif /* #if !UCONFIG_NO_FORMATTING */
 //eof

The Tor Browser / annotate

intl/icu/source/i18n/datefmt.cpp@6474c204b198 (annotated)

intl/icu/source/i18n/datefmt.cpp