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

/*
 *******************************************************************************
 * 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"

#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 "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),
    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 = (NumberFormat*)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(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);
    }
    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 fBoolFlags.get(attr);
}

U_NAMESPACE_END

#endif /* #if !UCONFIG_NO_FORMATTING */

//eof
Commit	Line	Data
b75a7d8f	1	/*
46f4442e	2	*******************************************************************************
57a6839d	3	* Copyright (C) 1997-2014, International Business Machines Corporation and *
46f4442e A	4	* others. All Rights Reserved. *
	5	*******************************************************************************
	6	*
	7	* File DATEFMT.CPP
	8	*
	9	* Modification History:
	10	*
	11	* Date Name Description
	12	* 02/19/97 aliu Converted from java.
	13	* 03/31/97 aliu Modified extensively to work with 50 locales.
	14	* 04/01/97 aliu Added support for centuries.
	15	* 08/12/97 aliu Fixed operator== to use Calendar::equivalentTo.
	16	* 07/20/98 stephen Changed ParsePosition initialization
	17	********************************************************************************
	18	*/
b75a7d8f A	19
	20	#include "unicode/utypes.h"
	21
	22	#if !UCONFIG_NO_FORMATTING
	23
374ca955	24	#include "unicode/ures.h"
b75a7d8f A	25	#include "unicode/datefmt.h"
b75a7d8f A	26	#include "unicode/smpdtfmt.h"
46f4442e	27	#include "unicode/dtptngen.h"
57a6839d	28	#include "unicode/udisplaycontext.h"
46f4442e	29	#include "reldtfmt.h"
b75a7d8f	30
73c04bcf A	31	#include "cstring.h"
	32	#include "windtfmt.h"
	33
374ca955 A	34	#if defined( U_DEBUG_CALSVC ) \|\| defined (U_DEBUG_CAL)
	35	#include <stdio.h>
	36	#endif
	37
b75a7d8f A	38	// *****************************************************************************
	39	// class DateFormat
	40	// *****************************************************************************
	41
	42	U_NAMESPACE_BEGIN
	43
	44	DateFormat::DateFormat()
	45	: fCalendar(0),
57a6839d A	46	fNumberFormat(0),
57a6839d A	47	fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
b75a7d8f A	48	{
	49	}
	50
	51	//----------------------------------------------------------------------
	52
	53	DateFormat::DateFormat(const DateFormat& other)
	54	: Format(other),
	55	fCalendar(0),
57a6839d A	56	fNumberFormat(0),
57a6839d A	57	fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
b75a7d8f A	58	{
	59	*this = other;
	60	}
	61
	62	//----------------------------------------------------------------------
	63
	64	DateFormat& DateFormat::operator=(const DateFormat& other)
	65	{
	66	if (this != &other)
	67	{
	68	delete fCalendar;
	69	delete fNumberFormat;
	70	if(other.fCalendar) {
	71	fCalendar = other.fCalendar->clone();
	72	} else {
	73	fCalendar = NULL;
	74	}
	75	if(other.fNumberFormat) {
	76	fNumberFormat = (NumberFormat*)other.fNumberFormat->clone();
	77	} else {
	78	fNumberFormat = NULL;
	79	}
57a6839d A	80	fBoolFlags = other.fBoolFlags;
57a6839d A	81	fCapitalizationContext = other.fCapitalizationContext;
b75a7d8f A	82	}
	83	return *this;
	84	}
	85
	86	//----------------------------------------------------------------------
	87
	88	DateFormat::~DateFormat()
	89	{
	90	delete fCalendar;
	91	delete fNumberFormat;
	92	}
	93
	94	//----------------------------------------------------------------------
	95
	96	UBool
	97	DateFormat::operator==(const Format& other) const
	98	{
	99	// This protected comparison operator should only be called by subclasses
	100	// which have confirmed that the other object being compared against is
	101	// an instance of a sublcass of DateFormat. THIS IS IMPORTANT.
	102
374ca955	103	// Format::operator== guarantees that this cast is safe
b75a7d8f A	104	DateFormat* fmt = (DateFormat*)&other;
	105
	106	return (this == fmt) \|\|
374ca955	107	(Format::operator==(other) &&
b75a7d8f	108	fCalendar&&(fCalendar->isEquivalentTo(*fmt->fCalendar)) &&
57a6839d A	109	(fNumberFormat && fNumberFormat == fmt->fNumberFormat) &&
57a6839d A	110	(fCapitalizationContext == fmt->fCapitalizationContext) );
b75a7d8f A	111	}
	112
	113	//----------------------------------------------------------------------
	114
	115	UnicodeString&
	116	DateFormat::format(const Formattable& obj,
	117	UnicodeString& appendTo,
	118	FieldPosition& fieldPosition,
	119	UErrorCode& status) const
	120	{
	121	if (U_FAILURE(status)) return appendTo;
	122
	123	// if the type of the Formattable is double or long, treat it as if it were a Date
	124	UDate date = 0;
	125	switch (obj.getType())
	126	{
	127	case Formattable::kDate:
	128	date = obj.getDate();
	129	break;
	130	case Formattable::kDouble:
	131	date = (UDate)obj.getDouble();
	132	break;
	133	case Formattable::kLong:
	134	date = (UDate)obj.getLong();
	135	break;
	136	default:
	137	status = U_ILLEGAL_ARGUMENT_ERROR;
	138	return appendTo;
	139	}
	140
	141	// Is this right?
	142	//if (fieldPosition.getBeginIndex() == fieldPosition.getEndIndex())
	143	// status = U_ILLEGAL_ARGUMENT_ERROR;
	144
	145	return format(date, appendTo, fieldPosition);
	146	}
	147
	148	//----------------------------------------------------------------------
	149
729e4ab9 A	150	UnicodeString&
	151	DateFormat::format(const Formattable& obj,
	152	UnicodeString& appendTo,
	153	FieldPositionIterator* posIter,
	154	UErrorCode& status) const
	155	{
	156	if (U_FAILURE(status)) return appendTo;
	157
	158	// if the type of the Formattable is double or long, treat it as if it were a Date
	159	UDate date = 0;
	160	switch (obj.getType())
	161	{
	162	case Formattable::kDate:
	163	date = obj.getDate();
	164	break;
	165	case Formattable::kDouble:
	166	date = (UDate)obj.getDouble();
	167	break;
	168	case Formattable::kLong:
	169	date = (UDate)obj.getLong();
	170	break;
	171	default:
	172	status = U_ILLEGAL_ARGUMENT_ERROR;
	173	return appendTo;
	174	}
	175
	176	// Is this right?
	177	//if (fieldPosition.getBeginIndex() == fieldPosition.getEndIndex())
	178	// status = U_ILLEGAL_ARGUMENT_ERROR;
	179
	180	return format(date, appendTo, posIter, status);
	181	}
	182
	183	//----------------------------------------------------------------------
	184
	185	// Default implementation for backwards compatibility, subclasses should implement.
	186	UnicodeString&
	187	DateFormat::format(Calendar& /* unused cal */,
	188	UnicodeString& appendTo,
	189	FieldPositionIterator* /* unused posIter */,
	190	UErrorCode& status) const {
	191	if (U_SUCCESS(status)) {
	192	status = U_UNSUPPORTED_ERROR;
	193	}
	194	return appendTo;
	195	}
	196
	197	//----------------------------------------------------------------------
	198
b75a7d8f A	199	UnicodeString&
	200	DateFormat::format(UDate date, UnicodeString& appendTo, FieldPosition& fieldPosition) const {
	201	if (fCalendar != NULL) {
4388f060 A	202	// Use a clone of our calendar instance
	203	Calendar* calClone = fCalendar->clone();
	204	if (calClone != NULL) {
	205	UErrorCode ec = U_ZERO_ERROR;
	206	calClone->setTime(date, ec);
	207	if (U_SUCCESS(ec)) {
	208	format(*calClone, appendTo, fieldPosition);
	209	}
	210	delete calClone;
b75a7d8f A	211	}
	212	}
	213	return appendTo;
	214	}
	215
	216	//----------------------------------------------------------------------
	217
729e4ab9 A	218	UnicodeString&
	219	DateFormat::format(UDate date, UnicodeString& appendTo, FieldPositionIterator* posIter,
	220	UErrorCode& status) const {
	221	if (fCalendar != NULL) {
4388f060 A	222	Calendar* calClone = fCalendar->clone();
	223	if (calClone != NULL) {
	224	calClone->setTime(date, status);
	225	if (U_SUCCESS(status)) {
	226	format(*calClone, appendTo, posIter, status);
	227	}
	228	delete calClone;
729e4ab9 A	229	}
	230	}
	231	return appendTo;
	232	}
	233
	234	//----------------------------------------------------------------------
	235
b75a7d8f A	236	UnicodeString&
	237	DateFormat::format(UDate date, UnicodeString& appendTo) const
	238	{
	239	// Note that any error information is just lost. That's okay
	240	// for this convenience method.
	241	FieldPosition fpos(0);
	242	return format(date, appendTo, fpos);
	243	}
	244
	245	//----------------------------------------------------------------------
	246
	247	UDate
	248	DateFormat::parse(const UnicodeString& text,
	249	ParsePosition& pos) const
	250	{
46f4442e	251	UDate d = 0; // Error return UDate is 0 (the epoch)
b75a7d8f	252	if (fCalendar != NULL) {
4388f060 A	253	Calendar* calClone = fCalendar->clone();
	254	if (calClone != NULL) {
	255	int32_t start = pos.getIndex();
	256	calClone->clear();
	257	parse(text, *calClone, pos);
	258	if (pos.getIndex() != start) {
	259	UErrorCode ec = U_ZERO_ERROR;
	260	d = calClone->getTime(ec);
	261	if (U_FAILURE(ec)) {
	262	// We arrive here if fCalendar => calClone is non-lenient and
	263	// there is an out-of-range field. We don't know which field
	264	// was illegal so we set the error index to the start.
	265	pos.setIndex(start);
	266	pos.setErrorIndex(start);
	267	d = 0;
	268	}
b75a7d8f	269	}
4388f060	270	delete calClone;
b75a7d8f A	271	}
b75a7d8f A	272	}
46f4442e	273	return d;
b75a7d8f A	274	}
	275
	276	//----------------------------------------------------------------------
	277
	278	UDate
	279	DateFormat::parse(const UnicodeString& text,
	280	UErrorCode& status) const
	281	{
	282	if (U_FAILURE(status)) return 0;
	283
	284	ParsePosition pos(0);
	285	UDate result = parse(text, pos);
374ca955 A	286	if (pos.getIndex() == 0) {
	287	#if defined (U_DEBUG_CAL)
	288	fprintf(stderr, "%s:%d - - failed to parse - err index %d\n"
	289	, __FILE__, __LINE__, pos.getErrorIndex() );
	290	#endif
	291	status = U_ILLEGAL_ARGUMENT_ERROR;
	292	}
b75a7d8f A	293	return result;
	294	}
	295
	296	//----------------------------------------------------------------------
	297
	298	void
	299	DateFormat::parseObject(const UnicodeString& source,
	300	Formattable& result,
	301	ParsePosition& pos) const
	302	{
	303	result.setDate(parse(source, pos));
	304	}
	305
	306	//----------------------------------------------------------------------
	307
374ca955	308	DateFormat* U_EXPORT2
b75a7d8f A	309	DateFormat::createTimeInstance(DateFormat::EStyle style,
	310	const Locale& aLocale)
	311	{
	312	return create(style, kNone, aLocale);
	313	}
	314
	315	//----------------------------------------------------------------------
	316
374ca955	317	DateFormat* U_EXPORT2
b75a7d8f A	318	DateFormat::createDateInstance(DateFormat::EStyle style,
	319	const Locale& aLocale)
	320	{
374ca955 A	321	// +4 to set the correct index for getting data out of
	322	// LocaleElements.
	323	if(style != kNone)
	324	{
	325	style = (EStyle) (style + kDateOffset);
	326	}
	327	return create(kNone, (EStyle) (style), aLocale);
b75a7d8f A	328	}
	329
	330	//----------------------------------------------------------------------
	331
374ca955	332	DateFormat* U_EXPORT2
b75a7d8f A	333	DateFormat::createDateTimeInstance(EStyle dateStyle,
	334	EStyle timeStyle,
	335	const Locale& aLocale)
	336	{
374ca955 A	337	if(dateStyle != kNone)
	338	{
	339	dateStyle = (EStyle) (dateStyle + kDateOffset);
	340	}
	341	return create(timeStyle, dateStyle, aLocale);
b75a7d8f A	342	}
	343
	344	//----------------------------------------------------------------------
	345
374ca955	346	DateFormat* U_EXPORT2
b75a7d8f A	347	DateFormat::createInstance()
	348	{
	349	return create(kShort, (EStyle) (kShort + kDateOffset), Locale::getDefault());
	350	}
	351
	352	//----------------------------------------------------------------------
	353
374ca955	354	DateFormat* U_EXPORT2
b75a7d8f A	355	DateFormat::create(EStyle timeStyle, EStyle dateStyle, const Locale& locale)
b75a7d8f A	356	{
b75a7d8f	357	UErrorCode status = U_ZERO_ERROR;
4388f060	358	#if U_PLATFORM_HAS_WIN32_API
73c04bcf A	359	char buffer[8];
	360	int32_t count = locale.getKeywordValue("compat", buffer, sizeof(buffer), status);
	361
	362	// if the locale has "@compat=host", create a host-specific DateFormat...
	363	if (count > 0 && uprv_strcmp(buffer, "host") == 0) {
	364	Win32DateFormat *f = new Win32DateFormat(timeStyle, dateStyle, locale, status);
	365
	366	if (U_SUCCESS(status)) {
	367	return f;
	368	}
	369
	370	delete f;
	371	}
	372	#endif
	373
46f4442e A	374	// is it relative?
	375	if(/((timeStyle!=UDAT_NONE)&&(timeStyle & UDAT_RELATIVE)) \|\| /((dateStyle!=kNone)&&((dateStyle-kDateOffset) & UDAT_RELATIVE))) {
	376	RelativeDateFormat *r = new RelativeDateFormat((UDateFormatStyle)timeStyle, (UDateFormatStyle)(dateStyle-kDateOffset), locale, status);
	377	if(U_SUCCESS(status)) return r;
	378	delete r;
	379	status = U_ZERO_ERROR;
	380	}
73c04bcf A	381
73c04bcf A	382	// Try to create a SimpleDateFormat of the desired style.
b75a7d8f A	383	SimpleDateFormat *f = new SimpleDateFormat(timeStyle, dateStyle, locale, status);
	384	if (U_SUCCESS(status)) return f;
	385	delete f;
	386
	387	// If that fails, try to create a format using the default pattern and
	388	// the DateFormatSymbols for this locale.
	389	status = U_ZERO_ERROR;
	390	f = new SimpleDateFormat(locale, status);
	391	if (U_SUCCESS(status)) return f;
	392	delete f;
	393
	394	// This should never really happen, because the preceding constructor
	395	// should always succeed. If the resource data is unavailable, a last
	396	// resort object should be returned.
	397	return 0;
	398	}
	399
	400	//----------------------------------------------------------------------
	401
374ca955	402	const Locale* U_EXPORT2
b75a7d8f A	403	DateFormat::getAvailableLocales(int32_t& count)
	404	{
	405	// Get the list of installed locales.
	406	// Even if root has the correct date format for this locale,
	407	// it's still a valid locale (we don't worry about data fallbacks).
	408	return Locale::getAvailableLocales(count);
	409	}
	410
	411	//----------------------------------------------------------------------
	412
	413	void
	414	DateFormat::adoptCalendar(Calendar* newCalendar)
	415	{
	416	delete fCalendar;
	417	fCalendar = newCalendar;
	418	}
	419
	420	//----------------------------------------------------------------------
	421	void
	422	DateFormat::setCalendar(const Calendar& newCalendar)
	423	{
46f4442e A	424	Calendar* newCalClone = newCalendar.clone();
	425	if (newCalClone != NULL) {
	426	adoptCalendar(newCalClone);
	427	}
b75a7d8f A	428	}
	429
	430	//----------------------------------------------------------------------
	431
	432	const Calendar*
	433	DateFormat::getCalendar() const
	434	{
	435	return fCalendar;
	436	}
	437
	438	//----------------------------------------------------------------------
	439
	440	void
	441	DateFormat::adoptNumberFormat(NumberFormat* newNumberFormat)
	442	{
	443	delete fNumberFormat;
	444	fNumberFormat = newNumberFormat;
	445	newNumberFormat->setParseIntegerOnly(TRUE);
	446	}
	447	//----------------------------------------------------------------------
	448
	449	void
	450	DateFormat::setNumberFormat(const NumberFormat& newNumberFormat)
	451	{
46f4442e A	452	NumberFormat* newNumFmtClone = (NumberFormat*)newNumberFormat.clone();
	453	if (newNumFmtClone != NULL) {
	454	adoptNumberFormat(newNumFmtClone);
	455	}
b75a7d8f A	456	}
	457
	458	//----------------------------------------------------------------------
	459
	460	const NumberFormat*
	461	DateFormat::getNumberFormat() const
	462	{
	463	return fNumberFormat;
	464	}
	465
	466	//----------------------------------------------------------------------
	467
	468	void
	469	DateFormat::adoptTimeZone(TimeZone* zone)
	470	{
46f4442e A	471	if (fCalendar != NULL) {
	472	fCalendar->adoptTimeZone(zone);
	473	}
b75a7d8f A	474	}
	475	//----------------------------------------------------------------------
	476
	477	void
	478	DateFormat::setTimeZone(const TimeZone& zone)
	479	{
46f4442e A	480	if (fCalendar != NULL) {
	481	fCalendar->setTimeZone(zone);
	482	}
b75a7d8f A	483	}
	484
	485	//----------------------------------------------------------------------
	486
	487	const TimeZone&
	488	DateFormat::getTimeZone() const
	489	{
46f4442e A	490	if (fCalendar != NULL) {
	491	return fCalendar->getTimeZone();
	492	}
	493	// If calendar doesn't exists, create default timezone.
	494	// fCalendar is rarely null
	495	return *(TimeZone::createDefault());
b75a7d8f A	496	}
	497
	498	//----------------------------------------------------------------------
	499
	500	void
	501	DateFormat::setLenient(UBool lenient)
	502	{
46f4442e A	503	if (fCalendar != NULL) {
	504	fCalendar->setLenient(lenient);
	505	}
57a6839d A	506	UErrorCode status = U_ZERO_ERROR;
	507	setBooleanAttribute(UDAT_PARSE_ALLOW_WHITESPACE, lenient, status);
	508	setBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, lenient, status);
b75a7d8f A	509	}
	510
	511	//----------------------------------------------------------------------
	512
	513	UBool
	514	DateFormat::isLenient() const
57a6839d A	515	{
	516	UBool lenient = TRUE;
	517	if (fCalendar != NULL) {
	518	lenient = fCalendar->isLenient();
	519	}
	520	UErrorCode status = U_ZERO_ERROR;
	521	return lenient
	522	&& getBooleanAttribute(UDAT_PARSE_ALLOW_WHITESPACE, status)
	523	&& getBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, status);
	524	}
	525
	526	void
	527	DateFormat::setCalendarLenient(UBool lenient)
	528	{
	529	if (fCalendar != NULL) {
	530	fCalendar->setLenient(lenient);
	531	}
	532	}
	533
	534	//----------------------------------------------------------------------
	535
	536	UBool
	537	DateFormat::isCalendarLenient() const
b75a7d8f	538	{
46f4442e A	539	if (fCalendar != NULL) {
	540	return fCalendar->isLenient();
	541	}
	542	// fCalendar is rarely null
	543	return FALSE;
b75a7d8f A	544	}
b75a7d8f A	545
57a6839d A	546
	547	//----------------------------------------------------------------------
	548
	549
	550	void DateFormat::setContext(UDisplayContext value, UErrorCode& status)
	551	{
	552	if (U_FAILURE(status))
	553	return;
	554	if ( (UDisplayContextType)((uint32_t)value >> 8) == UDISPCTX_TYPE_CAPITALIZATION ) {
	555	fCapitalizationContext = value;
	556	} else {
	557	status = U_ILLEGAL_ARGUMENT_ERROR;
	558	}
	559	}
	560
	561
	562	//----------------------------------------------------------------------
	563
	564
	565	UDisplayContext DateFormat::getContext(UDisplayContextType type, UErrorCode& status) const
	566	{
	567	if (U_FAILURE(status))
	568	return (UDisplayContext)0;
	569	if (type != UDISPCTX_TYPE_CAPITALIZATION) {
	570	status = U_ILLEGAL_ARGUMENT_ERROR;
	571	return (UDisplayContext)0;
	572	}
	573	return fCapitalizationContext;
	574	}
	575
	576
	577	//----------------------------------------------------------------------
	578
	579
	580	DateFormat&
	581	DateFormat::setBooleanAttribute(UDateFormatBooleanAttribute attr,
	582	UBool newValue,
	583	UErrorCode &status) {
	584	if(!fBoolFlags.isValidValue(newValue)) {
	585	status = U_ILLEGAL_ARGUMENT_ERROR;
	586	} else {
	587	fBoolFlags.set(attr, newValue);
	588	}
	589
	590	return *this;
	591	}
	592
	593	//----------------------------------------------------------------------
	594
	595	UBool
	596	DateFormat::getBooleanAttribute(UDateFormatBooleanAttribute attr, UErrorCode &/status/) const {
	597
	598	return fBoolFlags.get(attr);
	599	}
	600
b75a7d8f A	601	U_NAMESPACE_END
	602
	603	#endif /* #if !UCONFIG_NO_FORMATTING */
	604
	605	//eof