third_party/icu/source/i18n/datefmt.cpp - cobalt - Git at Google

 // © 2016 and later: Unicode, Inc. and others.
 // License & terms of use: http://www.unicode.org/copyright.html
 /*
  *******************************************************************************
  * Copyright (C) 1997-2015, 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 "unicode/udisplaycontext.h"
 #include "reldtfmt.h"
 #include "sharedobject.h"
 #include "unifiedcache.h"
 #include "uarrsort.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

 class U_I18N_API DateFmtBestPattern : public SharedObject {
 public:
     UnicodeString fPattern;

     DateFmtBestPattern(const UnicodeString &pattern)
             : fPattern(pattern) { }
     ~DateFmtBestPattern();
 };

 DateFmtBestPattern::~DateFmtBestPattern() {
 }

 template<> U_I18N_API
 const DateFmtBestPattern *LocaleCacheKey<DateFmtBestPattern>::createObject(
         const void * /*creationContext*/, UErrorCode &status) const {
     status = U_UNSUPPORTED_ERROR;
     return NULL;
 }

 class U_I18N_API DateFmtBestPatternKey : public LocaleCacheKey<DateFmtBestPattern> {
 private:
     UnicodeString fSkeleton;
 public:
     DateFmtBestPatternKey(
         const Locale &loc,
         const UnicodeString &skeleton,
         UErrorCode &status)
             : LocaleCacheKey<DateFmtBestPattern>(loc),
               fSkeleton(DateTimePatternGenerator::staticGetSkeleton(skeleton, status)) { }
     DateFmtBestPatternKey(const DateFmtBestPatternKey &other) :
             LocaleCacheKey<DateFmtBestPattern>(other),
             fSkeleton(other.fSkeleton) { }
     virtual ~DateFmtBestPatternKey();
     virtual int32_t hashCode() const {
         return (int32_t)(37u * (uint32_t)LocaleCacheKey<DateFmtBestPattern>::hashCode() + (uint32_t)fSkeleton.hashCode());
     }
     virtual UBool operator==(const CacheKeyBase &other) const {
        // reflexive
        if (this == &other) {
            return TRUE;
        }
        if (!LocaleCacheKey<DateFmtBestPattern>::operator==(other)) {
            return FALSE;
        }
        // We know that this and other are of same class if we get this far.
        const DateFmtBestPatternKey &realOther =
                static_cast<const DateFmtBestPatternKey &>(other);
        return (realOther.fSkeleton == fSkeleton);
     }
     virtual CacheKeyBase *clone() const {
         return new DateFmtBestPatternKey(*this);
     }
     virtual const DateFmtBestPattern *createObject(
             const void * /*unused*/, UErrorCode &status) const {
         LocalPointer<DateTimePatternGenerator> dtpg(
                     DateTimePatternGenerator::createInstance(fLoc, status));
         if (U_FAILURE(status)) {
             return NULL;
         }

         LocalPointer<DateFmtBestPattern> pattern(
                 new DateFmtBestPattern(
                         dtpg->getBestPattern(fSkeleton, status)),
                 status);
         if (U_FAILURE(status)) {
             return NULL;
         }
         DateFmtBestPattern *result = pattern.orphan();
         result->addRef();
         return result;
     }
 };

 DateFmtBestPatternKey::~DateFmtBestPatternKey() { }


 DateFormat::DateFormat()
 :   fCalendar(0),
     fNumberFormat(0),
     fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
 {
 }

 //----------------------------------------------------------------------

 DateFormat::DateFormat(const DateFormat& other)
 :   Format(other),
     fCalendar(0),
     fNumberFormat(0),
     fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
 {
     *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 = other.fNumberFormat->clone();
         } else {
           fNumberFormat = NULL;
         }
         fBoolFlags = other.fBoolFlags;
         fCapitalizationContext = other.fCapitalizationContext;
     }
     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) &&
          (fCapitalizationContext == fmt->fCapitalizationContext) );
 }

 //----------------------------------------------------------------------

 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(FieldPosition::DONT_CARE);
     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 createDateTimeInstance(kNone, style, aLocale);
 }

 //----------------------------------------------------------------------

 DateFormat* U_EXPORT2
 DateFormat::createDateInstance(DateFormat::EStyle style,
                                const Locale& aLocale)
 {
     return createDateTimeInstance(style, kNone, 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 createDateTimeInstance(kShort, kShort, Locale::getDefault());
 }

 //----------------------------------------------------------------------

 UnicodeString U_EXPORT2
 DateFormat::getBestPattern(
         const Locale &locale,
         const UnicodeString &skeleton,
         UErrorCode &status) {
     UnifiedCache *cache = UnifiedCache::getInstance(status);
     if (U_FAILURE(status)) {
         return UnicodeString();
     }
     DateFmtBestPatternKey key(locale, skeleton, status);
     const DateFmtBestPattern *patternPtr = NULL;
     cache->get(key, patternPtr, status);
     if (U_FAILURE(status)) {
         return UnicodeString();
     }
     UnicodeString result(patternPtr->fPattern);
     patternPtr->removeRef();
     return result;
 }

 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;
     }
     Locale localeWithCalendar = locale;
     localeWithCalendar.setKeywordValue("calendar", calendar->getType(), status);
     if (U_FAILURE(status)) {
         return NULL;
     }
     DateFormat *result = createInstanceForSkeleton(skeleton, localeWithCalendar, 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) {
     if (U_FAILURE(status)) {
         return NULL;
     }
     LocalPointer<DateFormat> df(
         new SimpleDateFormat(
             getBestPattern(locale, skeleton, status),
             locale, status),
         status);
     return U_SUCCESS(status) ? df.orphan() : NULL;
 }

 DateFormat* U_EXPORT2
 DateFormat::createInstanceForSkeleton(
         const UnicodeString& skeleton,
         UErrorCode &status) {
     return createInstanceForSkeleton(
             skeleton, Locale::getDefault(), status);
 }

 //----------------------------------------------------------------------

 DateFormat* U_EXPORT2
 DateFormat::create(EStyle timeStyle, EStyle dateStyle, const Locale& locale)
 {
     UErrorCode status = U_ZERO_ERROR;
 #if U_PLATFORM_USES_ONLY_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);
     newNumberFormat->setGroupingUsed(FALSE);
 }
 //----------------------------------------------------------------------

 void
 DateFormat::setNumberFormat(const NumberFormat& newNumberFormat)
 {
     NumberFormat* newNumFmtClone = 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);
     }
     UErrorCode status = U_ZERO_ERROR;
     setBooleanAttribute(UDAT_PARSE_ALLOW_WHITESPACE, lenient, status);
     setBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, lenient, status);
 }

 //----------------------------------------------------------------------

 UBool
 DateFormat::isLenient() const
 {
     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 static_cast<UBool>(fBoolFlags.get(attr));
 }

 U_NAMESPACE_END

 #endif /* #if !UCONFIG_NO_FORMATTING */

 //eof
	// © 2016 and later: Unicode, Inc. and others.
	// License & terms of use: http://www.unicode.org/copyright.html
	/*
	*******************************************************************************
	* Copyright (C) 1997-2015, 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 "unicode/udisplaycontext.h"
	#include "reldtfmt.h"
	#include "sharedobject.h"
	#include "unifiedcache.h"
	#include "uarrsort.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

	class U_I18N_API DateFmtBestPattern : public SharedObject {
	public:
	UnicodeString fPattern;

	DateFmtBestPattern(const UnicodeString &pattern)
	: fPattern(pattern) { }
	~DateFmtBestPattern();
	};

	DateFmtBestPattern::~DateFmtBestPattern() {
	}

	template<> U_I18N_API
	const DateFmtBestPattern *LocaleCacheKey<DateFmtBestPattern>::createObject(
	const void * /creationContext/, UErrorCode &status) const {
	status = U_UNSUPPORTED_ERROR;
	return NULL;
	}

	class U_I18N_API DateFmtBestPatternKey : public LocaleCacheKey<DateFmtBestPattern> {
	private:
	UnicodeString fSkeleton;
	public:
	DateFmtBestPatternKey(
	const Locale &loc,
	const UnicodeString &skeleton,
	UErrorCode &status)
	: LocaleCacheKey<DateFmtBestPattern>(loc),
	fSkeleton(DateTimePatternGenerator::staticGetSkeleton(skeleton, status)) { }
	DateFmtBestPatternKey(const DateFmtBestPatternKey &other) :
	LocaleCacheKey<DateFmtBestPattern>(other),
	fSkeleton(other.fSkeleton) { }
	virtual ~DateFmtBestPatternKey();
	virtual int32_t hashCode() const {
	return (int32_t)(37u * (uint32_t)LocaleCacheKey<DateFmtBestPattern>::hashCode() + (uint32_t)fSkeleton.hashCode());
	}
	virtual UBool operator==(const CacheKeyBase &other) const {
	// reflexive
	if (this == &other) {
	return TRUE;
	}
	if (!LocaleCacheKey<DateFmtBestPattern>::operator==(other)) {
	return FALSE;
	}
	// We know that this and other are of same class if we get this far.
	const DateFmtBestPatternKey &realOther =
	static_cast<const DateFmtBestPatternKey &>(other);
	return (realOther.fSkeleton == fSkeleton);
	}
	virtual CacheKeyBase *clone() const {
	return new DateFmtBestPatternKey(*this);
	}
	virtual const DateFmtBestPattern *createObject(
	const void * /unused/, UErrorCode &status) const {
	LocalPointer<DateTimePatternGenerator> dtpg(
	DateTimePatternGenerator::createInstance(fLoc, status));
	if (U_FAILURE(status)) {
	return NULL;
	}

	LocalPointer<DateFmtBestPattern> pattern(
	new DateFmtBestPattern(
	dtpg->getBestPattern(fSkeleton, status)),
	status);
	if (U_FAILURE(status)) {
	return NULL;
	}
	DateFmtBestPattern *result = pattern.orphan();
	result->addRef();
	return result;
	}
	};

	DateFmtBestPatternKey::~DateFmtBestPatternKey() { }


	DateFormat::DateFormat()
	: fCalendar(0),
	fNumberFormat(0),
	fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
	{
	}

	//----------------------------------------------------------------------

	DateFormat::DateFormat(const DateFormat& other)
	: Format(other),
	fCalendar(0),
	fNumberFormat(0),
	fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
	{
	*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 = other.fNumberFormat->clone();
	} else {
	fNumberFormat = NULL;
	}
	fBoolFlags = other.fBoolFlags;
	fCapitalizationContext = other.fCapitalizationContext;
	}
	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) &&
	(fCapitalizationContext == fmt->fCapitalizationContext) );
	}

	//----------------------------------------------------------------------

	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(FieldPosition::DONT_CARE);
	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 createDateTimeInstance(kNone, style, aLocale);
	}

	//----------------------------------------------------------------------

	DateFormat* U_EXPORT2
	DateFormat::createDateInstance(DateFormat::EStyle style,
	const Locale& aLocale)
	{
	return createDateTimeInstance(style, kNone, 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 createDateTimeInstance(kShort, kShort, Locale::getDefault());
	}

	//----------------------------------------------------------------------

	UnicodeString U_EXPORT2
	DateFormat::getBestPattern(
	const Locale &locale,
	const UnicodeString &skeleton,
	UErrorCode &status) {
	UnifiedCache *cache = UnifiedCache::getInstance(status);
	if (U_FAILURE(status)) {
	return UnicodeString();
	}
	DateFmtBestPatternKey key(locale, skeleton, status);
	const DateFmtBestPattern *patternPtr = NULL;
	cache->get(key, patternPtr, status);
	if (U_FAILURE(status)) {
	return UnicodeString();
	}
	UnicodeString result(patternPtr->fPattern);
	patternPtr->removeRef();
	return result;
	}

	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;
	}
	Locale localeWithCalendar = locale;
	localeWithCalendar.setKeywordValue("calendar", calendar->getType(), status);
	if (U_FAILURE(status)) {
	return NULL;
	}
	DateFormat *result = createInstanceForSkeleton(skeleton, localeWithCalendar, 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) {
	if (U_FAILURE(status)) {
	return NULL;
	}
	LocalPointer<DateFormat> df(
	new SimpleDateFormat(
	getBestPattern(locale, skeleton, status),
	locale, status),
	status);
	return U_SUCCESS(status) ? df.orphan() : NULL;
	}

	DateFormat* U_EXPORT2
	DateFormat::createInstanceForSkeleton(
	const UnicodeString& skeleton,
	UErrorCode &status) {
	return createInstanceForSkeleton(
	skeleton, Locale::getDefault(), status);
	}

	//----------------------------------------------------------------------

	DateFormat* U_EXPORT2
	DateFormat::create(EStyle timeStyle, EStyle dateStyle, const Locale& locale)
	{
	UErrorCode status = U_ZERO_ERROR;
	#if U_PLATFORM_USES_ONLY_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);
	newNumberFormat->setGroupingUsed(FALSE);
	}
	//----------------------------------------------------------------------

	void
	DateFormat::setNumberFormat(const NumberFormat& newNumberFormat)
	{
	NumberFormat* newNumFmtClone = 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);
	}
	UErrorCode status = U_ZERO_ERROR;
	setBooleanAttribute(UDAT_PARSE_ALLOW_WHITESPACE, lenient, status);
	setBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, lenient, status);
	}

	//----------------------------------------------------------------------

	UBool
	DateFormat::isLenient() const
	{
	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 static_cast<UBool>(fBoolFlags.get(attr));
	}

	U_NAMESPACE_END

	#endif /* #if !UCONFIG_NO_FORMATTING */

	//eof