1 /*******************************************************************************
2 * Copyright (C) 2008-2010, International Business Machines Corporation and
3 * others. All Rights Reserved.
4 *******************************************************************************
5 *
6 * File DTITVINF.CPP
7 *
8 *******************************************************************************
9 */
10
11 #include "unicode/dtitvinf.h"
12
13
14 #if !UCONFIG_NO_FORMATTING
15
16 //TODO: define it in compiler time
17 //#define DTITVINF_DEBUG 1
18
19
20 #ifdef DTITVINF_DEBUG
21 #include <iostream>
22 #endif
23
24 #include "cstring.h"
25 #include "unicode/msgfmt.h"
26 #include "unicode/uloc.h"
27 #include "unicode/ures.h"
28 #include "dtitv_impl.h"
29 #include "hash.h"
30 #include "gregoimp.h"
31 #include "uresimp.h"
32 #include "hash.h"
33 #include "gregoimp.h"
34 #include "uresimp.h"
35
36
37 U_NAMESPACE_BEGIN
38
39
40 #ifdef DTITVINF_DEBUG
41 #define PRINTMESG(msg) { std::cout << "(" << __FILE__ << ":" << __LINE__ << ") " << msg << "\n"; }
42 #endif
43
44 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(DateIntervalInfo)
45
46 static const char gCalendarTag[]="calendar";
47 static const char gGregorianTag[]="gregorian";
48 static const char gIntervalDateTimePatternTag[]="intervalFormats";
49 static const char gFallbackPatternTag[]="fallback";
50
51 // {0}
52 static const UChar gFirstPattern[] = {LEFT_CURLY_BRACKET, DIGIT_ZERO, RIGHT_CURLY_BRACKET};
53 // {1}
54 static const UChar gSecondPattern[] = {LEFT_CURLY_BRACKET, DIGIT_ONE, RIGHT_CURLY_BRACKET};
55
56 // default fall-back
57 static const UChar gDefaultFallbackPattern[] = {LEFT_CURLY_BRACKET, DIGIT_ZERO, RIGHT_CURLY_BRACKET, SPACE, EN_DASH, SPACE, LEFT_CURLY_BRACKET, DIGIT_ONE, RIGHT_CURLY_BRACKET, 0};
58
59
60
DateIntervalInfo(UErrorCode & status)61 DateIntervalInfo::DateIntervalInfo(UErrorCode& status)
62 : fFallbackIntervalPattern(gDefaultFallbackPattern),
63 fFirstDateInPtnIsLaterDate(false),
64 fIntervalPatterns(NULL)
65 {
66 fIntervalPatterns = initHash(status);
67 }
68
69
70
DateIntervalInfo(const Locale & locale,UErrorCode & status)71 DateIntervalInfo::DateIntervalInfo(const Locale& locale, UErrorCode& status)
72 : fFallbackIntervalPattern(gDefaultFallbackPattern),
73 fFirstDateInPtnIsLaterDate(false),
74 fIntervalPatterns(NULL)
75 {
76 initializeData(locale, status);
77 }
78
79
80
81 void
setIntervalPattern(const UnicodeString & skeleton,UCalendarDateFields lrgDiffCalUnit,const UnicodeString & intervalPattern,UErrorCode & status)82 DateIntervalInfo::setIntervalPattern(const UnicodeString& skeleton,
83 UCalendarDateFields lrgDiffCalUnit,
84 const UnicodeString& intervalPattern,
85 UErrorCode& status) {
86
87 if ( lrgDiffCalUnit == UCAL_HOUR_OF_DAY ) {
88 setIntervalPatternInternally(skeleton, UCAL_AM_PM, intervalPattern, status);
89 setIntervalPatternInternally(skeleton, UCAL_HOUR, intervalPattern, status);
90 } else if ( lrgDiffCalUnit == UCAL_DAY_OF_MONTH ||
91 lrgDiffCalUnit == UCAL_DAY_OF_WEEK ) {
92 setIntervalPatternInternally(skeleton, UCAL_DATE, intervalPattern, status);
93 } else {
94 setIntervalPatternInternally(skeleton, lrgDiffCalUnit, intervalPattern, status);
95 }
96 }
97
98
99 void
setFallbackIntervalPattern(const UnicodeString & fallbackPattern,UErrorCode & status)100 DateIntervalInfo::setFallbackIntervalPattern(
101 const UnicodeString& fallbackPattern,
102 UErrorCode& status) {
103 if ( U_FAILURE(status) ) {
104 return;
105 }
106 int32_t firstPatternIndex = fallbackPattern.indexOf(gFirstPattern,
107 sizeof(gFirstPattern)/sizeof(gFirstPattern[0]), 0);
108 int32_t secondPatternIndex = fallbackPattern.indexOf(gSecondPattern,
109 sizeof(gSecondPattern)/sizeof(gSecondPattern[0]), 0);
110 if ( firstPatternIndex == -1 || secondPatternIndex == -1 ) {
111 status = U_ILLEGAL_ARGUMENT_ERROR;
112 return;
113 }
114 if ( firstPatternIndex > secondPatternIndex ) {
115 fFirstDateInPtnIsLaterDate = true;
116 }
117 fFallbackIntervalPattern = fallbackPattern;
118 }
119
120
121
DateIntervalInfo(const DateIntervalInfo & dtitvinf)122 DateIntervalInfo::DateIntervalInfo(const DateIntervalInfo& dtitvinf)
123 : UObject(dtitvinf),
124 fIntervalPatterns(NULL)
125 {
126 *this = dtitvinf;
127 }
128
129
130
131 DateIntervalInfo&
operator =(const DateIntervalInfo & dtitvinf)132 DateIntervalInfo::operator=(const DateIntervalInfo& dtitvinf) {
133 if ( this == &dtitvinf ) {
134 return *this;
135 }
136
137 UErrorCode status = U_ZERO_ERROR;
138 deleteHash(fIntervalPatterns);
139 fIntervalPatterns = initHash(status);
140 copyHash(dtitvinf.fIntervalPatterns, fIntervalPatterns, status);
141 if ( U_FAILURE(status) ) {
142 return *this;
143 }
144
145 fFallbackIntervalPattern = dtitvinf.fFallbackIntervalPattern;
146 fFirstDateInPtnIsLaterDate = dtitvinf.fFirstDateInPtnIsLaterDate;
147 return *this;
148 }
149
150
151 DateIntervalInfo*
clone() const152 DateIntervalInfo::clone() const {
153 return new DateIntervalInfo(*this);
154 }
155
156
~DateIntervalInfo()157 DateIntervalInfo::~DateIntervalInfo() {
158 deleteHash(fIntervalPatterns);
159 fIntervalPatterns = NULL;
160 }
161
162
163 UBool
operator ==(const DateIntervalInfo & other) const164 DateIntervalInfo::operator==(const DateIntervalInfo& other) const {
165 UBool equal = (
166 fFallbackIntervalPattern == other.fFallbackIntervalPattern &&
167 fFirstDateInPtnIsLaterDate == other.fFirstDateInPtnIsLaterDate );
168
169 if ( equal == TRUE ) {
170 equal = fIntervalPatterns->equals(*(other.fIntervalPatterns));
171 }
172
173 return equal;
174 }
175
176
177 UnicodeString&
getIntervalPattern(const UnicodeString & skeleton,UCalendarDateFields field,UnicodeString & result,UErrorCode & status) const178 DateIntervalInfo::getIntervalPattern(const UnicodeString& skeleton,
179 UCalendarDateFields field,
180 UnicodeString& result,
181 UErrorCode& status) const {
182 if ( U_FAILURE(status) ) {
183 return result;
184 }
185
186 const UnicodeString* patternsOfOneSkeleton = (UnicodeString*) fIntervalPatterns->get(skeleton);
187 if ( patternsOfOneSkeleton != NULL ) {
188 IntervalPatternIndex index = calendarFieldToIntervalIndex(field, status);
189 if ( U_FAILURE(status) ) {
190 return result;
191 }
192 const UnicodeString& intervalPattern = patternsOfOneSkeleton[index];
193 if ( !intervalPattern.isEmpty() ) {
194 result = intervalPattern;
195 }
196 }
197 return result;
198 }
199
200
201 UBool
getDefaultOrder() const202 DateIntervalInfo::getDefaultOrder() const {
203 return fFirstDateInPtnIsLaterDate;
204 }
205
206
207 UnicodeString&
getFallbackIntervalPattern(UnicodeString & result) const208 DateIntervalInfo::getFallbackIntervalPattern(UnicodeString& result) const {
209 result = fFallbackIntervalPattern;
210 return result;
211 }
212
213 #define ULOC_LOCALE_IDENTIFIER_CAPACITY (ULOC_FULLNAME_CAPACITY + 1 + ULOC_KEYWORD_AND_VALUES_CAPACITY)
214
215 void
initializeData(const Locale & locale,UErrorCode & err)216 DateIntervalInfo::initializeData(const Locale& locale, UErrorCode& err)
217 {
218 fIntervalPatterns = initHash(err);
219 if ( U_FAILURE(err) ) {
220 return;
221 }
222 const char *locName = locale.getName();
223 char parentLocale[ULOC_FULLNAME_CAPACITY];
224 int32_t locNameLen;
225 uprv_strcpy(parentLocale, locName);
226 UErrorCode status = U_ZERO_ERROR;
227 Hashtable skeletonSet(FALSE, status);
228 if ( U_FAILURE(status) ) {
229 return;
230 }
231
232 // determine calendar type
233 const char * calendarTypeToUse = gGregorianTag; // initial default
234 char calendarType[ULOC_KEYWORDS_CAPACITY]; // to be filled in with the type to use, if all goes well
235 char localeWithCalendarKey[ULOC_LOCALE_IDENTIFIER_CAPACITY];
236 // obtain a locale that always has the calendar key value that should be used
237 (void)ures_getFunctionalEquivalent(localeWithCalendarKey, ULOC_LOCALE_IDENTIFIER_CAPACITY, NULL,
238 "calendar", "calendar", locName, NULL, FALSE, &status);
239 localeWithCalendarKey[ULOC_LOCALE_IDENTIFIER_CAPACITY-1] = 0; // ensure null termination
240 // now get the calendar key value from that locale
241 int32_t calendarTypeLen = uloc_getKeywordValue(localeWithCalendarKey, "calendar", calendarType, ULOC_KEYWORDS_CAPACITY, &status);
242 if (U_SUCCESS(status) && calendarTypeLen < ULOC_KEYWORDS_CAPACITY) {
243 calendarTypeToUse = calendarType;
244 }
245 status = U_ZERO_ERROR;
246
247 do {
248 UResourceBundle *rb, *calBundle, *calTypeBundle, *itvDtPtnResource;
249 rb = ures_open(NULL, parentLocale, &status);
250 calBundle = ures_getByKey(rb, gCalendarTag, NULL, &status);
251 calTypeBundle = ures_getByKey(calBundle, calendarTypeToUse, NULL, &status);
252 itvDtPtnResource = ures_getByKeyWithFallback(calTypeBundle,
253 gIntervalDateTimePatternTag, NULL, &status);
254
255 if ( U_SUCCESS(status) ) {
256 // look for fallback first, since it establishes the default order
257 const UChar* resStr;
258 int32_t resStrLen = 0;
259 resStr = ures_getStringByKeyWithFallback(itvDtPtnResource,
260 gFallbackPatternTag,
261 &resStrLen, &status);
262 if ( U_SUCCESS(status) ) {
263 UnicodeString pattern = UnicodeString(TRUE, resStr, resStrLen);
264 setFallbackIntervalPattern(pattern, status);
265 }
266
267 int32_t size = ures_getSize(itvDtPtnResource);
268 int32_t index;
269 for ( index = 0; index < size; ++index ) {
270 UResourceBundle* oneRes = ures_getByIndex(itvDtPtnResource, index,
271 NULL, &status);
272 if ( U_SUCCESS(status) ) {
273 const char* skeleton = ures_getKey(oneRes);
274 if ( skeleton == NULL ||
275 skeletonSet.geti(UnicodeString(skeleton)) == 1 ) {
276 ures_close(oneRes);
277 continue;
278 }
279 skeletonSet.puti(UnicodeString(skeleton), 1, status);
280 if ( uprv_strcmp(skeleton, gFallbackPatternTag) == 0 ) {
281 ures_close(oneRes);
282 continue; // fallback
283 }
284
285 UResourceBundle* intervalPatterns = ures_getByKey(
286 itvDtPtnResource, skeleton, NULL, &status);
287
288 if ( U_FAILURE(status) ) {
289 ures_close(intervalPatterns);
290 ures_close(oneRes);
291 break;
292 }
293 if ( intervalPatterns == NULL ) {
294 ures_close(intervalPatterns);
295 ures_close(oneRes);
296 continue;
297 }
298
299 const UChar* pattern;
300 const char* key;
301 int32_t ptLength;
302 int32_t ptnNum = ures_getSize(intervalPatterns);
303 int32_t ptnIndex;
304 for ( ptnIndex = 0; ptnIndex < ptnNum; ++ptnIndex ) {
305 pattern = ures_getNextString(intervalPatterns, &ptLength, &key,
306 &status);
307 if ( U_FAILURE(status) ) {
308 break;
309 }
310
311 UCalendarDateFields calendarField = UCAL_FIELD_COUNT;
312 if ( !uprv_strcmp(key, "y") ) {
313 calendarField = UCAL_YEAR;
314 } else if ( !uprv_strcmp(key, "M") ) {
315 calendarField = UCAL_MONTH;
316 } else if ( !uprv_strcmp(key, "d") ) {
317 calendarField = UCAL_DATE;
318 } else if ( !uprv_strcmp(key, "a") ) {
319 calendarField = UCAL_AM_PM;
320 } else if ( !uprv_strcmp(key, "h") || !uprv_strcmp(key, "H") ) {
321 calendarField = UCAL_HOUR;
322 } else if ( !uprv_strcmp(key, "m") ) {
323 calendarField = UCAL_MINUTE;
324 }
325 if ( calendarField != UCAL_FIELD_COUNT ) {
326 setIntervalPatternInternally(skeleton, calendarField, pattern,status);
327 }
328 }
329 ures_close(intervalPatterns);
330 }
331 ures_close(oneRes);
332 }
333 }
334 ures_close(itvDtPtnResource);
335 ures_close(calTypeBundle);
336 ures_close(calBundle);
337 ures_close(rb);
338 status = U_ZERO_ERROR;
339 locNameLen = uloc_getParent(parentLocale, parentLocale,
340 ULOC_FULLNAME_CAPACITY,&status);
341 } while ( locNameLen > 0 );
342 }
343
344
345
346 void
setIntervalPatternInternally(const UnicodeString & skeleton,UCalendarDateFields lrgDiffCalUnit,const UnicodeString & intervalPattern,UErrorCode & status)347 DateIntervalInfo::setIntervalPatternInternally(const UnicodeString& skeleton,
348 UCalendarDateFields lrgDiffCalUnit,
349 const UnicodeString& intervalPattern,
350 UErrorCode& status) {
351 IntervalPatternIndex index = calendarFieldToIntervalIndex(lrgDiffCalUnit,status);
352 if ( U_FAILURE(status) ) {
353 return;
354 }
355 UnicodeString* patternsOfOneSkeleton = (UnicodeString*)(fIntervalPatterns->get(skeleton));
356 UBool emptyHash = false;
357 if ( patternsOfOneSkeleton == NULL ) {
358 patternsOfOneSkeleton = new UnicodeString[kIPI_MAX_INDEX];
359 emptyHash = true;
360 }
361
362 patternsOfOneSkeleton[index] = intervalPattern;
363 if ( emptyHash == TRUE ) {
364 fIntervalPatterns->put(skeleton, patternsOfOneSkeleton, status);
365 }
366 }
367
368
369
370 void
parseSkeleton(const UnicodeString & skeleton,int32_t * skeletonFieldWidth)371 DateIntervalInfo::parseSkeleton(const UnicodeString& skeleton,
372 int32_t* skeletonFieldWidth) {
373 const int8_t PATTERN_CHAR_BASE = 0x41;
374 int32_t i;
375 for ( i = 0; i < skeleton.length(); ++i ) {
376 // it is an ASCII char in skeleton
377 int8_t ch = (int8_t)skeleton.charAt(i);
378 ++skeletonFieldWidth[ch - PATTERN_CHAR_BASE];
379 }
380 }
381
382
383
384 UBool
stringNumeric(int32_t fieldWidth,int32_t anotherFieldWidth,char patternLetter)385 DateIntervalInfo::stringNumeric(int32_t fieldWidth, int32_t anotherFieldWidth,
386 char patternLetter) {
387 if ( patternLetter == 'M' ) {
388 if ( (fieldWidth <= 2 && anotherFieldWidth > 2) ||
389 (fieldWidth > 2 && anotherFieldWidth <= 2 )) {
390 return true;
391 }
392 }
393 return false;
394 }
395
396
397
398 const UnicodeString*
getBestSkeleton(const UnicodeString & skeleton,int8_t & bestMatchDistanceInfo) const399 DateIntervalInfo::getBestSkeleton(const UnicodeString& skeleton,
400 int8_t& bestMatchDistanceInfo) const {
401 #ifdef DTITVINF_DEBUG
402 char result[1000];
403 char result_1[1000];
404 char mesg[2000];
405 skeleton.extract(0, skeleton.length(), result, "UTF-8");
406 sprintf(mesg, "in getBestSkeleton: skeleton: %s; \n", result);
407 PRINTMESG(mesg)
408 #endif
409
410
411 int32_t inputSkeletonFieldWidth[] =
412 {
413 // A B C D E F G H I J K L M N O
414 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
415 // P Q R S T U V W X Y Z
416 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
417 // a b c d e f g h i j k l m n o
418 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
419 // p q r s t u v w x y z
420 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
421 };
422
423 int32_t skeletonFieldWidth[] =
424 {
425 // A B C D E F G H I J K L M N O
426 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
427 // P Q R S T U V W X Y Z
428 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
429 // a b c d e f g h i j k l m n o
430 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
431 // p q r s t u v w x y z
432 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
433 };
434
435 const int32_t DIFFERENT_FIELD = 0x1000;
436 const int32_t STRING_NUMERIC_DIFFERENCE = 0x100;
437 const int32_t BASE = 0x41;
438 const UChar CHAR_V = 0x0076;
439 const UChar CHAR_Z = 0x007A;
440
441 // hack for 'v' and 'z'.
442 // resource bundle only have time skeletons ending with 'v',
443 // but not for time skeletons ending with 'z'.
444 UBool replaceZWithV = false;
445 const UnicodeString* inputSkeleton = &skeleton;
446 UnicodeString copySkeleton;
447 if ( skeleton.indexOf(CHAR_Z) != -1 ) {
448 UChar zstr[2];
449 UChar vstr[2];
450 zstr[0]=CHAR_Z;
451 vstr[0]=CHAR_V;
452 zstr[1]=0;
453 vstr[1]=0;
454 copySkeleton = skeleton;
455 copySkeleton.findAndReplace(zstr, vstr);
456 inputSkeleton = ©Skeleton;
457 replaceZWithV = true;
458 }
459
460 parseSkeleton(*inputSkeleton, inputSkeletonFieldWidth);
461 int32_t bestDistance = MAX_POSITIVE_INT;
462 const UnicodeString* bestSkeleton = NULL;
463
464 // 0 means exact the same skeletons;
465 // 1 means having the same field, but with different length,
466 // 2 means only z/v differs
467 // -1 means having different field.
468 bestMatchDistanceInfo = 0;
469 int8_t fieldLength = sizeof(skeletonFieldWidth)/sizeof(skeletonFieldWidth[0]);
470
471 int32_t pos = -1;
472 const UHashElement* elem = NULL;
473 while ( (elem = fIntervalPatterns->nextElement(pos)) != NULL ) {
474 const UHashTok keyTok = elem->key;
475 UnicodeString* skeleton = (UnicodeString*)keyTok.pointer;
476 #ifdef DTITVINF_DEBUG
477 skeleton->extract(0, skeleton->length(), result, "UTF-8");
478 sprintf(mesg, "available skeletons: skeleton: %s; \n", result);
479 PRINTMESG(mesg)
480 #endif
481
482 // clear skeleton field width
483 int8_t i;
484 for ( i = 0; i < fieldLength; ++i ) {
485 skeletonFieldWidth[i] = 0;
486 }
487 parseSkeleton(*skeleton, skeletonFieldWidth);
488 // calculate distance
489 int32_t distance = 0;
490 int8_t fieldDifference = 1;
491 for ( i = 0; i < fieldLength; ++i ) {
492 int32_t inputFieldWidth = inputSkeletonFieldWidth[i];
493 int32_t fieldWidth = skeletonFieldWidth[i];
494 if ( inputFieldWidth == fieldWidth ) {
495 continue;
496 }
497 if ( inputFieldWidth == 0 ) {
498 fieldDifference = -1;
499 distance += DIFFERENT_FIELD;
500 } else if ( fieldWidth == 0 ) {
501 fieldDifference = -1;
502 distance += DIFFERENT_FIELD;
503 } else if (stringNumeric(inputFieldWidth, fieldWidth,
504 (char)(i+BASE) ) ) {
505 distance += STRING_NUMERIC_DIFFERENCE;
506 } else {
507 distance += (inputFieldWidth > fieldWidth) ?
508 (inputFieldWidth - fieldWidth) :
509 (fieldWidth - inputFieldWidth);
510 }
511 }
512 if ( distance < bestDistance ) {
513 bestSkeleton = skeleton;
514 bestDistance = distance;
515 bestMatchDistanceInfo = fieldDifference;
516 }
517 if ( distance == 0 ) {
518 bestMatchDistanceInfo = 0;
519 break;
520 }
521 }
522 if ( replaceZWithV && bestMatchDistanceInfo != -1 ) {
523 bestMatchDistanceInfo = 2;
524 }
525 return bestSkeleton;
526 }
527
528
529
530 DateIntervalInfo::IntervalPatternIndex
calendarFieldToIntervalIndex(UCalendarDateFields field,UErrorCode & status)531 DateIntervalInfo::calendarFieldToIntervalIndex(UCalendarDateFields field,
532 UErrorCode& status) {
533 if ( U_FAILURE(status) ) {
534 return kIPI_MAX_INDEX;
535 }
536 IntervalPatternIndex index = kIPI_MAX_INDEX;
537 switch ( field ) {
538 case UCAL_ERA:
539 index = kIPI_ERA;
540 break;
541 case UCAL_YEAR:
542 index = kIPI_YEAR;
543 break;
544 case UCAL_MONTH:
545 index = kIPI_MONTH;
546 break;
547 case UCAL_DATE:
548 case UCAL_DAY_OF_WEEK:
549 //case UCAL_DAY_OF_MONTH:
550 index = kIPI_DATE;
551 break;
552 case UCAL_AM_PM:
553 index = kIPI_AM_PM;
554 break;
555 case UCAL_HOUR:
556 case UCAL_HOUR_OF_DAY:
557 index = kIPI_HOUR;
558 break;
559 case UCAL_MINUTE:
560 index = kIPI_MINUTE;
561 break;
562 default:
563 status = U_ILLEGAL_ARGUMENT_ERROR;
564 }
565 return index;
566 }
567
568
569
570 void
deleteHash(Hashtable * hTable)571 DateIntervalInfo::deleteHash(Hashtable* hTable)
572 {
573 if ( hTable == NULL ) {
574 return;
575 }
576 int32_t pos = -1;
577 const UHashElement* element = NULL;
578 while ( (element = hTable->nextElement(pos)) != NULL ) {
579 const UHashTok keyTok = element->key;
580 const UHashTok valueTok = element->value;
581 const UnicodeString* value = (UnicodeString*)valueTok.pointer;
582 delete[] value;
583 }
584 delete fIntervalPatterns;
585 }
586
587
588 U_CDECL_BEGIN
589
590 /**
591 * set hash table value comparator
592 *
593 * @param val1 one value in comparison
594 * @param val2 the other value in comparison
595 * @return TRUE if 2 values are the same, FALSE otherwise
596 */
597 static UBool U_CALLCONV dtitvinfHashTableValueComparator(UHashTok val1, UHashTok val2);
598
599 static UBool
dtitvinfHashTableValueComparator(UHashTok val1,UHashTok val2)600 U_CALLCONV dtitvinfHashTableValueComparator(UHashTok val1, UHashTok val2) {
601 const UnicodeString* pattern1 = (UnicodeString*)val1.pointer;
602 const UnicodeString* pattern2 = (UnicodeString*)val2.pointer;
603 UBool ret = TRUE;
604 int8_t i;
605 for ( i = 0; i < DateIntervalInfo::kMaxIntervalPatternIndex && ret == TRUE; ++i ) {
606 ret = (pattern1[i] == pattern2[i]);
607 }
608 return ret;
609 }
610
611 U_CDECL_END
612
613
614 Hashtable*
initHash(UErrorCode & status)615 DateIntervalInfo::initHash(UErrorCode& status) {
616 if ( U_FAILURE(status) ) {
617 return NULL;
618 }
619 Hashtable* hTable;
620 if ( (hTable = new Hashtable(FALSE, status)) == NULL ) {
621 status = U_MEMORY_ALLOCATION_ERROR;
622 return NULL;
623 }
624 hTable->setValueComparator(dtitvinfHashTableValueComparator);
625 return hTable;
626 }
627
628
629 void
copyHash(const Hashtable * source,Hashtable * target,UErrorCode & status)630 DateIntervalInfo::copyHash(const Hashtable* source,
631 Hashtable* target,
632 UErrorCode& status) {
633 if ( U_FAILURE(status) ) {
634 return;
635 }
636 int32_t pos = -1;
637 const UHashElement* element = NULL;
638 if ( source ) {
639 while ( (element = source->nextElement(pos)) != NULL ) {
640 const UHashTok keyTok = element->key;
641 const UnicodeString* key = (UnicodeString*)keyTok.pointer;
642 const UHashTok valueTok = element->value;
643 const UnicodeString* value = (UnicodeString*)valueTok.pointer;
644 UnicodeString* copy = new UnicodeString[kIPI_MAX_INDEX];
645 int8_t i;
646 for ( i = 0; i < kIPI_MAX_INDEX; ++i ) {
647 copy[i] = value[i];
648 }
649 target->put(UnicodeString(*key), copy, status);
650 if ( U_FAILURE(status) ) {
651 return;
652 }
653 }
654 }
655 }
656
657
658 U_NAMESPACE_END
659
660 #endif
661