scuffed-code/icu4c/source/i18n/datefmt.cpp

543 lines
15 KiB
C++
Raw Normal View History

1999-08-16 21:50:52 +00:00
/*
*******************************************************************************
* 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
********************************************************************************
*/
1999-08-16 21:50:52 +00:00
#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"
1999-08-16 21:50:52 +00:00
#include "cstring.h"
#include "windtfmt.h"
#if defined( U_DEBUG_CALSVC ) || defined (U_DEBUG_CAL)
#include <stdio.h>
#endif
1999-08-16 21:50:52 +00:00
// *****************************************************************************
// class DateFormat
// *****************************************************************************
U_NAMESPACE_BEGIN
1999-08-16 21:50:52 +00:00
DateFormat::DateFormat()
: fCalendar(0),
fNumberFormat(0)
{
}
//----------------------------------------------------------------------
DateFormat::DateFormat(const DateFormat& other)
: Format(other),
fCalendar(0),
1999-08-16 21:50:52 +00:00
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;
1999-08-16 21:50:52 +00:00
}
return *this;
}
//----------------------------------------------------------------------
DateFormat::~DateFormat()
{
delete fCalendar;
delete fNumberFormat;
}
//----------------------------------------------------------------------
UBool
1999-08-16 21:50:52 +00:00
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
1999-08-16 21:50:52 +00:00
DateFormat* fmt = (DateFormat*)&other;
return (this == fmt) ||
(Format::operator==(other) &&
fCalendar&&(fCalendar->isEquivalentTo(*fmt->fCalendar)) &&
(fNumberFormat && *fNumberFormat == *fmt->fNumberFormat));
1999-08-16 21:50:52 +00:00
}
//----------------------------------------------------------------------
UnicodeString&
DateFormat::format(const Formattable& obj,
UnicodeString& appendTo,
1999-08-16 21:50:52 +00:00
FieldPosition& fieldPosition,
UErrorCode& status) const
{
if (U_FAILURE(status)) return appendTo;
1999-08-16 21:50:52 +00:00
// if the type of the Formattable is double or long, treat it as if it were a Date
UDate date = 0;
1999-08-16 21:50:52 +00:00
switch (obj.getType())
{
case Formattable::kDate:
date = obj.getDate();
1999-08-16 21:50:52 +00:00
break;
case Formattable::kDouble:
date = (UDate)obj.getDouble();
1999-08-16 21:50:52 +00:00
break;
case Formattable::kLong:
date = (UDate)obj.getLong();
1999-08-16 21:50:52 +00:00
break;
default:
status = U_ILLEGAL_ARGUMENT_ERROR;
return appendTo;
1999-08-16 21:50:52 +00:00
}
// Is this right?
//if (fieldPosition.getBeginIndex() == fieldPosition.getEndIndex())
// status = U_ILLEGAL_ARGUMENT_ERROR;
1999-08-16 21:50:52 +00:00
return format(date, appendTo, fieldPosition);
1999-08-16 21:50:52 +00:00
}
//----------------------------------------------------------------------
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;
}
//----------------------------------------------------------------------
1999-08-16 21:50:52 +00:00
UnicodeString&
DateFormat::format(UDate date, UnicodeString& appendTo) const
1999-08-16 21:50:52 +00:00
{
// Note that any error information is just lost. That's okay
// for this convenience method.
FieldPosition fpos(0);
return format(date, appendTo, fpos);
1999-08-16 21:50:52 +00:00
}
//----------------------------------------------------------------------
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;
2002-04-02 02:55:31 +00:00
}
}
return d;
}
//----------------------------------------------------------------------
1999-08-16 21:50:52 +00:00
UDate
DateFormat::parse(const UnicodeString& text,
UErrorCode& status) const
{
if (U_FAILURE(status)) return 0;
1999-08-16 21:50:52 +00:00
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;
}
1999-08-16 21:50:52 +00:00
return result;
}
//----------------------------------------------------------------------
void
DateFormat::parseObject(const UnicodeString& source,
Formattable& result,
ParsePosition& pos) const
{
result.setDate(parse(source, pos));
}
//----------------------------------------------------------------------
DateFormat* U_EXPORT2
1999-08-16 21:50:52 +00:00
DateFormat::createTimeInstance(DateFormat::EStyle style,
const Locale& aLocale)
{
return create(style, kNone, aLocale);
}
//----------------------------------------------------------------------
DateFormat* U_EXPORT2
1999-08-16 21:50:52 +00:00
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);
1999-08-16 21:50:52 +00:00
}
//----------------------------------------------------------------------
DateFormat* U_EXPORT2
1999-08-16 21:50:52 +00:00
DateFormat::createDateTimeInstance(EStyle dateStyle,
EStyle timeStyle,
const Locale& aLocale)
{
if(dateStyle != kNone)
{
dateStyle = (EStyle) (dateStyle + kDateOffset);
}
return create(timeStyle, dateStyle, aLocale);
1999-08-16 21:50:52 +00:00
}
//----------------------------------------------------------------------
DateFormat* U_EXPORT2
1999-08-16 21:50:52 +00:00
DateFormat::createInstance()
{
return create(kShort, (EStyle) (kShort + kDateOffset), Locale::getDefault());
}
//----------------------------------------------------------------------
DateFormat* U_EXPORT2
1999-08-16 21:50:52 +00:00
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.
1999-08-16 21:50:52 +00:00
SimpleDateFormat *f = new SimpleDateFormat(timeStyle, dateStyle, locale, status);
if (U_SUCCESS(status)) return f;
1999-08-16 21:50:52 +00:00
delete f;
// If that fails, try to create a format using the default pattern and
// the DateFormatSymbols for this locale.
status = U_ZERO_ERROR;
1999-08-16 21:50:52 +00:00
f = new SimpleDateFormat(locale, status);
if (U_SUCCESS(status)) return f;
1999-08-16 21:50:52 +00:00
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
1999-08-16 21:50:52 +00:00
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);
1999-08-16 21:50:52 +00:00
}
//----------------------------------------------------------------------
void
DateFormat::adoptCalendar(Calendar* newCalendar)
{
delete fCalendar;
fCalendar = newCalendar;
}
//----------------------------------------------------------------------
void
DateFormat::setCalendar(const Calendar& newCalendar)
{
Calendar* newCalClone = newCalendar.clone();
if (newCalClone != NULL) {
adoptCalendar(newCalClone);
}
1999-08-16 21:50:52 +00:00
}
//----------------------------------------------------------------------
const Calendar*
DateFormat::getCalendar() const
{
return fCalendar;
}
//----------------------------------------------------------------------
void
DateFormat::adoptNumberFormat(NumberFormat* newNumberFormat)
{
delete fNumberFormat;
fNumberFormat = newNumberFormat;
newNumberFormat->setParseIntegerOnly(TRUE);
1999-08-16 21:50:52 +00:00
}
//----------------------------------------------------------------------
void
DateFormat::setNumberFormat(const NumberFormat& newNumberFormat)
{
NumberFormat* newNumFmtClone = (NumberFormat*)newNumberFormat.clone();
if (newNumFmtClone != NULL) {
adoptNumberFormat(newNumFmtClone);
}
1999-08-16 21:50:52 +00:00
}
//----------------------------------------------------------------------
const NumberFormat*
DateFormat::getNumberFormat() const
{
return fNumberFormat;
}
//----------------------------------------------------------------------
void
DateFormat::adoptTimeZone(TimeZone* zone)
{
if (fCalendar != NULL) {
fCalendar->adoptTimeZone(zone);
}
1999-08-16 21:50:52 +00:00
}
//----------------------------------------------------------------------
void
DateFormat::setTimeZone(const TimeZone& zone)
{
if (fCalendar != NULL) {
fCalendar->setTimeZone(zone);
}
1999-08-16 21:50:52 +00:00
}
//----------------------------------------------------------------------
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());
1999-08-16 21:50:52 +00:00
}
//----------------------------------------------------------------------
void
DateFormat::setLenient(UBool lenient)
1999-08-16 21:50:52 +00:00
{
if (fCalendar != NULL) {
fCalendar->setLenient(lenient);
}
1999-08-16 21:50:52 +00:00
}
//----------------------------------------------------------------------
UBool
1999-08-16 21:50:52 +00:00
DateFormat::isLenient() const
{
if (fCalendar != NULL) {
return fCalendar->isLenient();
}
// fCalendar is rarely null
return FALSE;
1999-08-16 21:50:52 +00:00
}
//----------------------------------------------------------------------
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 */
1999-08-16 21:50:52 +00:00
//eof