[apple/icu.git] / icuSources / test / intltest / fldset.cpp

/*
************************************************************************
* Copyright (c) 2007-2011, International Business Machines
* Corporation and others.  All Rights Reserved.
************************************************************************
*/

#include "fldset.h"
#include "intltest.h"

#if !UCONFIG_NO_FORMATTING
#include "unicode/regex.h"


FieldsSet::FieldsSet() {
    // NOTREACHED
}

FieldsSet::FieldsSet(int32_t fieldCount) {
    construct((UDebugEnumType)-1, fieldCount);
}

FieldsSet::FieldsSet(UDebugEnumType field) {
    construct(field, udbg_enumCount(field));
}

FieldsSet::~FieldsSet() {
    
}

int32_t FieldsSet::fieldCount() const {
    return fFieldCount;
}

void FieldsSet::construct(UDebugEnumType field, int32_t fieldCount) {
    fEnum = field;
    if(fieldCount > U_FIELDS_SET_MAX) {
        fieldCount = U_FIELDS_SET_MAX;
    }
    fFieldCount = fieldCount;
    clear();
}

UnicodeString FieldsSet::diffFrom(const FieldsSet& other, UErrorCode& status) const {
    UnicodeString str;
    if(!isSameType(other)) {
        status = U_ILLEGAL_ARGUMENT_ERROR;
        return UnicodeString("U_ILLEGAL_ARGUMENT_ERROR: FieldsSet of a different type!");
    }
    for (int i=0; i<fieldCount(); i++) {
        if (isSet((UCalendarDateFields)i)) {
            int32_t myVal = get(i);
            int32_t theirVal = other.get(i);
            
            if(fEnum != -1) {
                const UnicodeString& fieldName = udbg_enumString(
                        fEnum, i);

                str = str + fieldName + UnicodeString("=")+myVal+UnicodeString(" not ")+theirVal+UnicodeString(", ");
            } else {
                str = str + UnicodeString("some field") + "=" + myVal+" not " + theirVal+", ";
            }
        }
    }
    return str;
}

static UnicodeString *split(const UnicodeString &src, UChar ch, int32_t &splits)
{
    int32_t offset = -1;

    splits = 1;
    while((offset = src.indexOf(ch, offset + 1)) >= 0) {
        splits += 1;
    }

    UnicodeString *result = new UnicodeString[splits];

    int32_t start = 0;
    int32_t split = 0;
    int32_t end;

    while((end = src.indexOf(ch, start)) >= 0) {
        src.extractBetween(start, end, result[split++]);
        start = end + 1;
    }

    src.extractBetween(start, src.length(), result[split]);

    return result;
}

int32_t FieldsSet::parseFrom(const UnicodeString& str, const 
        FieldsSet* inheritFrom, UErrorCode& status) {

    int goodFields = 0;

    if(U_FAILURE(status)) {
        return -1;
    }

    int32_t destCount = 0;
    UnicodeString *dest = split(str, 0x002C /* ',' */, destCount);

    for(int i = 0; i < destCount; i += 1) {
        int32_t dc = 0;
        UnicodeString *kv = split(dest[i], 0x003D /* '=' */, dc);

        if(dc != 2) {
            it_errln(UnicodeString("dc == ") + dc + UnicodeString("?"));
        }

        int32_t field = handleParseName(inheritFrom, kv[0], kv[1], status);

        if(U_FAILURE(status)) {
            char ch[256];
            const UChar *u = kv[0].getBuffer();
            int32_t len = kv[0].length();
            u_UCharsToChars(u, ch, len);
            ch[len] = 0; /* include terminating \0 */
            it_errln(UnicodeString("Parse Failed: Field ") + UnicodeString(ch) + UnicodeString(", err ") + UnicodeString(u_errorName(status)));
            delete[] kv;
            delete[] dest;
            return -1;
        }

        if(field != -1) {
            handleParseValue(inheritFrom, field, kv[1], status);

            if(U_FAILURE(status)) {
                char ch[256];
                const UChar *u = kv[1].getBuffer();
                int32_t len = kv[1].length();
                u_UCharsToChars(u, ch, len);
                ch[len] = 0; /* include terminating \0 */
                it_errln(UnicodeString("Parse Failed: Value ") + UnicodeString(ch) + UnicodeString(", err ") + UnicodeString(u_errorName(status)));
                delete[] kv;
                delete[] dest;
                return -1;
            }

            goodFields += 1;
        }

        delete[] kv;
    }

    delete[] dest;

    return goodFields;
}

UBool FieldsSet::isSameType(const FieldsSet& other) const {
    return((&other==this)||
           ((other.fFieldCount==fFieldCount) && (other.fEnum==fEnum)));  
}

void FieldsSet::clear() {
    for (int i=0; i<fieldCount(); i++) {
        fValue[i]=-1;
        fIsSet[i]=FALSE;
    }
}

void FieldsSet::clear(int32_t field) {
    if (field<0|| field>=fieldCount()) {
        return;
    }
    fValue[field] = -1;
    fIsSet[field] = FALSE;
}
void FieldsSet::set(int32_t field, int32_t amount) {
    if (field<0|| field>=fieldCount()) {
        return;
    }
    fValue[field] = amount;
    fIsSet[field] = TRUE;
}

UBool FieldsSet::isSet(int32_t field) const {
    if (field<0|| field>=fieldCount()) {
        return FALSE;
    }
    return fIsSet[field];
}
int32_t FieldsSet::get(int32_t field) const {
    if (field<0|| field>=fieldCount()) {
        return -1;
    }
    return fValue[field];
}


int32_t FieldsSet::handleParseName(const FieldsSet* /* inheritFrom */, const UnicodeString& name, const UnicodeString& /* substr*/ , UErrorCode& status) {
    if(fEnum > -1) {
        int32_t which = udbg_enumByString(fEnum, name);
        if(which == UDBG_INVALID_ENUM) {
            status = U_UNSUPPORTED_ERROR;
        }
        return which;
    } else {
        status = U_UNSUPPORTED_ERROR;
        return -1;
    }
}

void FieldsSet::parseValueDefault(const FieldsSet* inheritFrom, int32_t field, const UnicodeString& substr, UErrorCode& status) {
    int32_t value = -1;
    if(substr.length()==0) { // inherit requested
        // inherit
        if((inheritFrom == NULL) || !inheritFrom->isSet((UCalendarDateFields)field)) {
            // couldn't inherit from field 
            it_errln(UnicodeString("Parse Failed: Couldn't inherit field ") + field + UnicodeString(" [") + UnicodeString(udbg_enumName(fEnum, field)) + UnicodeString("]"));
            status = U_ILLEGAL_ARGUMENT_ERROR;
            return;
        }
        value = inheritFrom->get((UCalendarDateFields)field);
    } else {        
        value = udbg_stoi(substr);
    }
    set(field, value);
}

void FieldsSet::parseValueEnum(UDebugEnumType type, const FieldsSet* inheritFrom, int32_t field, const UnicodeString& substr, UErrorCode& status) {
    int32_t value = udbg_enumByString(type, substr);
    if(value>=0) {
        set(field, value);
    } else {
        // fallback
        parseValueDefault(inheritFrom,field,substr,status);
    }
}

void FieldsSet::handleParseValue(const FieldsSet* inheritFrom, int32_t field, const UnicodeString& substr, UErrorCode& status) {
    parseValueDefault(inheritFrom, field, substr, status);
}

/// CAL FIELDS


CalendarFieldsSet::CalendarFieldsSet() :
FieldsSet(UDBG_UCalendarDateFields) {
    // base class will call clear.
}

CalendarFieldsSet::~CalendarFieldsSet() {
}

void CalendarFieldsSet::handleParseValue(const FieldsSet* inheritFrom, int32_t field, const UnicodeString& substr, UErrorCode& status) {
    if(field==UCAL_MONTH) {
        parseValueEnum(UDBG_UCalendarMonths, inheritFrom, field, substr, status);
        // will fallback to default.
    } else {
        parseValueDefault(inheritFrom, field, substr, status);
    }
}

/**
 * set the specified fields on this calendar. Doesn't clear first. Returns any errors the caller 
 */
void CalendarFieldsSet::setOnCalendar(Calendar *cal, UErrorCode& /*status*/) const {
    for (int i=0; i<UDAT_FIELD_COUNT; i++) {
        if (isSet((UCalendarDateFields)i)) {
            int32_t value = get((UCalendarDateFields)i);
            cal->set((UCalendarDateFields)i, value);
        }
    }
}

/**
 * return true if the calendar matches in these fields
 */
UBool CalendarFieldsSet::matches(Calendar *cal, CalendarFieldsSet &diffSet,
        UErrorCode& status) const {
    UBool match = TRUE;
    if (U_FAILURE(status)) {
        return FALSE;
    }
    for (int i=0; i<UDAT_FIELD_COUNT; i++) {
        if (isSet((UCalendarDateFields)i)) {
            int32_t calVal = cal->get((UCalendarDateFields)i, status);
            if (U_FAILURE(status))
                return FALSE;
            if (calVal != get((UCalendarDateFields)i)) {
                match = FALSE;
                diffSet.set((UCalendarDateFields)i, calVal);
                //fprintf(stderr, "match failed: %s#%d=%d != %d\n",udbg_enumName(UDBG_UCalendarDateFields,i),i,cal->get((UCalendarDateFields)i,status), get((UCalendarDateFields)i));;
            }
        }
    }
    return match;
}


/**
 * DateTimeStyleSet has two 'fields' -- date, and time.
 */
enum DateTimeStyleSetFields {
    DTS_DATE = 0,  /** Field one: the date (long, medium, short, etc). */
    DTS_TIME,      /** Field two: the time (long, medium, short, etc). */
    DTS_COUNT      /** The number of fields */
};

/**
 * DateTimeSet 
 * */
DateTimeStyleSet::DateTimeStyleSet() :
    FieldsSet(DTS_COUNT) {
}

DateTimeStyleSet::~DateTimeStyleSet() {
    
}

UDateFormatStyle DateTimeStyleSet::getDateStyle() const {
    if(!isSet(DTS_DATE)) {
        return UDAT_NONE;
    } else {
        return (UDateFormatStyle)get(DTS_DATE);
    }
}


UDateFormatStyle DateTimeStyleSet::getTimeStyle() const {
    if(!isSet(DTS_TIME)) {
        return UDAT_NONE;
    } else {
        return (UDateFormatStyle)get(DTS_TIME);
    }
}

void DateTimeStyleSet::handleParseValue(const FieldsSet* inheritFrom, int32_t field, const UnicodeString& substr, UErrorCode& status) {
    UnicodeString kRELATIVE_("RELATIVE_");
    if(substr.startsWith(kRELATIVE_)) {
        UnicodeString relativeas(substr,kRELATIVE_.length());
        parseValueEnum(UDBG_UDateFormatStyle, inheritFrom, field, relativeas, status);
        // fix relative value
        if(isSet(field) && U_SUCCESS(status)) {
            set(field, get(field) | UDAT_RELATIVE);
        }
    } else {
        parseValueEnum(UDBG_UDateFormatStyle, inheritFrom, field, substr, status);
    }
}

int32_t DateTimeStyleSet::handleParseName(const FieldsSet* /* inheritFrom */, const UnicodeString& name, const UnicodeString& /* substr */, UErrorCode& status) {
    UnicodeString kDATE("DATE"); // TODO: static
    UnicodeString kTIME("TIME"); // TODO: static
    if(name == kDATE ) { 
        return DTS_DATE;
    } else if(name == kTIME) {
        return DTS_TIME;
    } else {
        status = U_ILLEGAL_ARGUMENT_ERROR;
        return -1;   
    }
}

#endif /*!UCONFIG_NO_FORMAT*/
Commit	Line	Data
46f4442e A	1	/*
46f4442e A	2	************************************************************************
4388f060	3	* Copyright (c) 2007-2011, International Business Machines
46f4442e A	4	* Corporation and others. All Rights Reserved.
	5	************************************************************************
	6	*/
	7
	8	#include "fldset.h"
	9	#include "intltest.h"
	10
	11	#if !UCONFIG_NO_FORMATTING
	12	#include "unicode/regex.h"
	13
	14
	15	FieldsSet::FieldsSet() {
	16	// NOTREACHED
	17	}
	18
	19	FieldsSet::FieldsSet(int32_t fieldCount) {
	20	construct((UDebugEnumType)-1, fieldCount);
	21	}
	22
	23	FieldsSet::FieldsSet(UDebugEnumType field) {
	24	construct(field, udbg_enumCount(field));
	25	}
	26
	27	FieldsSet::~FieldsSet() {
	28
	29	}
	30
	31	int32_t FieldsSet::fieldCount() const {
	32	return fFieldCount;
	33	}
	34
	35	void FieldsSet::construct(UDebugEnumType field, int32_t fieldCount) {
	36	fEnum = field;
	37	if(fieldCount > U_FIELDS_SET_MAX) {
	38	fieldCount = U_FIELDS_SET_MAX;
	39	}
	40	fFieldCount = fieldCount;
	41	clear();
	42	}
	43
	44	UnicodeString FieldsSet::diffFrom(const FieldsSet& other, UErrorCode& status) const {
	45	UnicodeString str;
	46	if(!isSameType(other)) {
	47	status = U_ILLEGAL_ARGUMENT_ERROR;
	48	return UnicodeString("U_ILLEGAL_ARGUMENT_ERROR: FieldsSet of a different type!");
	49	}
	50	for (int i=0; i<fieldCount(); i++) {
	51	if (isSet((UCalendarDateFields)i)) {
	52	int32_t myVal = get(i);
	53	int32_t theirVal = other.get(i);
	54
	55	if(fEnum != -1) {
	56	const UnicodeString& fieldName = udbg_enumString(
	57	fEnum, i);
	58
	59	str = str + fieldName + UnicodeString("=")+myVal+UnicodeString(" not ")+theirVal+UnicodeString(", ");
	60	} else {
	61	str = str + UnicodeString("some field") + "=" + myVal+" not " + theirVal+", ";
	62	}
	63	}
	64	}
	65	return str;
	66	}
	67
68	static UnicodeString *split(const UnicodeString &src, UChar ch, int32_t &splits)
69	{
70	int32_t offset = -1;
71
72	splits = 1;
73	while((offset = src.indexOf(ch, offset + 1)) >= 0) {
74	splits += 1;
75	}
76
77	UnicodeString *result = new UnicodeString[splits];
78
79	int32_t start = 0;
80	int32_t split = 0;
81	int32_t end;
82
83	while((end = src.indexOf(ch, start)) >= 0) {
84	src.extractBetween(start, end, result[split++]);
85	start = end + 1;
86	}
87
88	src.extractBetween(start, src.length(), result[split]);
89
90	return result;
91	}
92
93	int32_t FieldsSet::parseFrom(const UnicodeString& str, const
94	FieldsSet* inheritFrom, UErrorCode& status) {
95
96	int goodFields = 0;
97
98	if(U_FAILURE(status)) {
99	return -1;
100	}
101
102	int32_t destCount = 0;
103	UnicodeString dest = split(str, 0x002C / ',' */, destCount);
104
105	for(int i = 0; i < destCount; i += 1) {
106	int32_t dc = 0;
107	UnicodeString kv = split(dest[i], 0x003D / '=' */, dc);
108
109	if(dc != 2) {
110	it_errln(UnicodeString("dc == ") + dc + UnicodeString("?"));
111	}
112
113	int32_t field = handleParseName(inheritFrom, kv[0], kv[1], status);
114
115	if(U_FAILURE(status)) {
116	char ch[256];
117	const UChar *u = kv[0].getBuffer();
118	int32_t len = kv[0].length();
119	u_UCharsToChars(u, ch, len);
120	ch[len] = 0; /* include terminating \0 */
121	it_errln(UnicodeString("Parse Failed: Field ") + UnicodeString(ch) + UnicodeString(", err ") + UnicodeString(u_errorName(status)));
4388f060 A	122	delete[] kv;
4388f060 A	123	delete[] dest;
46f4442e A	124	return -1;
	125	}
	126
	127	if(field != -1) {
	128	handleParseValue(inheritFrom, field, kv[1], status);
	129
	130	if(U_FAILURE(status)) {
	131	char ch[256];
	132	const UChar *u = kv[1].getBuffer();
	133	int32_t len = kv[1].length();
	134	u_UCharsToChars(u, ch, len);
	135	ch[len] = 0; /* include terminating \0 */
	136	it_errln(UnicodeString("Parse Failed: Value ") + UnicodeString(ch) + UnicodeString(", err ") + UnicodeString(u_errorName(status)));
4388f060 A	137	delete[] kv;
4388f060 A	138	delete[] dest;
46f4442e A	139	return -1;
	140	}
	141
	142	goodFields += 1;
	143	}
	144
	145	delete[] kv;
	146	}
	147
	148	delete[] dest;
	149
	150	return goodFields;
	151	}
	152
	153	UBool FieldsSet::isSameType(const FieldsSet& other) const {
	154	return((&other==this)\|\|
	155	((other.fFieldCount==fFieldCount) && (other.fEnum==fEnum)));
	156	}
	157
	158	void FieldsSet::clear() {
	159	for (int i=0; i<fieldCount(); i++) {
	160	fValue[i]=-1;
	161	fIsSet[i]=FALSE;
	162	}
	163	}
	164
	165	void FieldsSet::clear(int32_t field) {
	166	if (field<0\|\| field>=fieldCount()) {
	167	return;
	168	}
	169	fValue[field] = -1;
	170	fIsSet[field] = FALSE;
	171	}
	172	void FieldsSet::set(int32_t field, int32_t amount) {
	173	if (field<0\|\| field>=fieldCount()) {
	174	return;
	175	}
	176	fValue[field] = amount;
	177	fIsSet[field] = TRUE;
	178	}
	179
	180	UBool FieldsSet::isSet(int32_t field) const {
	181	if (field<0\|\| field>=fieldCount()) {
	182	return FALSE;
	183	}
	184	return fIsSet[field];
	185	}
	186	int32_t FieldsSet::get(int32_t field) const {
	187	if (field<0\|\| field>=fieldCount()) {
	188	return -1;
	189	}
	190	return fValue[field];
	191	}
	192
	193
	194	int32_t FieldsSet::handleParseName(const FieldsSet* /* inheritFrom /, const UnicodeString& name, const UnicodeString& / substr*/ , UErrorCode& status) {
	195	if(fEnum > -1) {
729e4ab9 A	196	int32_t which = udbg_enumByString(fEnum, name);
	197	if(which == UDBG_INVALID_ENUM) {
	198	status = U_UNSUPPORTED_ERROR;
	199	}
	200	return which;
46f4442e A	201	} else {
	202	status = U_UNSUPPORTED_ERROR;
	203	return -1;
	204	}
	205	}
	206
	207	void FieldsSet::parseValueDefault(const FieldsSet* inheritFrom, int32_t field, const UnicodeString& substr, UErrorCode& status) {
	208	int32_t value = -1;
	209	if(substr.length()==0) { // inherit requested
	210	// inherit
	211	if((inheritFrom == NULL) \|\| !inheritFrom->isSet((UCalendarDateFields)field)) {
	212	// couldn't inherit from field
	213	it_errln(UnicodeString("Parse Failed: Couldn't inherit field ") + field + UnicodeString(" [") + UnicodeString(udbg_enumName(fEnum, field)) + UnicodeString("]"));
	214	status = U_ILLEGAL_ARGUMENT_ERROR;
	215	return;
	216	}
	217	value = inheritFrom->get((UCalendarDateFields)field);
	218	} else {
	219	value = udbg_stoi(substr);
	220	}
	221	set(field, value);
	222	}
	223
	224	void FieldsSet::parseValueEnum(UDebugEnumType type, const FieldsSet* inheritFrom, int32_t field, const UnicodeString& substr, UErrorCode& status) {
	225	int32_t value = udbg_enumByString(type, substr);
	226	if(value>=0) {
	227	set(field, value);
	228	} else {
	229	// fallback
	230	parseValueDefault(inheritFrom,field,substr,status);
	231	}
	232	}
	233
	234	void FieldsSet::handleParseValue(const FieldsSet* inheritFrom, int32_t field, const UnicodeString& substr, UErrorCode& status) {
	235	parseValueDefault(inheritFrom, field, substr, status);
	236	}
	237
	238	/// CAL FIELDS
	239
	240
	241	CalendarFieldsSet::CalendarFieldsSet() :
	242	FieldsSet(UDBG_UCalendarDateFields) {
	243	// base class will call clear.
	244	}
	245
	246	CalendarFieldsSet::~CalendarFieldsSet() {
	247	}
	248
	249	void CalendarFieldsSet::handleParseValue(const FieldsSet* inheritFrom, int32_t field, const UnicodeString& substr, UErrorCode& status) {
	250	if(field==UCAL_MONTH) {
	251	parseValueEnum(UDBG_UCalendarMonths, inheritFrom, field, substr, status);
	252	// will fallback to default.
	253	} else {
	254	parseValueDefault(inheritFrom, field, substr, status);
	255	}
	256	}
	257
	258	/**
	259	* set the specified fields on this calendar. Doesn't clear first. Returns any errors the caller
	260	*/
	261	void CalendarFieldsSet::setOnCalendar(Calendar cal, UErrorCode& /status*/) const {
	262	for (int i=0; i<UDAT_FIELD_COUNT; i++) {
	263	if (isSet((UCalendarDateFields)i)) {
	264	int32_t value = get((UCalendarDateFields)i);
46f4442e A	265	cal->set((UCalendarDateFields)i, value);
	266	}
	267	}
	268	}
	269
	270	/**
	271	* return true if the calendar matches in these fields
	272	*/
	273	UBool CalendarFieldsSet::matches(Calendar *cal, CalendarFieldsSet &diffSet,
	274	UErrorCode& status) const {
	275	UBool match = TRUE;
729e4ab9	276	if (U_FAILURE(status)) {
46f4442e	277	return FALSE;
729e4ab9	278	}
46f4442e A	279	for (int i=0; i<UDAT_FIELD_COUNT; i++) {
	280	if (isSet((UCalendarDateFields)i)) {
	281	int32_t calVal = cal->get((UCalendarDateFields)i, status);
	282	if (U_FAILURE(status))
	283	return FALSE;
	284	if (calVal != get((UCalendarDateFields)i)) {
	285	match = FALSE;
	286	diffSet.set((UCalendarDateFields)i, calVal);
	287	//fprintf(stderr, "match failed: %s#%d=%d != %d\n",udbg_enumName(UDBG_UCalendarDateFields,i),i,cal->get((UCalendarDateFields)i,status), get((UCalendarDateFields)i));;
	288	}
	289	}
	290	}
	291	return match;
	292	}
	293
	294
729e4ab9 A	295	/**
	296	* DateTimeStyleSet has two 'fields' -- date, and time.
	297	*/
	298	enum DateTimeStyleSetFields {
	299	DTS_DATE = 0, /** Field one: the date (long, medium, short, etc). */
	300	DTS_TIME, /** Field two: the time (long, medium, short, etc). */
	301	DTS_COUNT /** The number of fields */
46f4442e A	302	};
	303
	304	/**
	305	* DateTimeSet
	306	* */
	307	DateTimeStyleSet::DateTimeStyleSet() :
	308	FieldsSet(DTS_COUNT) {
46f4442e A	309	}
	310
	311	DateTimeStyleSet::~DateTimeStyleSet() {
	312
	313	}
	314
	315	UDateFormatStyle DateTimeStyleSet::getDateStyle() const {
	316	if(!isSet(DTS_DATE)) {
	317	return UDAT_NONE;
	318	} else {
	319	return (UDateFormatStyle)get(DTS_DATE);
	320	}
	321	}
	322
	323
	324	UDateFormatStyle DateTimeStyleSet::getTimeStyle() const {
	325	if(!isSet(DTS_TIME)) {
	326	return UDAT_NONE;
	327	} else {
	328	return (UDateFormatStyle)get(DTS_TIME);
	329	}
	330	}
	331
	332	void DateTimeStyleSet::handleParseValue(const FieldsSet* inheritFrom, int32_t field, const UnicodeString& substr, UErrorCode& status) {
46f4442e A	333	UnicodeString kRELATIVE_("RELATIVE_");
	334	if(substr.startsWith(kRELATIVE_)) {
	335	UnicodeString relativeas(substr,kRELATIVE_.length());
	336	parseValueEnum(UDBG_UDateFormatStyle, inheritFrom, field, relativeas, status);
	337	// fix relative value
	338	if(isSet(field) && U_SUCCESS(status)) {
	339	set(field, get(field) \| UDAT_RELATIVE);
	340	}
	341	} else {
	342	parseValueEnum(UDBG_UDateFormatStyle, inheritFrom, field, substr, status);
	343	}
	344	}
	345
	346	int32_t DateTimeStyleSet::handleParseName(const FieldsSet* /* inheritFrom /, const UnicodeString& name, const UnicodeString& / substr */, UErrorCode& status) {
	347	UnicodeString kDATE("DATE"); // TODO: static
	348	UnicodeString kTIME("TIME"); // TODO: static
	349	if(name == kDATE ) {
	350	return DTS_DATE;
	351	} else if(name == kTIME) {
	352	return DTS_TIME;
	353	} else {
	354	status = U_ILLEGAL_ARGUMENT_ERROR;
	355	return -1;
	356	}
	357	}
	358
	359	#endif /!UCONFIG_NO_FORMAT/