1// © 2016 and later: Unicode, Inc. and others.
2// License & terms of use: http://www.unicode.org/copyright.html
3/*******************************************************************************
4* Copyright (C) 2008-2016, International Business Machines Corporation and
5* others. All Rights Reserved.
6*******************************************************************************
7*
8* File DTITVINF.CPP
9*
10*******************************************************************************
11*/
12
13#include "unicode/dtitvinf.h"
14
15
16#if !UCONFIG_NO_FORMATTING
17
18//TODO: define it in compiler time
19//#define DTITVINF_DEBUG 1
20
21
22#ifdef DTITVINF_DEBUG
23#include <iostream>
24#endif
25
26#include "cmemory.h"
27#include "cstring.h"
28#include "unicode/msgfmt.h"
29#include "unicode/uloc.h"
30#include "unicode/ures.h"
31#include "dtitv_impl.h"
32#include "charstr.h"
33#include "hash.h"
34#include "gregoimp.h"
35#include "uresimp.h"
36#include "hash.h"
37#include "gregoimp.h"
38#include "uresimp.h"
39
40
41U_NAMESPACE_BEGIN
42
43
44#ifdef DTITVINF_DEBUG
45#define PRINTMESG(msg) UPRV_BLOCK_MACRO_BEGIN { \
46 std::cout << "(" << __FILE__ << ":" << __LINE__ << ") " << msg << "\n"; \
47} UPRV_BLOCK_MACRO_END
48#endif
49
50UOBJECT_DEFINE_RTTI_IMPLEMENTATION(DateIntervalInfo)
51
52static const char gCalendarTag[]="calendar";
53static const char gGenericTag[]="generic";
54static const char gGregorianTag[]="gregorian";
55static const char gIntervalDateTimePatternTag[]="intervalFormats";
56static const char gFallbackPatternTag[]="fallback";
57
58// {0}
59static const UChar gFirstPattern[] = {LEFT_CURLY_BRACKET, DIGIT_ZERO, RIGHT_CURLY_BRACKET};
60// {1}
61static const UChar gSecondPattern[] = {LEFT_CURLY_BRACKET, DIGIT_ONE, RIGHT_CURLY_BRACKET};
62
63// default fall-back
64static const UChar gDefaultFallbackPattern[] = {LEFT_CURLY_BRACKET, DIGIT_ZERO, RIGHT_CURLY_BRACKET, SPACE, EN_DASH, SPACE, LEFT_CURLY_BRACKET, DIGIT_ONE, RIGHT_CURLY_BRACKET, 0};
65
66DateIntervalInfo::DateIntervalInfo(UErrorCode& status)
67: fFallbackIntervalPattern(gDefaultFallbackPattern),
68 fFirstDateInPtnIsLaterDate(false),
69 fIntervalPatterns(nullptr)
70{
71 fIntervalPatterns = initHash(status);
72}
73
74
75
76DateIntervalInfo::DateIntervalInfo(const Locale& locale, UErrorCode& status)
77: fFallbackIntervalPattern(gDefaultFallbackPattern),
78 fFirstDateInPtnIsLaterDate(false),
79 fIntervalPatterns(nullptr)
80{
81 initializeData(locale, status);
82}
83
84
85
86void
87DateIntervalInfo::setIntervalPattern(const UnicodeString& skeleton,
88 UCalendarDateFields lrgDiffCalUnit,
89 const UnicodeString& intervalPattern,
90 UErrorCode& status) {
91
92 if ( lrgDiffCalUnit == UCAL_HOUR_OF_DAY ) {
93 setIntervalPatternInternally(skeleton, UCAL_AM_PM, intervalPattern, status);
94 setIntervalPatternInternally(skeleton, UCAL_HOUR, intervalPattern, status);
95 } else if ( lrgDiffCalUnit == UCAL_DAY_OF_MONTH ||
96 lrgDiffCalUnit == UCAL_DAY_OF_WEEK ) {
97 setIntervalPatternInternally(skeleton, UCAL_DATE, intervalPattern, status);
98 } else {
99 setIntervalPatternInternally(skeleton, lrgDiffCalUnit, intervalPattern, status);
100 }
101}
102
103
104void
105DateIntervalInfo::setFallbackIntervalPattern(
106 const UnicodeString& fallbackPattern,
107 UErrorCode& status) {
108 if ( U_FAILURE(status) ) {
109 return;
110 }
111 int32_t firstPatternIndex = fallbackPattern.indexOf(gFirstPattern,
112 UPRV_LENGTHOF(gFirstPattern), 0);
113 int32_t secondPatternIndex = fallbackPattern.indexOf(gSecondPattern,
114 UPRV_LENGTHOF(gSecondPattern), 0);
115 if ( firstPatternIndex == -1 || secondPatternIndex == -1 ) {
116 status = U_ILLEGAL_ARGUMENT_ERROR;
117 return;
118 }
119 if ( firstPatternIndex > secondPatternIndex ) {
120 fFirstDateInPtnIsLaterDate = true;
121 }
122 fFallbackIntervalPattern = fallbackPattern;
123}
124
125
126
127DateIntervalInfo::DateIntervalInfo(const DateIntervalInfo& dtitvinf)
128: UObject(dtitvinf),
129 fIntervalPatterns(nullptr)
130{
131 *this = dtitvinf;
132}
133
134
135
136DateIntervalInfo&
137DateIntervalInfo::operator=(const DateIntervalInfo& dtitvinf) {
138 if ( this == &dtitvinf ) {
139 return *this;
140 }
141
142 UErrorCode status = U_ZERO_ERROR;
143 deleteHash(fIntervalPatterns);
144 fIntervalPatterns = initHash(status);
145 copyHash(dtitvinf.fIntervalPatterns, fIntervalPatterns, status);
146 if ( U_FAILURE(status) ) {
147 return *this;
148 }
149
150 fFallbackIntervalPattern = dtitvinf.fFallbackIntervalPattern;
151 fFirstDateInPtnIsLaterDate = dtitvinf.fFirstDateInPtnIsLaterDate;
152 return *this;
153}
154
155
156DateIntervalInfo*
157DateIntervalInfo::clone() const {
158 return new DateIntervalInfo(*this);
159}
160
161
162DateIntervalInfo::~DateIntervalInfo() {
163 deleteHash(fIntervalPatterns);
164 fIntervalPatterns = nullptr;
165}
166
167
168UBool
169DateIntervalInfo::operator==(const DateIntervalInfo& other) const {
170 UBool equal = (
171 fFallbackIntervalPattern == other.fFallbackIntervalPattern &&
172 fFirstDateInPtnIsLaterDate == other.fFirstDateInPtnIsLaterDate );
173
174 if ( equal == TRUE ) {
175 equal = fIntervalPatterns->equals(*(other.fIntervalPatterns));
176 }
177
178 return equal;
179}
180
181
182UnicodeString&
183DateIntervalInfo::getIntervalPattern(const UnicodeString& skeleton,
184 UCalendarDateFields field,
185 UnicodeString& result,
186 UErrorCode& status) const {
187 if ( U_FAILURE(status) ) {
188 return result;
189 }
190
191 const UnicodeString* patternsOfOneSkeleton = (UnicodeString*) fIntervalPatterns->get(skeleton);
192 if ( patternsOfOneSkeleton != nullptr ) {
193 IntervalPatternIndex index = calendarFieldToIntervalIndex(field, status);
194 if ( U_FAILURE(status) ) {
195 return result;
196 }
197 const UnicodeString& intervalPattern = patternsOfOneSkeleton[index];
198 if ( !intervalPattern.isEmpty() ) {
199 result = intervalPattern;
200 }
201 }
202 return result;
203}
204
205
206UBool
207DateIntervalInfo::getDefaultOrder() const {
208 return fFirstDateInPtnIsLaterDate;
209}
210
211
212UnicodeString&
213DateIntervalInfo::getFallbackIntervalPattern(UnicodeString& result) const {
214 result = fFallbackIntervalPattern;
215 return result;
216}
217
218#define ULOC_LOCALE_IDENTIFIER_CAPACITY (ULOC_FULLNAME_CAPACITY + 1 + ULOC_KEYWORD_AND_VALUES_CAPACITY)
219
220
221static const int32_t PATH_PREFIX_LENGTH = 17;
222static const UChar PATH_PREFIX[] = {SOLIDUS, CAP_L, CAP_O, CAP_C, CAP_A, CAP_L, CAP_E, SOLIDUS,
223 LOW_C, LOW_A, LOW_L, LOW_E, LOW_N, LOW_D, LOW_A, LOW_R, SOLIDUS};
224static const int32_t PATH_SUFFIX_LENGTH = 16;
225static const UChar PATH_SUFFIX[] = {SOLIDUS, LOW_I, LOW_N, LOW_T, LOW_E, LOW_R, LOW_V, LOW_A,
226 LOW_L, CAP_F, LOW_O, LOW_R, LOW_M, LOW_A, LOW_T, LOW_S};
227
228/**
229 * Sink for enumerating all of the date interval skeletons.
230 */
231struct DateIntervalInfo::DateIntervalSink : public ResourceSink {
232
233 // Output data
234 DateIntervalInfo &dateIntervalInfo;
235
236 // Next calendar type
237 UnicodeString nextCalendarType;
238
239 DateIntervalSink(DateIntervalInfo &diInfo, const char *currentCalendarType)
240 : dateIntervalInfo(diInfo), nextCalendarType(currentCalendarType, -1, US_INV) { }
241 virtual ~DateIntervalSink();
242
243 virtual void put(const char *key, ResourceValue &value, UBool /*noFallback*/, UErrorCode &errorCode) {
244 if (U_FAILURE(errorCode)) { return; }
245
246 // Iterate over all the calendar entries and only pick the 'intervalFormats' table.
247 ResourceTable dateIntervalData = value.getTable(errorCode);
248 if (U_FAILURE(errorCode)) { return; }
249 for (int32_t i = 0; dateIntervalData.getKeyAndValue(i, key, value); i++) {
250 if (uprv_strcmp(key, gIntervalDateTimePatternTag) != 0) {
251 continue;
252 }
253
254 // Handle aliases and tables. Ignore the rest.
255 if (value.getType() == URES_ALIAS) {
256 // Get the calendar type for the alias path.
257 const UnicodeString &aliasPath = value.getAliasUnicodeString(errorCode);
258 if (U_FAILURE(errorCode)) { return; }
259
260 nextCalendarType.remove();
261 getCalendarTypeFromPath(aliasPath, nextCalendarType, errorCode);
262
263 if (U_FAILURE(errorCode)) {
264 resetNextCalendarType();
265 }
266 break;
267
268 } else if (value.getType() == URES_TABLE) {
269 // Iterate over all the skeletons in the 'intervalFormat' table.
270 ResourceTable skeletonData = value.getTable(errorCode);
271 if (U_FAILURE(errorCode)) { return; }
272 for (int32_t j = 0; skeletonData.getKeyAndValue(j, key, value); j++) {
273 if (value.getType() == URES_TABLE) {
274 // Process the skeleton
275 processSkeletonTable(key, value, errorCode);
276 if (U_FAILURE(errorCode)) { return; }
277 }
278 }
279 break;
280 }
281 }
282 }
283
284 /**
285 * Processes the patterns for a skeleton table
286 */
287 void processSkeletonTable(const char *key, ResourceValue &value, UErrorCode &errorCode) {
288 if (U_FAILURE(errorCode)) { return; }
289
290 // Iterate over all the patterns in the current skeleton table
291 const char *currentSkeleton = key;
292 ResourceTable patternData = value.getTable(errorCode);
293 if (U_FAILURE(errorCode)) { return; }
294 for (int32_t k = 0; patternData.getKeyAndValue(k, key, value); k++) {
295 if (value.getType() == URES_STRING) {
296 // Process the key
297 UCalendarDateFields calendarField = validateAndProcessPatternLetter(key);
298
299 // If the calendar field has a valid value
300 if (calendarField < UCAL_FIELD_COUNT) {
301 // Set the interval pattern
302 setIntervalPatternIfAbsent(currentSkeleton, calendarField, value, errorCode);
303 if (U_FAILURE(errorCode)) { return; }
304 }
305 }
306 }
307 }
308
309 /**
310 * Extracts the calendar type from the path.
311 */
312 static void getCalendarTypeFromPath(const UnicodeString &path, UnicodeString &calendarType,
313 UErrorCode &errorCode) {
314 if (U_FAILURE(errorCode)) { return; }
315
316 if (!path.startsWith(PATH_PREFIX, PATH_PREFIX_LENGTH) || !path.endsWith(PATH_SUFFIX, PATH_SUFFIX_LENGTH)) {
317 errorCode = U_INVALID_FORMAT_ERROR;
318 return;
319 }
320
321 path.extractBetween(PATH_PREFIX_LENGTH, path.length() - PATH_SUFFIX_LENGTH, calendarType);
322 }
323
324 /**
325 * Validates and processes the pattern letter
326 */
327 UCalendarDateFields validateAndProcessPatternLetter(const char *patternLetter) {
328 // Check that patternLetter is just one letter
329 char c0;
330 if ((c0 = patternLetter[0]) != 0 && patternLetter[1] == 0) {
331 // Check that the pattern letter is accepted
332 if (c0 == 'G') {
333 return UCAL_ERA;
334 } else if (c0 == 'y') {
335 return UCAL_YEAR;
336 } else if (c0 == 'M') {
337 return UCAL_MONTH;
338 } else if (c0 == 'd') {
339 return UCAL_DATE;
340 } else if (c0 == 'a') {
341 return UCAL_AM_PM;
342 } else if (c0 == 'h' || c0 == 'H') {
343 return UCAL_HOUR;
344 } else if (c0 == 'm') {
345 return UCAL_MINUTE;
346 }// TODO(ticket:12190): Why icu4c doesn't accept the calendar field "s" but icu4j does?
347 }
348 return UCAL_FIELD_COUNT;
349 }
350
351 /**
352 * Stores the interval pattern for the current skeleton in the internal data structure
353 * if it's not present.
354 */
355 void setIntervalPatternIfAbsent(const char *currentSkeleton, UCalendarDateFields lrgDiffCalUnit,
356 const ResourceValue &value, UErrorCode &errorCode) {
357 // Check if the pattern has already been stored on the data structure
358 IntervalPatternIndex index =
359 dateIntervalInfo.calendarFieldToIntervalIndex(lrgDiffCalUnit, errorCode);
360 if (U_FAILURE(errorCode)) { return; }
361
362 UnicodeString skeleton(currentSkeleton, -1, US_INV);
363 UnicodeString* patternsOfOneSkeleton =
364 (UnicodeString*)(dateIntervalInfo.fIntervalPatterns->get(skeleton));
365
366 if (patternsOfOneSkeleton == nullptr || patternsOfOneSkeleton[index].isEmpty()) {
367 UnicodeString pattern = value.getUnicodeString(errorCode);
368 dateIntervalInfo.setIntervalPatternInternally(skeleton, lrgDiffCalUnit,
369 pattern, errorCode);
370 }
371 }
372
373 const UnicodeString &getNextCalendarType() {
374 return nextCalendarType;
375 }
376
377 void resetNextCalendarType() {
378 nextCalendarType.setToBogus();
379 }
380};
381
382// Virtual destructors must be defined out of line.
383DateIntervalInfo::DateIntervalSink::~DateIntervalSink() {}
384
385
386
387void
388DateIntervalInfo::initializeData(const Locale& locale, UErrorCode& status)
389{
390 fIntervalPatterns = initHash(status);
391 if (U_FAILURE(status)) {
392 return;
393 }
394 const char *locName = locale.getName();
395
396 // Get the correct calendar type
397 const char * calendarTypeToUse = gGregorianTag; // initial default
398 char calendarType[ULOC_KEYWORDS_CAPACITY]; // to be filled in with the type to use, if all goes well
399 char localeWithCalendarKey[ULOC_LOCALE_IDENTIFIER_CAPACITY];
400 // obtain a locale that always has the calendar key value that should be used
401 (void)ures_getFunctionalEquivalent(localeWithCalendarKey, ULOC_LOCALE_IDENTIFIER_CAPACITY, nullptr,
402 "calendar", "calendar", locName, nullptr, FALSE, &status);
403 localeWithCalendarKey[ULOC_LOCALE_IDENTIFIER_CAPACITY-1] = 0; // ensure null termination
404 // now get the calendar key value from that locale
405 int32_t calendarTypeLen = uloc_getKeywordValue(localeWithCalendarKey, "calendar", calendarType,
406 ULOC_KEYWORDS_CAPACITY, &status);
407 if (U_SUCCESS(status) && calendarTypeLen < ULOC_KEYWORDS_CAPACITY) {
408 calendarTypeToUse = calendarType;
409 }
410 status = U_ZERO_ERROR;
411
412 // Instantiate the resource bundles
413 UResourceBundle *rb, *calBundle;
414 rb = ures_open(nullptr, locName, &status);
415 if (U_FAILURE(status)) {
416 return;
417 }
418 calBundle = ures_getByKeyWithFallback(rb, gCalendarTag, nullptr, &status);
419
420
421 if (U_SUCCESS(status)) {
422 UResourceBundle *calTypeBundle, *itvDtPtnResource;
423
424 // Get the fallback pattern
425 const UChar* resStr = nullptr;
426 int32_t resStrLen = 0;
427 calTypeBundle = ures_getByKeyWithFallback(calBundle, calendarTypeToUse, nullptr, &status);
428 itvDtPtnResource = ures_getByKeyWithFallback(calTypeBundle,
429 gIntervalDateTimePatternTag, nullptr, &status);
430 // TODO(ICU-20400): After the fixing, we should find the "fallback" from
431 // the rb directly by the path "calendar/${calendar}/intervalFormats/fallback".
432 if ( U_SUCCESS(status) ) {
433 resStr = ures_getStringByKeyWithFallback(itvDtPtnResource, gFallbackPatternTag,
434 &resStrLen, &status);
435 if ( U_FAILURE(status) ) {
436 // Try to find "fallback" from "generic" to work around the bug in
437 // ures_getByKeyWithFallback
438 UErrorCode localStatus = U_ZERO_ERROR;
439 UResourceBundle *genericCalBundle =
440 ures_getByKeyWithFallback(calBundle, gGenericTag, nullptr, &localStatus);
441 UResourceBundle *genericItvDtPtnResource =
442 ures_getByKeyWithFallback(
443 genericCalBundle, gIntervalDateTimePatternTag, nullptr, &localStatus);
444 resStr = ures_getStringByKeyWithFallback(
445 genericItvDtPtnResource, gFallbackPatternTag, &resStrLen, &localStatus);
446 ures_close(genericItvDtPtnResource);
447 ures_close(genericCalBundle);
448 if ( U_SUCCESS(localStatus) ) {
449 status = U_USING_FALLBACK_WARNING;;
450 }
451 }
452 }
453
454 if ( U_SUCCESS(status) && (resStr != nullptr)) {
455 UnicodeString pattern = UnicodeString(TRUE, resStr, resStrLen);
456 setFallbackIntervalPattern(pattern, status);
457 }
458 ures_close(itvDtPtnResource);
459 ures_close(calTypeBundle);
460
461
462 // Instantiate the sink
463 DateIntervalSink sink(*this, calendarTypeToUse);
464 const UnicodeString &calendarTypeToUseUString = sink.getNextCalendarType();
465
466 // Already loaded calendar types
467 Hashtable loadedCalendarTypes(FALSE, status);
468
469 if (U_SUCCESS(status)) {
470 while (!calendarTypeToUseUString.isBogus()) {
471 // Set an error when a loop is detected
472 if (loadedCalendarTypes.geti(calendarTypeToUseUString) == 1) {
473 status = U_INVALID_FORMAT_ERROR;
474 break;
475 }
476
477 // Register the calendar type to avoid loops
478 loadedCalendarTypes.puti(calendarTypeToUseUString, 1, status);
479 if (U_FAILURE(status)) { break; }
480
481 // Get the calendar string
482 CharString calTypeBuffer;
483 calTypeBuffer.appendInvariantChars(calendarTypeToUseUString, status);
484 if (U_FAILURE(status)) { break; }
485 const char *calType = calTypeBuffer.data();
486
487 // Reset the next calendar type to load.
488 sink.resetNextCalendarType();
489
490 // Get all resources for this calendar type
491 ures_getAllItemsWithFallback(calBundle, calType, sink, status);
492 }
493 }
494 }
495
496 // Close the opened resource bundles
497 ures_close(calBundle);
498 ures_close(rb);
499}
500
501void
502DateIntervalInfo::setIntervalPatternInternally(const UnicodeString& skeleton,
503 UCalendarDateFields lrgDiffCalUnit,
504 const UnicodeString& intervalPattern,
505 UErrorCode& status) {
506 IntervalPatternIndex index = calendarFieldToIntervalIndex(lrgDiffCalUnit,status);
507 if ( U_FAILURE(status) ) {
508 return;
509 }
510 UnicodeString* patternsOfOneSkeleton = (UnicodeString*)(fIntervalPatterns->get(skeleton));
511 UBool emptyHash = false;
512 if ( patternsOfOneSkeleton == nullptr ) {
513 patternsOfOneSkeleton = new UnicodeString[kIPI_MAX_INDEX];
514 if (patternsOfOneSkeleton == nullptr) {
515 status = U_MEMORY_ALLOCATION_ERROR;
516 return;
517 }
518 emptyHash = true;
519 }
520
521 patternsOfOneSkeleton[index] = intervalPattern;
522 if ( emptyHash == TRUE ) {
523 fIntervalPatterns->put(skeleton, patternsOfOneSkeleton, status);
524 }
525}
526
527
528
529void
530DateIntervalInfo::parseSkeleton(const UnicodeString& skeleton,
531 int32_t* skeletonFieldWidth) {
532 const int8_t PATTERN_CHAR_BASE = 0x41;
533 int32_t i;
534 for ( i = 0; i < skeleton.length(); ++i ) {
535 // it is an ASCII char in skeleton
536 int8_t ch = (int8_t)skeleton.charAt(i);
537 ++skeletonFieldWidth[ch - PATTERN_CHAR_BASE];
538 }
539}
540
541
542
543UBool
544DateIntervalInfo::stringNumeric(int32_t fieldWidth, int32_t anotherFieldWidth,
545 char patternLetter) {
546 if ( patternLetter == 'M' ) {
547 if ( (fieldWidth <= 2 && anotherFieldWidth > 2) ||
548 (fieldWidth > 2 && anotherFieldWidth <= 2 )) {
549 return true;
550 }
551 }
552 return false;
553}
554
555
556
557const UnicodeString*
558DateIntervalInfo::getBestSkeleton(const UnicodeString& skeleton,
559 int8_t& bestMatchDistanceInfo) const {
560#ifdef DTITVINF_DEBUG
561 char result[1000];
562 char result_1[1000];
563 char mesg[2000];
564 skeleton.extract(0, skeleton.length(), result, "UTF-8");
565 sprintf(mesg, "in getBestSkeleton: skeleton: %s; \n", result);
566 PRINTMESG(mesg)
567#endif
568
569
570 int32_t inputSkeletonFieldWidth[] =
571 {
572 // A B C D E F G H I J K L M N O
573 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
574 // P Q R S T U V W X Y Z
575 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
576 // a b c d e f g h i j k l m n o
577 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
578 // p q r s t u v w x y z
579 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
580 };
581
582 int32_t skeletonFieldWidth[] =
583 {
584 // A B C D E F G H I J K L M N O
585 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
586 // P Q R S T U V W X Y Z
587 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
588 // a b c d e f g h i j k l m n o
589 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
590 // p q r s t u v w x y z
591 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
592 };
593
594 const int32_t DIFFERENT_FIELD = 0x1000;
595 const int32_t STRING_NUMERIC_DIFFERENCE = 0x100;
596 const int32_t BASE = 0x41;
597 const UChar CHAR_V = 0x0076;
598 const UChar CHAR_Z = 0x007A;
599
600 // hack for 'v' and 'z'.
601 // resource bundle only have time skeletons ending with 'v',
602 // but not for time skeletons ending with 'z'.
603 UBool replaceZWithV = false;
604 const UnicodeString* inputSkeleton = &skeleton;
605 UnicodeString copySkeleton;
606 if ( skeleton.indexOf(CHAR_Z) != -1 ) {
607 copySkeleton = skeleton;
608 copySkeleton.findAndReplace(UnicodeString(CHAR_Z), UnicodeString(CHAR_V));
609 inputSkeleton = &copySkeleton;
610 replaceZWithV = true;
611 }
612
613 parseSkeleton(*inputSkeleton, inputSkeletonFieldWidth);
614 int32_t bestDistance = MAX_POSITIVE_INT;
615 const UnicodeString* bestSkeleton = nullptr;
616
617 // 0 means exact the same skeletons;
618 // 1 means having the same field, but with different length,
619 // 2 means only z/v differs
620 // -1 means having different field.
621 bestMatchDistanceInfo = 0;
622 int8_t fieldLength = UPRV_LENGTHOF(skeletonFieldWidth);
623
624 int32_t pos = UHASH_FIRST;
625 const UHashElement* elem = nullptr;
626 while ( (elem = fIntervalPatterns->nextElement(pos)) != nullptr ) {
627 const UHashTok keyTok = elem->key;
628 UnicodeString* newSkeleton = (UnicodeString*)keyTok.pointer;
629#ifdef DTITVINF_DEBUG
630 skeleton->extract(0, skeleton->length(), result, "UTF-8");
631 sprintf(mesg, "available skeletons: skeleton: %s; \n", result);
632 PRINTMESG(mesg)
633#endif
634
635 // clear skeleton field width
636 int8_t i;
637 for ( i = 0; i < fieldLength; ++i ) {
638 skeletonFieldWidth[i] = 0;
639 }
640 parseSkeleton(*newSkeleton, skeletonFieldWidth);
641 // calculate distance
642 int32_t distance = 0;
643 int8_t fieldDifference = 1;
644 for ( i = 0; i < fieldLength; ++i ) {
645 int32_t inputFieldWidth = inputSkeletonFieldWidth[i];
646 int32_t fieldWidth = skeletonFieldWidth[i];
647 if ( inputFieldWidth == fieldWidth ) {
648 continue;
649 }
650 if ( inputFieldWidth == 0 ) {
651 fieldDifference = -1;
652 distance += DIFFERENT_FIELD;
653 } else if ( fieldWidth == 0 ) {
654 fieldDifference = -1;
655 distance += DIFFERENT_FIELD;
656 } else if (stringNumeric(inputFieldWidth, fieldWidth,
657 (char)(i+BASE) ) ) {
658 distance += STRING_NUMERIC_DIFFERENCE;
659 } else {
660 distance += (inputFieldWidth > fieldWidth) ?
661 (inputFieldWidth - fieldWidth) :
662 (fieldWidth - inputFieldWidth);
663 }
664 }
665 if ( distance < bestDistance ) {
666 bestSkeleton = newSkeleton;
667 bestDistance = distance;
668 bestMatchDistanceInfo = fieldDifference;
669 }
670 if ( distance == 0 ) {
671 bestMatchDistanceInfo = 0;
672 break;
673 }
674 }
675 if ( replaceZWithV && bestMatchDistanceInfo != -1 ) {
676 bestMatchDistanceInfo = 2;
677 }
678 return bestSkeleton;
679}
680
681
682
683DateIntervalInfo::IntervalPatternIndex
684DateIntervalInfo::calendarFieldToIntervalIndex(UCalendarDateFields field,
685 UErrorCode& status) {
686 if ( U_FAILURE(status) ) {
687 return kIPI_MAX_INDEX;
688 }
689 IntervalPatternIndex index = kIPI_MAX_INDEX;
690 switch ( field ) {
691 case UCAL_ERA:
692 index = kIPI_ERA;
693 break;
694 case UCAL_YEAR:
695 index = kIPI_YEAR;
696 break;
697 case UCAL_MONTH:
698 index = kIPI_MONTH;
699 break;
700 case UCAL_DATE:
701 case UCAL_DAY_OF_WEEK:
702 //case UCAL_DAY_OF_MONTH:
703 index = kIPI_DATE;
704 break;
705 case UCAL_AM_PM:
706 index = kIPI_AM_PM;
707 break;
708 case UCAL_HOUR:
709 case UCAL_HOUR_OF_DAY:
710 index = kIPI_HOUR;
711 break;
712 case UCAL_MINUTE:
713 index = kIPI_MINUTE;
714 break;
715 case UCAL_SECOND:
716 index = kIPI_SECOND;
717 break;
718 case UCAL_MILLISECOND:
719 index = kIPI_MILLISECOND;
720 break;
721 default:
722 status = U_ILLEGAL_ARGUMENT_ERROR;
723 }
724 return index;
725}
726
727
728
729void
730DateIntervalInfo::deleteHash(Hashtable* hTable)
731{
732 if ( hTable == nullptr ) {
733 return;
734 }
735 int32_t pos = UHASH_FIRST;
736 const UHashElement* element = nullptr;
737 while ( (element = hTable->nextElement(pos)) != nullptr ) {
738 const UHashTok valueTok = element->value;
739 const UnicodeString* value = (UnicodeString*)valueTok.pointer;
740 delete[] value;
741 }
742 delete fIntervalPatterns;
743}
744
745
746U_CDECL_BEGIN
747
748/**
749 * set hash table value comparator
750 *
751 * @param val1 one value in comparison
752 * @param val2 the other value in comparison
753 * @return TRUE if 2 values are the same, FALSE otherwise
754 */
755static UBool U_CALLCONV dtitvinfHashTableValueComparator(UHashTok val1, UHashTok val2);
756
757static UBool
758U_CALLCONV dtitvinfHashTableValueComparator(UHashTok val1, UHashTok val2) {
759 const UnicodeString* pattern1 = (UnicodeString*)val1.pointer;
760 const UnicodeString* pattern2 = (UnicodeString*)val2.pointer;
761 UBool ret = TRUE;
762 int8_t i;
763 for ( i = 0; i < DateIntervalInfo::kMaxIntervalPatternIndex && ret == TRUE; ++i ) {
764 ret = (pattern1[i] == pattern2[i]);
765 }
766 return ret;
767}
768
769U_CDECL_END
770
771
772Hashtable*
773DateIntervalInfo::initHash(UErrorCode& status) {
774 if ( U_FAILURE(status) ) {
775 return nullptr;
776 }
777 Hashtable* hTable;
778 if ( (hTable = new Hashtable(FALSE, status)) == nullptr ) {
779 status = U_MEMORY_ALLOCATION_ERROR;
780 return nullptr;
781 }
782 if ( U_FAILURE(status) ) {
783 delete hTable;
784 return nullptr;
785 }
786 hTable->setValueComparator(dtitvinfHashTableValueComparator);
787 return hTable;
788}
789
790
791void
792DateIntervalInfo::copyHash(const Hashtable* source,
793 Hashtable* target,
794 UErrorCode& status) {
795 if ( U_FAILURE(status) ) {
796 return;
797 }
798 int32_t pos = UHASH_FIRST;
799 const UHashElement* element = nullptr;
800 if ( source ) {
801 while ( (element = source->nextElement(pos)) != nullptr ) {
802 const UHashTok keyTok = element->key;
803 const UnicodeString* key = (UnicodeString*)keyTok.pointer;
804 const UHashTok valueTok = element->value;
805 const UnicodeString* value = (UnicodeString*)valueTok.pointer;
806 UnicodeString* copy = new UnicodeString[kIPI_MAX_INDEX];
807 if (copy == nullptr) {
808 status = U_MEMORY_ALLOCATION_ERROR;
809 return;
810 }
811 int8_t i;
812 for ( i = 0; i < kIPI_MAX_INDEX; ++i ) {
813 copy[i] = value[i];
814 }
815 target->put(UnicodeString(*key), copy, status);
816 if ( U_FAILURE(status) ) {
817 return;
818 }
819 }
820 }
821}
822
823
824U_NAMESPACE_END
825
826#endif
827