1 // Copyright (C) 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /*
4 *******************************************************************************
5 * Copyright (C) 1996-2015, International Business Machines
6 * Corporation and others. All Rights Reserved.
7 *******************************************************************************
8 */
9
10 #include "unicode/utypes.h"
11
12 #if !UCONFIG_NO_FORMATTING
13
14 #include "unicode/udat.h"
15
16 #include "unicode/uloc.h"
17 #include "unicode/datefmt.h"
18 #include "unicode/timezone.h"
19 #include "unicode/smpdtfmt.h"
20 #include "unicode/fieldpos.h"
21 #include "unicode/parsepos.h"
22 #include "unicode/calendar.h"
23 #include "unicode/numfmt.h"
24 #include "unicode/dtfmtsym.h"
25 #include "unicode/ustring.h"
26 #include "unicode/udisplaycontext.h"
27 #include "unicode/ufieldpositer.h"
28 #include "cpputils.h"
29 #include "reldtfmt.h"
30 #include "umutex.h"
31
32 U_NAMESPACE_USE
33
34 /**
35 * Verify that fmt is a SimpleDateFormat. Invalid error if not.
36 * @param fmt the UDateFormat, definitely a DateFormat, maybe something else
37 * @param status error code, will be set to failure if there is a familure or the fmt is NULL.
38 */
verifyIsSimpleDateFormat(const UDateFormat * fmt,UErrorCode * status)39 static void verifyIsSimpleDateFormat(const UDateFormat* fmt, UErrorCode *status) {
40 if(U_SUCCESS(*status) &&
41 dynamic_cast<const SimpleDateFormat*>(reinterpret_cast<const DateFormat*>(fmt))==NULL) {
42 *status = U_ILLEGAL_ARGUMENT_ERROR;
43 }
44 }
45
46 // This mirrors the correspondence between the
47 // SimpleDateFormat::fgPatternIndexToDateFormatField and
48 // SimpleDateFormat::fgPatternIndexToCalendarField arrays.
49 static UCalendarDateFields gDateFieldMapping[] = {
50 UCAL_ERA, // UDAT_ERA_FIELD = 0
51 UCAL_YEAR, // UDAT_YEAR_FIELD = 1
52 UCAL_MONTH, // UDAT_MONTH_FIELD = 2
53 UCAL_DATE, // UDAT_DATE_FIELD = 3
54 UCAL_HOUR_OF_DAY, // UDAT_HOUR_OF_DAY1_FIELD = 4
55 UCAL_HOUR_OF_DAY, // UDAT_HOUR_OF_DAY0_FIELD = 5
56 UCAL_MINUTE, // UDAT_MINUTE_FIELD = 6
57 UCAL_SECOND, // UDAT_SECOND_FIELD = 7
58 UCAL_MILLISECOND, // UDAT_FRACTIONAL_SECOND_FIELD = 8
59 UCAL_DAY_OF_WEEK, // UDAT_DAY_OF_WEEK_FIELD = 9
60 UCAL_DAY_OF_YEAR, // UDAT_DAY_OF_YEAR_FIELD = 10
61 UCAL_DAY_OF_WEEK_IN_MONTH, // UDAT_DAY_OF_WEEK_IN_MONTH_FIELD = 11
62 UCAL_WEEK_OF_YEAR, // UDAT_WEEK_OF_YEAR_FIELD = 12
63 UCAL_WEEK_OF_MONTH, // UDAT_WEEK_OF_MONTH_FIELD = 13
64 UCAL_AM_PM, // UDAT_AM_PM_FIELD = 14
65 UCAL_HOUR, // UDAT_HOUR1_FIELD = 15
66 UCAL_HOUR, // UDAT_HOUR0_FIELD = 16
67 UCAL_ZONE_OFFSET, // UDAT_TIMEZONE_FIELD = 17
68 UCAL_YEAR_WOY, // UDAT_YEAR_WOY_FIELD = 18
69 UCAL_DOW_LOCAL, // UDAT_DOW_LOCAL_FIELD = 19
70 UCAL_EXTENDED_YEAR, // UDAT_EXTENDED_YEAR_FIELD = 20
71 UCAL_JULIAN_DAY, // UDAT_JULIAN_DAY_FIELD = 21
72 UCAL_MILLISECONDS_IN_DAY, // UDAT_MILLISECONDS_IN_DAY_FIELD = 22
73 UCAL_ZONE_OFFSET, // UDAT_TIMEZONE_RFC_FIELD = 23 (also UCAL_DST_OFFSET)
74 UCAL_ZONE_OFFSET, // UDAT_TIMEZONE_GENERIC_FIELD = 24 (also UCAL_DST_OFFSET)
75 UCAL_DOW_LOCAL, // UDAT_STANDALONE_DAY_FIELD = 25
76 UCAL_MONTH, // UDAT_STANDALONE_MONTH_FIELD = 26
77 UCAL_MONTH, // UDAT_QUARTER_FIELD = 27
78 UCAL_MONTH, // UDAT_STANDALONE_QUARTER_FIELD = 28
79 UCAL_ZONE_OFFSET, // UDAT_TIMEZONE_SPECIAL_FIELD = 29 (also UCAL_DST_OFFSET)
80 UCAL_YEAR, // UDAT_YEAR_NAME_FIELD = 30
81 UCAL_ZONE_OFFSET, // UDAT_TIMEZONE_LOCALIZED_GMT_OFFSET_FIELD = 31 (also UCAL_DST_OFFSET)
82 UCAL_ZONE_OFFSET, // UDAT_TIMEZONE_ISO_FIELD = 32 (also UCAL_DST_OFFSET)
83 UCAL_ZONE_OFFSET, // UDAT_TIMEZONE_ISO_LOCAL_FIELD = 33 (also UCAL_DST_OFFSET)
84 UCAL_EXTENDED_YEAR, // UDAT_RELATED_YEAR_FIELD = 34 (not an exact match)
85 UCAL_FIELD_COUNT, // UDAT_FIELD_COUNT = 35
86 // UCAL_IS_LEAP_MONTH is not the target of a mapping
87 };
88
89 U_CAPI UCalendarDateFields U_EXPORT2
udat_toCalendarDateField(UDateFormatField field)90 udat_toCalendarDateField(UDateFormatField field) {
91 return gDateFieldMapping[field];
92 }
93
94 /* For now- one opener. */
95 static UDateFormatOpener gOpener = NULL;
96
97 U_INTERNAL void U_EXPORT2
udat_registerOpener(UDateFormatOpener opener,UErrorCode * status)98 udat_registerOpener(UDateFormatOpener opener, UErrorCode *status)
99 {
100 if(U_FAILURE(*status)) return;
101 umtx_lock(NULL);
102 if(gOpener==NULL) {
103 gOpener = opener;
104 } else {
105 *status = U_ILLEGAL_ARGUMENT_ERROR;
106 }
107 umtx_unlock(NULL);
108 }
109
110 U_INTERNAL UDateFormatOpener U_EXPORT2
udat_unregisterOpener(UDateFormatOpener opener,UErrorCode * status)111 udat_unregisterOpener(UDateFormatOpener opener, UErrorCode *status)
112 {
113 if(U_FAILURE(*status)) return NULL;
114 UDateFormatOpener oldOpener = NULL;
115 umtx_lock(NULL);
116 if(gOpener==NULL || gOpener!=opener) {
117 *status = U_ILLEGAL_ARGUMENT_ERROR;
118 } else {
119 oldOpener=gOpener;
120 gOpener=NULL;
121 }
122 umtx_unlock(NULL);
123 return oldOpener;
124 }
125
126
127
128 U_CAPI UDateFormat* U_EXPORT2
udat_open(UDateFormatStyle timeStyle,UDateFormatStyle dateStyle,const char * locale,const UChar * tzID,int32_t tzIDLength,const UChar * pattern,int32_t patternLength,UErrorCode * status)129 udat_open(UDateFormatStyle timeStyle,
130 UDateFormatStyle dateStyle,
131 const char *locale,
132 const UChar *tzID,
133 int32_t tzIDLength,
134 const UChar *pattern,
135 int32_t patternLength,
136 UErrorCode *status)
137 {
138 DateFormat *fmt;
139 if(U_FAILURE(*status)) {
140 return 0;
141 }
142 if(gOpener!=NULL) { // if it's registered
143 fmt = (DateFormat*) (*gOpener)(timeStyle,dateStyle,locale,tzID,tzIDLength,pattern,patternLength,status);
144 if(fmt!=NULL) {
145 return (UDateFormat*)fmt;
146 } // else fall through.
147 }
148 if(timeStyle != UDAT_PATTERN) {
149 if(locale == 0) {
150 fmt = DateFormat::createDateTimeInstance((DateFormat::EStyle)dateStyle,
151 (DateFormat::EStyle)timeStyle);
152 }
153 else {
154 fmt = DateFormat::createDateTimeInstance((DateFormat::EStyle)dateStyle,
155 (DateFormat::EStyle)timeStyle,
156 Locale(locale));
157 }
158 }
159 else {
160 UnicodeString pat((UBool)(patternLength == -1), pattern, patternLength);
161
162 if(locale == 0) {
163 fmt = new SimpleDateFormat(pat, *status);
164 }
165 else {
166 fmt = new SimpleDateFormat(pat, Locale(locale), *status);
167 }
168 }
169
170 if(fmt == 0) {
171 *status = U_MEMORY_ALLOCATION_ERROR;
172 return 0;
173 }
174
175 if(tzID != 0) {
176 TimeZone *zone = TimeZone::createTimeZone(UnicodeString((UBool)(tzIDLength == -1), tzID, tzIDLength));
177 if(zone == 0) {
178 *status = U_MEMORY_ALLOCATION_ERROR;
179 delete fmt;
180 return 0;
181 }
182 fmt->adoptTimeZone(zone);
183 }
184
185 return (UDateFormat*)fmt;
186 }
187
188
189 U_CAPI void U_EXPORT2
udat_close(UDateFormat * format)190 udat_close(UDateFormat* format)
191 {
192 delete (DateFormat*)format;
193 }
194
195 U_CAPI UDateFormat* U_EXPORT2
udat_clone(const UDateFormat * fmt,UErrorCode * status)196 udat_clone(const UDateFormat *fmt,
197 UErrorCode *status)
198 {
199 if(U_FAILURE(*status)) return 0;
200
201 Format *res = ((DateFormat*)fmt)->clone();
202
203 if(res == 0) {
204 *status = U_MEMORY_ALLOCATION_ERROR;
205 return 0;
206 }
207
208 return (UDateFormat*) res;
209 }
210
211 U_CAPI int32_t U_EXPORT2
udat_format(const UDateFormat * format,UDate dateToFormat,UChar * result,int32_t resultLength,UFieldPosition * position,UErrorCode * status)212 udat_format( const UDateFormat* format,
213 UDate dateToFormat,
214 UChar* result,
215 int32_t resultLength,
216 UFieldPosition* position,
217 UErrorCode* status)
218 {
219 if(U_FAILURE(*status)) {
220 return -1;
221 }
222 if (result == NULL ? resultLength != 0 : resultLength < 0) {
223 *status = U_ILLEGAL_ARGUMENT_ERROR;
224 return -1;
225 }
226
227 UnicodeString res;
228 if (result != NULL) {
229 // NULL destination for pure preflighting: empty dummy string
230 // otherwise, alias the destination buffer
231 res.setTo(result, 0, resultLength);
232 }
233
234 FieldPosition fp;
235
236 if(position != 0)
237 fp.setField(position->field);
238
239 ((DateFormat*)format)->format(dateToFormat, res, fp);
240
241 if(position != 0) {
242 position->beginIndex = fp.getBeginIndex();
243 position->endIndex = fp.getEndIndex();
244 }
245
246 return res.extract(result, resultLength, *status);
247 }
248
249 U_CAPI int32_t U_EXPORT2
udat_formatCalendar(const UDateFormat * format,UCalendar * calendar,UChar * result,int32_t resultLength,UFieldPosition * position,UErrorCode * status)250 udat_formatCalendar(const UDateFormat* format,
251 UCalendar* calendar,
252 UChar* result,
253 int32_t resultLength,
254 UFieldPosition* position,
255 UErrorCode* status)
256 {
257 if(U_FAILURE(*status)) {
258 return -1;
259 }
260 if (result == NULL ? resultLength != 0 : resultLength < 0) {
261 *status = U_ILLEGAL_ARGUMENT_ERROR;
262 return -1;
263 }
264
265 UnicodeString res;
266 if (result != NULL) {
267 // NULL destination for pure preflighting: empty dummy string
268 // otherwise, alias the destination buffer
269 res.setTo(result, 0, resultLength);
270 }
271
272 FieldPosition fp;
273
274 if(position != 0)
275 fp.setField(position->field);
276
277 ((DateFormat*)format)->format(*(Calendar*)calendar, res, fp);
278
279 if(position != 0) {
280 position->beginIndex = fp.getBeginIndex();
281 position->endIndex = fp.getEndIndex();
282 }
283
284 return res.extract(result, resultLength, *status);
285 }
286
287 U_CAPI int32_t U_EXPORT2
udat_formatForFields(const UDateFormat * format,UDate dateToFormat,UChar * result,int32_t resultLength,UFieldPositionIterator * fpositer,UErrorCode * status)288 udat_formatForFields( const UDateFormat* format,
289 UDate dateToFormat,
290 UChar* result,
291 int32_t resultLength,
292 UFieldPositionIterator* fpositer,
293 UErrorCode* status)
294 {
295 if(U_FAILURE(*status)) {
296 return -1;
297 }
298 if (result == NULL ? resultLength != 0 : resultLength < 0) {
299 *status = U_ILLEGAL_ARGUMENT_ERROR;
300 return -1;
301 }
302
303 UnicodeString res;
304 if (result != NULL) {
305 // NULL destination for pure preflighting: empty dummy string
306 // otherwise, alias the destination buffer
307 res.setTo(result, 0, resultLength);
308 }
309
310 ((DateFormat*)format)->format(dateToFormat, res, (FieldPositionIterator*)fpositer, *status);
311
312 return res.extract(result, resultLength, *status);
313 }
314
315 U_CAPI int32_t U_EXPORT2
udat_formatCalendarForFields(const UDateFormat * format,UCalendar * calendar,UChar * result,int32_t resultLength,UFieldPositionIterator * fpositer,UErrorCode * status)316 udat_formatCalendarForFields(const UDateFormat* format,
317 UCalendar* calendar,
318 UChar* result,
319 int32_t resultLength,
320 UFieldPositionIterator* fpositer,
321 UErrorCode* status)
322 {
323 if(U_FAILURE(*status)) {
324 return -1;
325 }
326 if (result == NULL ? resultLength != 0 : resultLength < 0) {
327 *status = U_ILLEGAL_ARGUMENT_ERROR;
328 return -1;
329 }
330
331 UnicodeString res;
332 if (result != NULL) {
333 // NULL destination for pure preflighting: empty dummy string
334 // otherwise, alias the destination buffer
335 res.setTo(result, 0, resultLength);
336 }
337
338 ((DateFormat*)format)->format(*(Calendar*)calendar, res, (FieldPositionIterator*)fpositer, *status);
339
340 return res.extract(result, resultLength, *status);
341 }
342
343 U_CAPI UDate U_EXPORT2
udat_parse(const UDateFormat * format,const UChar * text,int32_t textLength,int32_t * parsePos,UErrorCode * status)344 udat_parse( const UDateFormat* format,
345 const UChar* text,
346 int32_t textLength,
347 int32_t *parsePos,
348 UErrorCode *status)
349 {
350 if(U_FAILURE(*status)) return (UDate)0;
351
352 const UnicodeString src((UBool)(textLength == -1), text, textLength);
353 ParsePosition pp;
354 int32_t stackParsePos = 0;
355 UDate res;
356
357 if(parsePos == NULL) {
358 parsePos = &stackParsePos;
359 }
360
361 pp.setIndex(*parsePos);
362
363 res = ((DateFormat*)format)->parse(src, pp);
364
365 if(pp.getErrorIndex() == -1)
366 *parsePos = pp.getIndex();
367 else {
368 *parsePos = pp.getErrorIndex();
369 *status = U_PARSE_ERROR;
370 }
371
372 return res;
373 }
374
375 U_CAPI void U_EXPORT2
udat_parseCalendar(const UDateFormat * format,UCalendar * calendar,const UChar * text,int32_t textLength,int32_t * parsePos,UErrorCode * status)376 udat_parseCalendar(const UDateFormat* format,
377 UCalendar* calendar,
378 const UChar* text,
379 int32_t textLength,
380 int32_t *parsePos,
381 UErrorCode *status)
382 {
383 if(U_FAILURE(*status)) return;
384
385 const UnicodeString src((UBool)(textLength == -1), text, textLength);
386 ParsePosition pp;
387 int32_t stackParsePos = 0;
388
389 if(parsePos == NULL) {
390 parsePos = &stackParsePos;
391 }
392
393 pp.setIndex(*parsePos);
394
395 ((DateFormat*)format)->parse(src, *(Calendar*)calendar, pp);
396
397 if(pp.getErrorIndex() == -1)
398 *parsePos = pp.getIndex();
399 else {
400 *parsePos = pp.getErrorIndex();
401 *status = U_PARSE_ERROR;
402 }
403 }
404
405 U_CAPI UBool U_EXPORT2
udat_isLenient(const UDateFormat * fmt)406 udat_isLenient(const UDateFormat* fmt)
407 {
408 return ((DateFormat*)fmt)->isLenient();
409 }
410
411 U_CAPI void U_EXPORT2
udat_setLenient(UDateFormat * fmt,UBool isLenient)412 udat_setLenient( UDateFormat* fmt,
413 UBool isLenient)
414 {
415 ((DateFormat*)fmt)->setLenient(isLenient);
416 }
417
418 U_DRAFT UBool U_EXPORT2
udat_getBooleanAttribute(const UDateFormat * fmt,UDateFormatBooleanAttribute attr,UErrorCode * status)419 udat_getBooleanAttribute(const UDateFormat* fmt,
420 UDateFormatBooleanAttribute attr,
421 UErrorCode* status)
422 {
423 if(U_FAILURE(*status)) return FALSE;
424 return ((DateFormat*)fmt)->getBooleanAttribute(attr, *status);
425 //return FALSE;
426 }
427
428 U_DRAFT void U_EXPORT2
udat_setBooleanAttribute(UDateFormat * fmt,UDateFormatBooleanAttribute attr,UBool newValue,UErrorCode * status)429 udat_setBooleanAttribute(UDateFormat *fmt,
430 UDateFormatBooleanAttribute attr,
431 UBool newValue,
432 UErrorCode* status)
433 {
434 if(U_FAILURE(*status)) return;
435 ((DateFormat*)fmt)->setBooleanAttribute(attr, newValue, *status);
436 }
437
438 U_CAPI const UCalendar* U_EXPORT2
udat_getCalendar(const UDateFormat * fmt)439 udat_getCalendar(const UDateFormat* fmt)
440 {
441 return (const UCalendar*) ((DateFormat*)fmt)->getCalendar();
442 }
443
444 U_CAPI void U_EXPORT2
udat_setCalendar(UDateFormat * fmt,const UCalendar * calendarToSet)445 udat_setCalendar(UDateFormat* fmt,
446 const UCalendar* calendarToSet)
447 {
448 ((DateFormat*)fmt)->setCalendar(*((Calendar*)calendarToSet));
449 }
450
451 U_DRAFT const UNumberFormat* U_EXPORT2
udat_getNumberFormatForField(const UDateFormat * fmt,UChar field)452 udat_getNumberFormatForField(const UDateFormat* fmt, UChar field)
453 {
454 UErrorCode status = U_ZERO_ERROR;
455 verifyIsSimpleDateFormat(fmt, &status);
456 if (U_FAILURE(status)) return (const UNumberFormat*) ((DateFormat*)fmt)->getNumberFormat();
457 return (const UNumberFormat*) ((SimpleDateFormat*)fmt)->getNumberFormatForField(field);
458 }
459
460 U_CAPI const UNumberFormat* U_EXPORT2
udat_getNumberFormat(const UDateFormat * fmt)461 udat_getNumberFormat(const UDateFormat* fmt)
462 {
463 return (const UNumberFormat*) ((DateFormat*)fmt)->getNumberFormat();
464 }
465
466 U_DRAFT void U_EXPORT2
udat_adoptNumberFormatForFields(UDateFormat * fmt,const UChar * fields,UNumberFormat * numberFormatToSet,UErrorCode * status)467 udat_adoptNumberFormatForFields( UDateFormat* fmt,
468 const UChar* fields,
469 UNumberFormat* numberFormatToSet,
470 UErrorCode* status)
471 {
472 verifyIsSimpleDateFormat(fmt, status);
473 if (U_FAILURE(*status)) return;
474
475 if (fields!=NULL) {
476 UnicodeString overrideFields(fields);
477 ((SimpleDateFormat*)fmt)->adoptNumberFormat(overrideFields, (NumberFormat*)numberFormatToSet, *status);
478 }
479 }
480
481 U_CAPI void U_EXPORT2
udat_setNumberFormat(UDateFormat * fmt,const UNumberFormat * numberFormatToSet)482 udat_setNumberFormat(UDateFormat* fmt,
483 const UNumberFormat* numberFormatToSet)
484 {
485 ((DateFormat*)fmt)->setNumberFormat(*((NumberFormat*)numberFormatToSet));
486 }
487
488 U_DRAFT void U_EXPORT2
udat_adoptNumberFormat(UDateFormat * fmt,UNumberFormat * numberFormatToAdopt)489 udat_adoptNumberFormat( UDateFormat* fmt,
490 UNumberFormat* numberFormatToAdopt)
491 {
492 ((DateFormat*)fmt)->adoptNumberFormat((NumberFormat*)numberFormatToAdopt);
493 }
494
495 U_CAPI const char* U_EXPORT2
udat_getAvailable(int32_t index)496 udat_getAvailable(int32_t index)
497 {
498 return uloc_getAvailable(index);
499 }
500
501 U_CAPI int32_t U_EXPORT2
udat_countAvailable()502 udat_countAvailable()
503 {
504 return uloc_countAvailable();
505 }
506
507 U_CAPI UDate U_EXPORT2
udat_get2DigitYearStart(const UDateFormat * fmt,UErrorCode * status)508 udat_get2DigitYearStart( const UDateFormat *fmt,
509 UErrorCode *status)
510 {
511 verifyIsSimpleDateFormat(fmt, status);
512 if(U_FAILURE(*status)) return (UDate)0;
513 return ((SimpleDateFormat*)fmt)->get2DigitYearStart(*status);
514 }
515
516 U_CAPI void U_EXPORT2
udat_set2DigitYearStart(UDateFormat * fmt,UDate d,UErrorCode * status)517 udat_set2DigitYearStart( UDateFormat *fmt,
518 UDate d,
519 UErrorCode *status)
520 {
521 verifyIsSimpleDateFormat(fmt, status);
522 if(U_FAILURE(*status)) return;
523 ((SimpleDateFormat*)fmt)->set2DigitYearStart(d, *status);
524 }
525
526 U_CAPI int32_t U_EXPORT2
udat_toPattern(const UDateFormat * fmt,UBool localized,UChar * result,int32_t resultLength,UErrorCode * status)527 udat_toPattern( const UDateFormat *fmt,
528 UBool localized,
529 UChar *result,
530 int32_t resultLength,
531 UErrorCode *status)
532 {
533 if(U_FAILURE(*status)) {
534 return -1;
535 }
536 if (result == NULL ? resultLength != 0 : resultLength < 0) {
537 *status = U_ILLEGAL_ARGUMENT_ERROR;
538 return -1;
539 }
540
541 UnicodeString res;
542 if (result != NULL) {
543 // NULL destination for pure preflighting: empty dummy string
544 // otherwise, alias the destination buffer
545 res.setTo(result, 0, resultLength);
546 }
547
548 const DateFormat *df=reinterpret_cast<const DateFormat *>(fmt);
549 const SimpleDateFormat *sdtfmt=dynamic_cast<const SimpleDateFormat *>(df);
550 const RelativeDateFormat *reldtfmt;
551 if (sdtfmt!=NULL) {
552 if(localized)
553 sdtfmt->toLocalizedPattern(res, *status);
554 else
555 sdtfmt->toPattern(res);
556 } else if (!localized && (reldtfmt=dynamic_cast<const RelativeDateFormat *>(df))!=NULL) {
557 reldtfmt->toPattern(res, *status);
558 } else {
559 *status = U_ILLEGAL_ARGUMENT_ERROR;
560 return -1;
561 }
562
563 return res.extract(result, resultLength, *status);
564 }
565
566 // TODO: should this take an UErrorCode?
567 // A: Yes. Of course.
568 U_CAPI void U_EXPORT2
udat_applyPattern(UDateFormat * format,UBool localized,const UChar * pattern,int32_t patternLength)569 udat_applyPattern( UDateFormat *format,
570 UBool localized,
571 const UChar *pattern,
572 int32_t patternLength)
573 {
574 const UnicodeString pat((UBool)(patternLength == -1), pattern, patternLength);
575 UErrorCode status = U_ZERO_ERROR;
576
577 verifyIsSimpleDateFormat(format, &status);
578 if(U_FAILURE(status)) {
579 return;
580 }
581
582 if(localized)
583 ((SimpleDateFormat*)format)->applyLocalizedPattern(pat, status);
584 else
585 ((SimpleDateFormat*)format)->applyPattern(pat);
586 }
587
588 U_CAPI int32_t U_EXPORT2
udat_getSymbols(const UDateFormat * fmt,UDateFormatSymbolType type,int32_t index,UChar * result,int32_t resultLength,UErrorCode * status)589 udat_getSymbols(const UDateFormat *fmt,
590 UDateFormatSymbolType type,
591 int32_t index,
592 UChar *result,
593 int32_t resultLength,
594 UErrorCode *status)
595 {
596 const DateFormatSymbols *syms;
597 const SimpleDateFormat* sdtfmt;
598 const RelativeDateFormat* rdtfmt;
599 if ((sdtfmt = dynamic_cast<const SimpleDateFormat*>(reinterpret_cast<const DateFormat*>(fmt))) != NULL) {
600 syms = sdtfmt->getDateFormatSymbols();
601 } else if ((rdtfmt = dynamic_cast<const RelativeDateFormat*>(reinterpret_cast<const DateFormat*>(fmt))) != NULL) {
602 syms = rdtfmt->getDateFormatSymbols();
603 } else {
604 return -1;
605 }
606 int32_t count;
607 const UnicodeString *res = NULL;
608
609 switch(type) {
610 case UDAT_ERAS:
611 res = syms->getEras(count);
612 break;
613
614 case UDAT_ERA_NAMES:
615 res = syms->getEraNames(count);
616 break;
617
618 case UDAT_MONTHS:
619 res = syms->getMonths(count);
620 break;
621
622 case UDAT_SHORT_MONTHS:
623 res = syms->getShortMonths(count);
624 break;
625
626 case UDAT_WEEKDAYS:
627 res = syms->getWeekdays(count);
628 break;
629
630 case UDAT_SHORT_WEEKDAYS:
631 res = syms->getShortWeekdays(count);
632 break;
633
634 case UDAT_AM_PMS:
635 res = syms->getAmPmStrings(count);
636 break;
637
638 case UDAT_LOCALIZED_CHARS:
639 {
640 UnicodeString res1;
641 if(!(result==NULL && resultLength==0)) {
642 // NULL destination for pure preflighting: empty dummy string
643 // otherwise, alias the destination buffer
644 res1.setTo(result, 0, resultLength);
645 }
646 syms->getLocalPatternChars(res1);
647 return res1.extract(result, resultLength, *status);
648 }
649
650 case UDAT_NARROW_MONTHS:
651 res = syms->getMonths(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
652 break;
653
654 case UDAT_SHORTER_WEEKDAYS:
655 res = syms->getWeekdays(count, DateFormatSymbols::FORMAT, DateFormatSymbols::SHORT);
656 break;
657
658 case UDAT_NARROW_WEEKDAYS:
659 res = syms->getWeekdays(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
660 break;
661
662 case UDAT_STANDALONE_MONTHS:
663 res = syms->getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
664 break;
665
666 case UDAT_STANDALONE_SHORT_MONTHS:
667 res = syms->getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
668 break;
669
670 case UDAT_STANDALONE_NARROW_MONTHS:
671 res = syms->getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::NARROW);
672 break;
673
674 case UDAT_STANDALONE_WEEKDAYS:
675 res = syms->getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
676 break;
677
678 case UDAT_STANDALONE_SHORT_WEEKDAYS:
679 res = syms->getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
680 break;
681
682 case UDAT_STANDALONE_SHORTER_WEEKDAYS:
683 res = syms->getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::SHORT);
684 break;
685
686 case UDAT_STANDALONE_NARROW_WEEKDAYS:
687 res = syms->getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::NARROW);
688 break;
689
690 case UDAT_QUARTERS:
691 res = syms->getQuarters(count, DateFormatSymbols::FORMAT, DateFormatSymbols::WIDE);
692 break;
693
694 case UDAT_SHORT_QUARTERS:
695 res = syms->getQuarters(count, DateFormatSymbols::FORMAT, DateFormatSymbols::ABBREVIATED);
696 break;
697
698 case UDAT_STANDALONE_QUARTERS:
699 res = syms->getQuarters(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
700 break;
701
702 case UDAT_STANDALONE_SHORT_QUARTERS:
703 res = syms->getQuarters(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
704 break;
705
706 case UDAT_CYCLIC_YEARS_WIDE:
707 res = syms->getYearNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::WIDE);
708 break;
709
710 case UDAT_CYCLIC_YEARS_ABBREVIATED:
711 res = syms->getYearNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::ABBREVIATED);
712 break;
713
714 case UDAT_CYCLIC_YEARS_NARROW:
715 res = syms->getYearNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
716 break;
717
718 case UDAT_ZODIAC_NAMES_WIDE:
719 res = syms->getZodiacNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::WIDE);
720 break;
721
722 case UDAT_ZODIAC_NAMES_ABBREVIATED:
723 res = syms->getZodiacNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::ABBREVIATED);
724 break;
725
726 case UDAT_ZODIAC_NAMES_NARROW:
727 res = syms->getZodiacNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
728 break;
729
730 }
731
732 if(index < count) {
733 return res[index].extract(result, resultLength, *status);
734 }
735 return 0;
736 }
737
738 // TODO: also needs an errorCode.
739 U_CAPI int32_t U_EXPORT2
udat_countSymbols(const UDateFormat * fmt,UDateFormatSymbolType type)740 udat_countSymbols( const UDateFormat *fmt,
741 UDateFormatSymbolType type)
742 {
743 const DateFormatSymbols *syms;
744 const SimpleDateFormat* sdtfmt;
745 const RelativeDateFormat* rdtfmt;
746 if ((sdtfmt = dynamic_cast<const SimpleDateFormat*>(reinterpret_cast<const DateFormat*>(fmt))) != NULL) {
747 syms = sdtfmt->getDateFormatSymbols();
748 } else if ((rdtfmt = dynamic_cast<const RelativeDateFormat*>(reinterpret_cast<const DateFormat*>(fmt))) != NULL) {
749 syms = rdtfmt->getDateFormatSymbols();
750 } else {
751 return 0;
752 }
753 int32_t count = 0;
754
755 switch(type) {
756 case UDAT_ERAS:
757 syms->getEras(count);
758 break;
759
760 case UDAT_MONTHS:
761 syms->getMonths(count);
762 break;
763
764 case UDAT_SHORT_MONTHS:
765 syms->getShortMonths(count);
766 break;
767
768 case UDAT_WEEKDAYS:
769 syms->getWeekdays(count);
770 break;
771
772 case UDAT_SHORT_WEEKDAYS:
773 syms->getShortWeekdays(count);
774 break;
775
776 case UDAT_AM_PMS:
777 syms->getAmPmStrings(count);
778 break;
779
780 case UDAT_LOCALIZED_CHARS:
781 count = 1;
782 break;
783
784 case UDAT_ERA_NAMES:
785 syms->getEraNames(count);
786 break;
787
788 case UDAT_NARROW_MONTHS:
789 syms->getMonths(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
790 break;
791
792 case UDAT_SHORTER_WEEKDAYS:
793 syms->getWeekdays(count, DateFormatSymbols::FORMAT, DateFormatSymbols::SHORT);
794 break;
795
796 case UDAT_NARROW_WEEKDAYS:
797 syms->getWeekdays(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
798 break;
799
800 case UDAT_STANDALONE_MONTHS:
801 syms->getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
802 break;
803
804 case UDAT_STANDALONE_SHORT_MONTHS:
805 syms->getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
806 break;
807
808 case UDAT_STANDALONE_NARROW_MONTHS:
809 syms->getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::NARROW);
810 break;
811
812 case UDAT_STANDALONE_WEEKDAYS:
813 syms->getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
814 break;
815
816 case UDAT_STANDALONE_SHORT_WEEKDAYS:
817 syms->getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
818 break;
819
820 case UDAT_STANDALONE_SHORTER_WEEKDAYS:
821 syms->getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::SHORT);
822 break;
823
824 case UDAT_STANDALONE_NARROW_WEEKDAYS:
825 syms->getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::NARROW);
826 break;
827
828 case UDAT_QUARTERS:
829 syms->getQuarters(count, DateFormatSymbols::FORMAT, DateFormatSymbols::WIDE);
830 break;
831
832 case UDAT_SHORT_QUARTERS:
833 syms->getQuarters(count, DateFormatSymbols::FORMAT, DateFormatSymbols::ABBREVIATED);
834 break;
835
836 case UDAT_STANDALONE_QUARTERS:
837 syms->getQuarters(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
838 break;
839
840 case UDAT_STANDALONE_SHORT_QUARTERS:
841 syms->getQuarters(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
842 break;
843
844 case UDAT_CYCLIC_YEARS_WIDE:
845 syms->getYearNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::WIDE);
846 break;
847
848 case UDAT_CYCLIC_YEARS_ABBREVIATED:
849 syms->getYearNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::ABBREVIATED);
850 break;
851
852 case UDAT_CYCLIC_YEARS_NARROW:
853 syms->getYearNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
854 break;
855
856 case UDAT_ZODIAC_NAMES_WIDE:
857 syms->getZodiacNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::WIDE);
858 break;
859
860 case UDAT_ZODIAC_NAMES_ABBREVIATED:
861 syms->getZodiacNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::ABBREVIATED);
862 break;
863
864 case UDAT_ZODIAC_NAMES_NARROW:
865 syms->getZodiacNames(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
866 break;
867
868 }
869
870 return count;
871 }
872
873 U_NAMESPACE_BEGIN
874
875 /*
876 * This DateFormatSymbolsSingleSetter class is a friend of DateFormatSymbols
877 * solely for the purpose of avoiding to clone the array of strings
878 * just to modify one of them and then setting all of them back.
879 * For example, the old code looked like this:
880 * case UDAT_MONTHS:
881 * res = syms->getMonths(count);
882 * array = new UnicodeString[count];
883 * if(array == 0) {
884 * *status = U_MEMORY_ALLOCATION_ERROR;
885 * return;
886 * }
887 * uprv_arrayCopy(res, array, count);
888 * if(index < count)
889 * array[index] = val;
890 * syms->setMonths(array, count);
891 * break;
892 *
893 * Even worse, the old code actually cloned the entire DateFormatSymbols object,
894 * cloned one value array, changed one value, and then made the SimpleDateFormat
895 * replace its DateFormatSymbols object with the new one.
896 *
897 * markus 2002-oct-14
898 */
899 class DateFormatSymbolsSingleSetter /* not : public UObject because all methods are static */ {
900 public:
901 static void
setSymbol(UnicodeString * array,int32_t count,int32_t index,const UChar * value,int32_t valueLength,UErrorCode & errorCode)902 setSymbol(UnicodeString *array, int32_t count, int32_t index,
903 const UChar *value, int32_t valueLength, UErrorCode &errorCode)
904 {
905 if(array!=NULL) {
906 if(index>=count) {
907 errorCode=U_INDEX_OUTOFBOUNDS_ERROR;
908 } else if(value==NULL) {
909 errorCode=U_ILLEGAL_ARGUMENT_ERROR;
910 } else {
911 array[index].setTo(value, valueLength);
912 }
913 }
914 }
915
916 static void
setEra(DateFormatSymbols * syms,int32_t index,const UChar * value,int32_t valueLength,UErrorCode & errorCode)917 setEra(DateFormatSymbols *syms, int32_t index,
918 const UChar *value, int32_t valueLength, UErrorCode &errorCode)
919 {
920 setSymbol(syms->fEras, syms->fErasCount, index, value, valueLength, errorCode);
921 }
922
923 static void
setEraName(DateFormatSymbols * syms,int32_t index,const UChar * value,int32_t valueLength,UErrorCode & errorCode)924 setEraName(DateFormatSymbols *syms, int32_t index,
925 const UChar *value, int32_t valueLength, UErrorCode &errorCode)
926 {
927 setSymbol(syms->fEraNames, syms->fEraNamesCount, index, value, valueLength, errorCode);
928 }
929
930 static void
setMonth(DateFormatSymbols * syms,int32_t index,const UChar * value,int32_t valueLength,UErrorCode & errorCode)931 setMonth(DateFormatSymbols *syms, int32_t index,
932 const UChar *value, int32_t valueLength, UErrorCode &errorCode)
933 {
934 setSymbol(syms->fMonths, syms->fMonthsCount, index, value, valueLength, errorCode);
935 }
936
937 static void
setShortMonth(DateFormatSymbols * syms,int32_t index,const UChar * value,int32_t valueLength,UErrorCode & errorCode)938 setShortMonth(DateFormatSymbols *syms, int32_t index,
939 const UChar *value, int32_t valueLength, UErrorCode &errorCode)
940 {
941 setSymbol(syms->fShortMonths, syms->fShortMonthsCount, index, value, valueLength, errorCode);
942 }
943
944 static void
setNarrowMonth(DateFormatSymbols * syms,int32_t index,const UChar * value,int32_t valueLength,UErrorCode & errorCode)945 setNarrowMonth(DateFormatSymbols *syms, int32_t index,
946 const UChar *value, int32_t valueLength, UErrorCode &errorCode)
947 {
948 setSymbol(syms->fNarrowMonths, syms->fNarrowMonthsCount, index, value, valueLength, errorCode);
949 }
950
951 static void
setStandaloneMonth(DateFormatSymbols * syms,int32_t index,const UChar * value,int32_t valueLength,UErrorCode & errorCode)952 setStandaloneMonth(DateFormatSymbols *syms, int32_t index,
953 const UChar *value, int32_t valueLength, UErrorCode &errorCode)
954 {
955 setSymbol(syms->fStandaloneMonths, syms->fStandaloneMonthsCount, index, value, valueLength, errorCode);
956 }
957
958 static void
setStandaloneShortMonth(DateFormatSymbols * syms,int32_t index,const UChar * value,int32_t valueLength,UErrorCode & errorCode)959 setStandaloneShortMonth(DateFormatSymbols *syms, int32_t index,
960 const UChar *value, int32_t valueLength, UErrorCode &errorCode)
961 {
962 setSymbol(syms->fStandaloneShortMonths, syms->fStandaloneShortMonthsCount, index, value, valueLength, errorCode);
963 }
964
965 static void
setStandaloneNarrowMonth(DateFormatSymbols * syms,int32_t index,const UChar * value,int32_t valueLength,UErrorCode & errorCode)966 setStandaloneNarrowMonth(DateFormatSymbols *syms, int32_t index,
967 const UChar *value, int32_t valueLength, UErrorCode &errorCode)
968 {
969 setSymbol(syms->fStandaloneNarrowMonths, syms->fStandaloneNarrowMonthsCount, index, value, valueLength, errorCode);
970 }
971
972 static void
setWeekday(DateFormatSymbols * syms,int32_t index,const UChar * value,int32_t valueLength,UErrorCode & errorCode)973 setWeekday(DateFormatSymbols *syms, int32_t index,
974 const UChar *value, int32_t valueLength, UErrorCode &errorCode)
975 {
976 setSymbol(syms->fWeekdays, syms->fWeekdaysCount, index, value, valueLength, errorCode);
977 }
978
979 static void
setShortWeekday(DateFormatSymbols * syms,int32_t index,const UChar * value,int32_t valueLength,UErrorCode & errorCode)980 setShortWeekday(DateFormatSymbols *syms, int32_t index,
981 const UChar *value, int32_t valueLength, UErrorCode &errorCode)
982 {
983 setSymbol(syms->fShortWeekdays, syms->fShortWeekdaysCount, index, value, valueLength, errorCode);
984 }
985
986 static void
setShorterWeekday(DateFormatSymbols * syms,int32_t index,const UChar * value,int32_t valueLength,UErrorCode & errorCode)987 setShorterWeekday(DateFormatSymbols *syms, int32_t index,
988 const UChar *value, int32_t valueLength, UErrorCode &errorCode)
989 {
990 setSymbol(syms->fShorterWeekdays, syms->fShorterWeekdaysCount, index, value, valueLength, errorCode);
991 }
992
993 static void
setNarrowWeekday(DateFormatSymbols * syms,int32_t index,const UChar * value,int32_t valueLength,UErrorCode & errorCode)994 setNarrowWeekday(DateFormatSymbols *syms, int32_t index,
995 const UChar *value, int32_t valueLength, UErrorCode &errorCode)
996 {
997 setSymbol(syms->fNarrowWeekdays, syms->fNarrowWeekdaysCount, index, value, valueLength, errorCode);
998 }
999
1000 static void
setStandaloneWeekday(DateFormatSymbols * syms,int32_t index,const UChar * value,int32_t valueLength,UErrorCode & errorCode)1001 setStandaloneWeekday(DateFormatSymbols *syms, int32_t index,
1002 const UChar *value, int32_t valueLength, UErrorCode &errorCode)
1003 {
1004 setSymbol(syms->fStandaloneWeekdays, syms->fStandaloneWeekdaysCount, index, value, valueLength, errorCode);
1005 }
1006
1007 static void
setStandaloneShortWeekday(DateFormatSymbols * syms,int32_t index,const UChar * value,int32_t valueLength,UErrorCode & errorCode)1008 setStandaloneShortWeekday(DateFormatSymbols *syms, int32_t index,
1009 const UChar *value, int32_t valueLength, UErrorCode &errorCode)
1010 {
1011 setSymbol(syms->fStandaloneShortWeekdays, syms->fStandaloneShortWeekdaysCount, index, value, valueLength, errorCode);
1012 }
1013
1014 static void
setStandaloneShorterWeekday(DateFormatSymbols * syms,int32_t index,const UChar * value,int32_t valueLength,UErrorCode & errorCode)1015 setStandaloneShorterWeekday(DateFormatSymbols *syms, int32_t index,
1016 const UChar *value, int32_t valueLength, UErrorCode &errorCode)
1017 {
1018 setSymbol(syms->fStandaloneShorterWeekdays, syms->fStandaloneShorterWeekdaysCount, index, value, valueLength, errorCode);
1019 }
1020
1021 static void
setStandaloneNarrowWeekday(DateFormatSymbols * syms,int32_t index,const UChar * value,int32_t valueLength,UErrorCode & errorCode)1022 setStandaloneNarrowWeekday(DateFormatSymbols *syms, int32_t index,
1023 const UChar *value, int32_t valueLength, UErrorCode &errorCode)
1024 {
1025 setSymbol(syms->fStandaloneNarrowWeekdays, syms->fStandaloneNarrowWeekdaysCount, index, value, valueLength, errorCode);
1026 }
1027
1028 static void
setQuarter(DateFormatSymbols * syms,int32_t index,const UChar * value,int32_t valueLength,UErrorCode & errorCode)1029 setQuarter(DateFormatSymbols *syms, int32_t index,
1030 const UChar *value, int32_t valueLength, UErrorCode &errorCode)
1031 {
1032 setSymbol(syms->fQuarters, syms->fQuartersCount, index, value, valueLength, errorCode);
1033 }
1034
1035 static void
setShortQuarter(DateFormatSymbols * syms,int32_t index,const UChar * value,int32_t valueLength,UErrorCode & errorCode)1036 setShortQuarter(DateFormatSymbols *syms, int32_t index,
1037 const UChar *value, int32_t valueLength, UErrorCode &errorCode)
1038 {
1039 setSymbol(syms->fShortQuarters, syms->fShortQuartersCount, index, value, valueLength, errorCode);
1040 }
1041
1042 static void
setStandaloneQuarter(DateFormatSymbols * syms,int32_t index,const UChar * value,int32_t valueLength,UErrorCode & errorCode)1043 setStandaloneQuarter(DateFormatSymbols *syms, int32_t index,
1044 const UChar *value, int32_t valueLength, UErrorCode &errorCode)
1045 {
1046 setSymbol(syms->fStandaloneQuarters, syms->fStandaloneQuartersCount, index, value, valueLength, errorCode);
1047 }
1048
1049 static void
setStandaloneShortQuarter(DateFormatSymbols * syms,int32_t index,const UChar * value,int32_t valueLength,UErrorCode & errorCode)1050 setStandaloneShortQuarter(DateFormatSymbols *syms, int32_t index,
1051 const UChar *value, int32_t valueLength, UErrorCode &errorCode)
1052 {
1053 setSymbol(syms->fStandaloneShortQuarters, syms->fStandaloneShortQuartersCount, index, value, valueLength, errorCode);
1054 }
1055
1056 static void
setShortYearNames(DateFormatSymbols * syms,int32_t index,const UChar * value,int32_t valueLength,UErrorCode & errorCode)1057 setShortYearNames(DateFormatSymbols *syms, int32_t index,
1058 const UChar *value, int32_t valueLength, UErrorCode &errorCode)
1059 {
1060 setSymbol(syms->fShortYearNames, syms->fShortYearNamesCount, index, value, valueLength, errorCode);
1061 }
1062
1063 static void
setShortZodiacNames(DateFormatSymbols * syms,int32_t index,const UChar * value,int32_t valueLength,UErrorCode & errorCode)1064 setShortZodiacNames(DateFormatSymbols *syms, int32_t index,
1065 const UChar *value, int32_t valueLength, UErrorCode &errorCode)
1066 {
1067 setSymbol(syms->fShortZodiacNames, syms->fShortZodiacNamesCount, index, value, valueLength, errorCode);
1068 }
1069
1070 static void
setAmPm(DateFormatSymbols * syms,int32_t index,const UChar * value,int32_t valueLength,UErrorCode & errorCode)1071 setAmPm(DateFormatSymbols *syms, int32_t index,
1072 const UChar *value, int32_t valueLength, UErrorCode &errorCode)
1073 {
1074 setSymbol(syms->fAmPms, syms->fAmPmsCount, index, value, valueLength, errorCode);
1075 }
1076
1077 static void
setLocalPatternChars(DateFormatSymbols * syms,const UChar * value,int32_t valueLength,UErrorCode & errorCode)1078 setLocalPatternChars(DateFormatSymbols *syms,
1079 const UChar *value, int32_t valueLength, UErrorCode &errorCode)
1080 {
1081 setSymbol(&syms->fLocalPatternChars, 1, 0, value, valueLength, errorCode);
1082 }
1083 };
1084
1085 U_NAMESPACE_END
1086
1087 U_CAPI void U_EXPORT2
udat_setSymbols(UDateFormat * format,UDateFormatSymbolType type,int32_t index,UChar * value,int32_t valueLength,UErrorCode * status)1088 udat_setSymbols( UDateFormat *format,
1089 UDateFormatSymbolType type,
1090 int32_t index,
1091 UChar *value,
1092 int32_t valueLength,
1093 UErrorCode *status)
1094 {
1095 verifyIsSimpleDateFormat(format, status);
1096 if(U_FAILURE(*status)) return;
1097
1098 DateFormatSymbols *syms = (DateFormatSymbols *)((SimpleDateFormat *)format)->getDateFormatSymbols();
1099
1100 switch(type) {
1101 case UDAT_ERAS:
1102 DateFormatSymbolsSingleSetter::setEra(syms, index, value, valueLength, *status);
1103 break;
1104
1105 case UDAT_ERA_NAMES:
1106 DateFormatSymbolsSingleSetter::setEraName(syms, index, value, valueLength, *status);
1107 break;
1108
1109 case UDAT_MONTHS:
1110 DateFormatSymbolsSingleSetter::setMonth(syms, index, value, valueLength, *status);
1111 break;
1112
1113 case UDAT_SHORT_MONTHS:
1114 DateFormatSymbolsSingleSetter::setShortMonth(syms, index, value, valueLength, *status);
1115 break;
1116
1117 case UDAT_NARROW_MONTHS:
1118 DateFormatSymbolsSingleSetter::setNarrowMonth(syms, index, value, valueLength, *status);
1119 break;
1120
1121 case UDAT_STANDALONE_MONTHS:
1122 DateFormatSymbolsSingleSetter::setStandaloneMonth(syms, index, value, valueLength, *status);
1123 break;
1124
1125 case UDAT_STANDALONE_SHORT_MONTHS:
1126 DateFormatSymbolsSingleSetter::setStandaloneShortMonth(syms, index, value, valueLength, *status);
1127 break;
1128
1129 case UDAT_STANDALONE_NARROW_MONTHS:
1130 DateFormatSymbolsSingleSetter::setStandaloneNarrowMonth(syms, index, value, valueLength, *status);
1131 break;
1132
1133 case UDAT_WEEKDAYS:
1134 DateFormatSymbolsSingleSetter::setWeekday(syms, index, value, valueLength, *status);
1135 break;
1136
1137 case UDAT_SHORT_WEEKDAYS:
1138 DateFormatSymbolsSingleSetter::setShortWeekday(syms, index, value, valueLength, *status);
1139 break;
1140
1141 case UDAT_SHORTER_WEEKDAYS:
1142 DateFormatSymbolsSingleSetter::setShorterWeekday(syms, index, value, valueLength, *status);
1143 break;
1144
1145 case UDAT_NARROW_WEEKDAYS:
1146 DateFormatSymbolsSingleSetter::setNarrowWeekday(syms, index, value, valueLength, *status);
1147 break;
1148
1149 case UDAT_STANDALONE_WEEKDAYS:
1150 DateFormatSymbolsSingleSetter::setStandaloneWeekday(syms, index, value, valueLength, *status);
1151 break;
1152
1153 case UDAT_STANDALONE_SHORT_WEEKDAYS:
1154 DateFormatSymbolsSingleSetter::setStandaloneShortWeekday(syms, index, value, valueLength, *status);
1155 break;
1156
1157 case UDAT_STANDALONE_SHORTER_WEEKDAYS:
1158 DateFormatSymbolsSingleSetter::setStandaloneShorterWeekday(syms, index, value, valueLength, *status);
1159 break;
1160
1161 case UDAT_STANDALONE_NARROW_WEEKDAYS:
1162 DateFormatSymbolsSingleSetter::setStandaloneNarrowWeekday(syms, index, value, valueLength, *status);
1163 break;
1164
1165 case UDAT_QUARTERS:
1166 DateFormatSymbolsSingleSetter::setQuarter(syms, index, value, valueLength, *status);
1167 break;
1168
1169 case UDAT_SHORT_QUARTERS:
1170 DateFormatSymbolsSingleSetter::setShortQuarter(syms, index, value, valueLength, *status);
1171 break;
1172
1173 case UDAT_STANDALONE_QUARTERS:
1174 DateFormatSymbolsSingleSetter::setStandaloneQuarter(syms, index, value, valueLength, *status);
1175 break;
1176
1177 case UDAT_STANDALONE_SHORT_QUARTERS:
1178 DateFormatSymbolsSingleSetter::setStandaloneShortQuarter(syms, index, value, valueLength, *status);
1179 break;
1180
1181 case UDAT_CYCLIC_YEARS_ABBREVIATED:
1182 DateFormatSymbolsSingleSetter::setShortYearNames(syms, index, value, valueLength, *status);
1183 break;
1184
1185 case UDAT_ZODIAC_NAMES_ABBREVIATED:
1186 DateFormatSymbolsSingleSetter::setShortZodiacNames(syms, index, value, valueLength, *status);
1187 break;
1188
1189 case UDAT_AM_PMS:
1190 DateFormatSymbolsSingleSetter::setAmPm(syms, index, value, valueLength, *status);
1191 break;
1192
1193 case UDAT_LOCALIZED_CHARS:
1194 DateFormatSymbolsSingleSetter::setLocalPatternChars(syms, value, valueLength, *status);
1195 break;
1196
1197 default:
1198 *status = U_UNSUPPORTED_ERROR;
1199 break;
1200
1201 }
1202 }
1203
1204 U_CAPI const char* U_EXPORT2
udat_getLocaleByType(const UDateFormat * fmt,ULocDataLocaleType type,UErrorCode * status)1205 udat_getLocaleByType(const UDateFormat *fmt,
1206 ULocDataLocaleType type,
1207 UErrorCode* status)
1208 {
1209 if (fmt == NULL) {
1210 if (U_SUCCESS(*status)) {
1211 *status = U_ILLEGAL_ARGUMENT_ERROR;
1212 }
1213 return NULL;
1214 }
1215 return ((Format*)fmt)->getLocaleID(type, *status);
1216 }
1217
1218 U_CAPI void U_EXPORT2
udat_setContext(UDateFormat * fmt,UDisplayContext value,UErrorCode * status)1219 udat_setContext(UDateFormat* fmt, UDisplayContext value, UErrorCode* status)
1220 {
1221 if (U_FAILURE(*status)) {
1222 return;
1223 }
1224 ((DateFormat*)fmt)->setContext(value, *status);
1225 return;
1226 }
1227
1228 U_CAPI UDisplayContext U_EXPORT2
udat_getContext(const UDateFormat * fmt,UDisplayContextType type,UErrorCode * status)1229 udat_getContext(const UDateFormat* fmt, UDisplayContextType type, UErrorCode* status)
1230 {
1231 if (U_FAILURE(*status)) {
1232 return (UDisplayContext)0;
1233 }
1234 return ((const DateFormat*)fmt)->getContext(type, *status);
1235 }
1236
1237
1238 /**
1239 * Verify that fmt is a RelativeDateFormat. Invalid error if not.
1240 * @param fmt the UDateFormat, definitely a DateFormat, maybe something else
1241 * @param status error code, will be set to failure if there is a familure or the fmt is NULL.
1242 */
verifyIsRelativeDateFormat(const UDateFormat * fmt,UErrorCode * status)1243 static void verifyIsRelativeDateFormat(const UDateFormat* fmt, UErrorCode *status) {
1244 if(U_SUCCESS(*status) &&
1245 dynamic_cast<const RelativeDateFormat*>(reinterpret_cast<const DateFormat*>(fmt))==NULL) {
1246 *status = U_ILLEGAL_ARGUMENT_ERROR;
1247 }
1248 }
1249
1250
1251 U_CAPI int32_t U_EXPORT2
udat_toPatternRelativeDate(const UDateFormat * fmt,UChar * result,int32_t resultLength,UErrorCode * status)1252 udat_toPatternRelativeDate(const UDateFormat *fmt,
1253 UChar *result,
1254 int32_t resultLength,
1255 UErrorCode *status)
1256 {
1257 verifyIsRelativeDateFormat(fmt, status);
1258 if(U_FAILURE(*status)) {
1259 return -1;
1260 }
1261 if (result == NULL ? resultLength != 0 : resultLength < 0) {
1262 *status = U_ILLEGAL_ARGUMENT_ERROR;
1263 return -1;
1264 }
1265
1266 UnicodeString datePattern;
1267 if (result != NULL) {
1268 // NULL destination for pure preflighting: empty dummy string
1269 // otherwise, alias the destination buffer
1270 datePattern.setTo(result, 0, resultLength);
1271 }
1272 ((RelativeDateFormat*)fmt)->toPatternDate(datePattern, *status);
1273 return datePattern.extract(result, resultLength, *status);
1274 }
1275
1276 U_CAPI int32_t U_EXPORT2
udat_toPatternRelativeTime(const UDateFormat * fmt,UChar * result,int32_t resultLength,UErrorCode * status)1277 udat_toPatternRelativeTime(const UDateFormat *fmt,
1278 UChar *result,
1279 int32_t resultLength,
1280 UErrorCode *status)
1281 {
1282 verifyIsRelativeDateFormat(fmt, status);
1283 if(U_FAILURE(*status)) {
1284 return -1;
1285 }
1286 if (result == NULL ? resultLength != 0 : resultLength < 0) {
1287 *status = U_ILLEGAL_ARGUMENT_ERROR;
1288 return -1;
1289 }
1290
1291 UnicodeString timePattern;
1292 if (result != NULL) {
1293 // NULL destination for pure preflighting: empty dummy string
1294 // otherwise, alias the destination buffer
1295 timePattern.setTo(result, 0, resultLength);
1296 }
1297 ((RelativeDateFormat*)fmt)->toPatternTime(timePattern, *status);
1298 return timePattern.extract(result, resultLength, *status);
1299 }
1300
1301 U_CAPI void U_EXPORT2
udat_applyPatternRelative(UDateFormat * format,const UChar * datePattern,int32_t datePatternLength,const UChar * timePattern,int32_t timePatternLength,UErrorCode * status)1302 udat_applyPatternRelative(UDateFormat *format,
1303 const UChar *datePattern,
1304 int32_t datePatternLength,
1305 const UChar *timePattern,
1306 int32_t timePatternLength,
1307 UErrorCode *status)
1308 {
1309 verifyIsRelativeDateFormat(format, status);
1310 if(U_FAILURE(*status)) return;
1311 const UnicodeString datePat((UBool)(datePatternLength == -1), datePattern, datePatternLength);
1312 const UnicodeString timePat((UBool)(timePatternLength == -1), timePattern, timePatternLength);
1313 ((RelativeDateFormat*)format)->applyPatterns(datePat, timePat, *status);
1314 }
1315
1316 #endif /* #if !UCONFIG_NO_FORMATTING */
1317