ICU-551.51.4.tar.gz

[apple/icu.git] / icuSources / i18n / datefmt.cpp

diff --git a/icuSources/i18n/datefmt.cpp b/icuSources/i18n/datefmt.cpp
index b2b758168d4aa514c511de580cddd677715b0f30..7006e10317a8cc95cee09019b939040baf2c586a 100644 (file)
--- a/icuSources/i18n/datefmt.cpp
+++ b/icuSources/i18n/datefmt.cpp
@@ -1,21 +1,21 @@
 /*
 /*

-*******************************************************************************
-* Copyright (C) 1997-2004, 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
-********************************************************************************
-*/
+ *******************************************************************************
+ * Copyright (C) 1997-2014, 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"
 
 
 #include "unicode/utypes.h"
 


@@ -24,6 +24,12 @@
 #include "unicode/ures.h"
 #include "unicode/datefmt.h"
 #include "unicode/smpdtfmt.h"
 #include "unicode/ures.h"
 #include "unicode/datefmt.h"
 #include "unicode/smpdtfmt.h"

+#include "unicode/dtptngen.h"
+#include "unicode/udisplaycontext.h"
+#include "reldtfmt.h"
+
+#include "cstring.h"
+#include "windtfmt.h"

 
 #if defined( U_DEBUG_CALSVC ) || defined (U_DEBUG_CAL)
 #include <stdio.h>
 
 #if defined( U_DEBUG_CALSVC ) || defined (U_DEBUG_CAL)
 #include <stdio.h>


@@ -37,7 +43,8 @@ U_NAMESPACE_BEGIN
 
 DateFormat::DateFormat()
 :   fCalendar(0),
 
 DateFormat::DateFormat()
 :   fCalendar(0),

-    fNumberFormat(0)
+    fNumberFormat(0),
+    fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE)

 {
 }
 
 {
 }
 


@@ -46,7 +53,8 @@ DateFormat::DateFormat()
 DateFormat::DateFormat(const DateFormat& other)
 :   Format(other),
     fCalendar(0),
 DateFormat::DateFormat(const DateFormat& other)
 :   Format(other),
     fCalendar(0),

-    fNumberFormat(0)
+    fNumberFormat(0),
+    fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE)

 {
     *this = other;
 }
 {
     *this = other;
 }


@@ -69,6 +77,8 @@ DateFormat& DateFormat::operator=(const DateFormat& other)
         } else {
           fNumberFormat = NULL;
         }
         } else {
           fNumberFormat = NULL;
         }

+        fBoolFlags = other.fBoolFlags;
+        fCapitalizationContext = other.fCapitalizationContext;

     }
     return *this;
 }
     }
     return *this;
 }


@@ -96,7 +106,8 @@ DateFormat::operator==(const Format& other) const
     return (this == fmt) ||
         (Format::operator==(other) &&
          fCalendar&&(fCalendar->isEquivalentTo(*fmt->fCalendar)) &&
     return (this == fmt) ||
         (Format::operator==(other) &&
          fCalendar&&(fCalendar->isEquivalentTo(*fmt->fCalendar)) &&

-         (fNumberFormat && *fNumberFormat == *fmt->fNumberFormat));
+         (fNumberFormat && *fNumberFormat == *fmt->fNumberFormat) &&
+         (fCapitalizationContext == fmt->fCapitalizationContext) );

 }
 
 //----------------------------------------------------------------------
 }
 
 //----------------------------------------------------------------------


@@ -136,14 +147,85 @@ DateFormat::format(const Formattable& obj,
 
 //----------------------------------------------------------------------
 
 
 //----------------------------------------------------------------------
 

+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) {
 UnicodeString&
 DateFormat::format(UDate date, UnicodeString& appendTo, FieldPosition& fieldPosition) const {
     if (fCalendar != NULL) {

-        // Use our calendar instance
-        UErrorCode ec = U_ZERO_ERROR;
-        fCalendar->setTime(date, ec);
-        if (U_SUCCESS(ec)) {
-            return format(*fCalendar, appendTo, fieldPosition);
+        // 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;
         }
     }
     return appendTo;


@@ -166,24 +248,29 @@ UDate
 DateFormat::parse(const UnicodeString& text,
                   ParsePosition& pos) const
 {
 DateFormat::parse(const UnicodeString& text,
                   ParsePosition& pos) const
 {

+    UDate d = 0; // Error return UDate is 0 (the epoch)

     if (fCalendar != NULL) {
     if (fCalendar != NULL) {

-        int32_t start = pos.getIndex();
-        fCalendar->clear();
-        parse(text, *fCalendar, pos);
-        if (pos.getIndex() != start) {
-            UErrorCode ec = U_ZERO_ERROR;
-            UDate d = fCalendar->getTime(ec);
-            if (U_SUCCESS(ec)) {
-                return d; // Successful function exit
+        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;
+                }

             }
             }

-            // We arrive here if fCalendar 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);
+            delete calClone;

         }
     }
         }
     }

-    return 0; // Error return UDate is 0 (the epoch)
+    return d;

 }
 
 //----------------------------------------------------------------------
 }
 
 //----------------------------------------------------------------------


@@ -222,7 +309,7 @@ DateFormat* U_EXPORT2
 DateFormat::createTimeInstance(DateFormat::EStyle style,
                                const Locale& aLocale)
 {
 DateFormat::createTimeInstance(DateFormat::EStyle style,
                                const Locale& aLocale)
 {

-    return create(style, kNone, aLocale);
+    return createDateTimeInstance(kNone, style, aLocale);

 }
 
 //----------------------------------------------------------------------
 }
 
 //----------------------------------------------------------------------


@@ -231,13 +318,7 @@ DateFormat* U_EXPORT2
 DateFormat::createDateInstance(DateFormat::EStyle style,
                                const Locale& aLocale)
 {
 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);
+    return createDateTimeInstance(style, kNone, aLocale);

 }
 
 //----------------------------------------------------------------------
 }
 
 //----------------------------------------------------------------------


@@ -247,11 +328,11 @@ DateFormat::createDateTimeInstance(EStyle dateStyle,
                                    EStyle timeStyle,
                                    const Locale& aLocale)
 {
                                    EStyle timeStyle,
                                    const Locale& aLocale)
 {

-    if(dateStyle != kNone)
-    {
-        dateStyle = (EStyle) (dateStyle + kDateOffset);
-    }
-    return create(timeStyle, dateStyle, aLocale);
+   if(dateStyle != kNone)
+   {
+       dateStyle = (EStyle) (dateStyle + kDateOffset);
+   }
+   return create(timeStyle, dateStyle, aLocale);

 }
 
 //----------------------------------------------------------------------
 }
 
 //----------------------------------------------------------------------


@@ -259,7 +340,77 @@ DateFormat::createDateTimeInstance(EStyle dateStyle,
 DateFormat* U_EXPORT2
 DateFormat::createInstance()
 {
 DateFormat* U_EXPORT2
 DateFormat::createInstance()
 {

-    return create(kShort, (EStyle) (kShort + kDateOffset), Locale::getDefault());
+    return createDateTimeInstance(kShort, kShort, Locale::getDefault());
+}
+
+//----------------------------------------------------------------------
+
+DateFormat* U_EXPORT2
+DateFormat::createInstanceForSkeleton(
+        Calendar *calendarToAdopt,
+        const UnicodeString& skeleton,
+        const Locale &locale,
+        UErrorCode &status) {
+    LocalPointer<Calendar> calendar(calendarToAdopt);
+    if (U_FAILURE(status)) {
+        return NULL;
+    }
+    if (calendar.isNull()) {
+        status = U_ILLEGAL_ARGUMENT_ERROR;
+        return NULL;
+    }
+    DateFormat *result = createInstanceForSkeleton(skeleton, locale, status);
+    if (U_FAILURE(status)) {
+        return NULL;
+    }
+    result->adoptCalendar(calendar.orphan());
+    return result;
+}
+
+DateFormat* U_EXPORT2
+DateFormat::createInstanceForSkeleton(
+        const UnicodeString& skeleton,
+        const Locale &locale,
+        UErrorCode &status) {
+    LocalPointer<DateTimePatternGenerator> gen(
+            DateTimePatternGenerator::createInstance(locale, status));
+    if (U_FAILURE(status)) {
+        return NULL;
+    }
+    return internalCreateInstanceForSkeleton(
+            skeleton, locale, *gen, status);
+}
+
+DateFormat* U_EXPORT2
+DateFormat::createInstanceForSkeleton(
+        const UnicodeString& skeleton,
+        UErrorCode &status) {
+    return createInstanceForSkeleton(
+            skeleton, Locale::getDefault(), status);
+}
+
+DateFormat* U_EXPORT2
+DateFormat::internalCreateInstanceForSkeleton(
+        const UnicodeString& skeleton,
+        const Locale &locale,
+        DateTimePatternGenerator &gen,
+        UErrorCode &status) {
+    if (U_FAILURE(status)) {
+        return NULL;
+    }
+    DateFormat *fmt = new SimpleDateFormat(
+               gen.getBestPattern(skeleton, status),
+               locale,
+               status);
+   if (fmt == NULL) {
+       status = U_MEMORY_ALLOCATION_ERROR;
+       return NULL;
+   }
+   if (U_FAILURE(status)) {
+       delete fmt;
+       return NULL;
+   }
+   return fmt;

 }
 
 //----------------------------------------------------------------------
 }
 
 //----------------------------------------------------------------------


@@ -267,8 +418,32 @@ DateFormat::createInstance()
 DateFormat* U_EXPORT2
 DateFormat::create(EStyle timeStyle, EStyle dateStyle, const Locale& locale)
 {
 DateFormat* U_EXPORT2
 DateFormat::create(EStyle timeStyle, EStyle dateStyle, const Locale& locale)
 {

-    // Try to create a SimpleDateFormat of the desired style.

     UErrorCode status = U_ZERO_ERROR;
     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;
     SimpleDateFormat *f = new SimpleDateFormat(timeStyle, dateStyle, locale, status);
     if (U_SUCCESS(status)) return f;
     delete f;


@@ -310,7 +485,10 @@ DateFormat::adoptCalendar(Calendar* newCalendar)
 void
 DateFormat::setCalendar(const Calendar& newCalendar)
 {
 void
 DateFormat::setCalendar(const Calendar& newCalendar)
 {

-    adoptCalendar(newCalendar.clone());
+    Calendar* newCalClone = newCalendar.clone();
+    if (newCalClone != NULL) {
+        adoptCalendar(newCalClone);
+    }

 }
 
 //----------------------------------------------------------------------
 }
 
 //----------------------------------------------------------------------


@@ -335,7 +513,10 @@ DateFormat::adoptNumberFormat(NumberFormat* newNumberFormat)
 void
 DateFormat::setNumberFormat(const NumberFormat& newNumberFormat)
 {
 void
 DateFormat::setNumberFormat(const NumberFormat& newNumberFormat)
 {

-    adoptNumberFormat((NumberFormat*)newNumberFormat.clone());
+    NumberFormat* newNumFmtClone = (NumberFormat*)newNumberFormat.clone();
+    if (newNumFmtClone != NULL) {
+        adoptNumberFormat(newNumFmtClone);
+    }

 }
 
 //----------------------------------------------------------------------
 }
 
 //----------------------------------------------------------------------


@@ -351,14 +532,18 @@ DateFormat::getNumberFormat() const
 void
 DateFormat::adoptTimeZone(TimeZone* zone)
 {
 void
 DateFormat::adoptTimeZone(TimeZone* zone)
 {

-    fCalendar->adoptTimeZone(zone);
+    if (fCalendar != NULL) {
+        fCalendar->adoptTimeZone(zone);
+    }

 }
 //----------------------------------------------------------------------
 
 void
 DateFormat::setTimeZone(const TimeZone& zone)
 {
 }
 //----------------------------------------------------------------------
 
 void
 DateFormat::setTimeZone(const TimeZone& zone)
 {

-    fCalendar->setTimeZone(zone);
+    if (fCalendar != NULL) {
+        fCalendar->setTimeZone(zone);
+    }

 }
 
 //----------------------------------------------------------------------
 }
 
 //----------------------------------------------------------------------


@@ -366,7 +551,12 @@ DateFormat::setTimeZone(const TimeZone& zone)
 const TimeZone&
 DateFormat::getTimeZone() const
 {
 const TimeZone&
 DateFormat::getTimeZone() const
 {

-    return fCalendar->getTimeZone();
+    if (fCalendar != NULL) {
+        return fCalendar->getTimeZone();
+    }
+    // If calendar doesn't exists, create default timezone.
+    // fCalendar is rarely null
+    return *(TimeZone::createDefault());

 }
 
 //----------------------------------------------------------------------
 }
 
 //----------------------------------------------------------------------


@@ -374,7 +564,12 @@ DateFormat::getTimeZone() const
 void
 DateFormat::setLenient(UBool lenient)
 {
 void
 DateFormat::setLenient(UBool lenient)
 {

-    fCalendar->setLenient(lenient);
+    if (fCalendar != NULL) {
+        fCalendar->setLenient(lenient);
+    }
+    UErrorCode status = U_ZERO_ERROR;
+    setBooleanAttribute(UDAT_PARSE_ALLOW_WHITESPACE, lenient, status);
+    setBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, lenient, status);

 }
 
 //----------------------------------------------------------------------
 }
 
 //----------------------------------------------------------------------


@@ -382,7 +577,89 @@ DateFormat::setLenient(UBool lenient)
 UBool
 DateFormat::isLenient() const
 {
 UBool
 DateFormat::isLenient() const
 {

-    return fCalendar->isLenient();
+    UBool lenient = TRUE;
+    if (fCalendar != NULL) {
+        lenient = fCalendar->isLenient();
+    }
+    UErrorCode status = U_ZERO_ERROR;
+    return lenient
+        && getBooleanAttribute(UDAT_PARSE_ALLOW_WHITESPACE, status)
+        && getBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, status);
+}
+
+void
+DateFormat::setCalendarLenient(UBool lenient)
+{
+    if (fCalendar != NULL) {
+        fCalendar->setLenient(lenient);
+    }
+}
+
+//----------------------------------------------------------------------
+
+UBool
+DateFormat::isCalendarLenient() const
+{
+    if (fCalendar != NULL) {
+        return fCalendar->isLenient();
+    }
+    // fCalendar is rarely null
+    return FALSE;
+}
+
+
+//----------------------------------------------------------------------
+
+
+void DateFormat::setContext(UDisplayContext value, UErrorCode& status)
+{
+    if (U_FAILURE(status))
+        return;
+    if ( (UDisplayContextType)((uint32_t)value >> 8) == UDISPCTX_TYPE_CAPITALIZATION ) {
+        fCapitalizationContext = value;
+    } else {
+        status = U_ILLEGAL_ARGUMENT_ERROR;
+   }
+}
+
+
+//----------------------------------------------------------------------
+
+
+UDisplayContext DateFormat::getContext(UDisplayContextType type, UErrorCode& status) const
+{
+    if (U_FAILURE(status))
+        return (UDisplayContext)0;
+    if (type != UDISPCTX_TYPE_CAPITALIZATION) {
+        status = U_ILLEGAL_ARGUMENT_ERROR;
+        return (UDisplayContext)0;
+    }
+    return fCapitalizationContext;
+}
+
+
+//----------------------------------------------------------------------
+
+
+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
 }
 
 U_NAMESPACE_END