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

/*******************************************************************************
* Copyright (C) 2008, International Business Machines Corporation and
* others. All Rights Reserved.
*******************************************************************************
*
* File DTITVINF.CPP 
*
*******************************************************************************
*/

#include "unicode/dtitvinf.h"


#if !UCONFIG_NO_FORMATTING

//FIXME: define it in compiler time
//#define DTITVINF_DEBUG 1


#ifdef DTITVINF_DEBUG 
#include <iostream>
#endif

#include "cstring.h"
#include "unicode/msgfmt.h"
#include "dtitv_impl.h"
#include "hash.h"
#include "gregoimp.h"
#include "uresimp.h"
#include "hash.h"
#include "gregoimp.h"
#include "uresimp.h"


U_NAMESPACE_BEGIN


#ifdef DTITVINF_DEBUG 
#define PRINTMESG(msg) { std::cout << "(" << __FILE__ << ":" << __LINE__ << ") " << msg << "\n"; }
#endif

UOBJECT_DEFINE_RTTI_IMPLEMENTATION(DateIntervalInfo)

static const char gCalendarTag[]="calendar";
static const char gGregorianTag[]="gregorian";
static const char gIntervalDateTimePatternTag[]="intervalFormats";
static const char gFallbackPatternTag[]="fallback";

// {0}
static const UChar gFirstPattern[] = {LEFT_CURLY_BRACKET, DIGIT_ZERO, RIGHT_CURLY_BRACKET};
// {1}
static const UChar gSecondPattern[] = {LEFT_CURLY_BRACKET, DIGIT_ONE, RIGHT_CURLY_BRACKET};

// default fall-back
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};


DateIntervalInfo::DateIntervalInfo(UErrorCode& status) 
:   fFallbackIntervalPattern(gDefaultFallbackPattern),
    fFirstDateInPtnIsLaterDate(false),
    fIntervalPatterns(NULL)
{
    fIntervalPatterns = initHash(status);
}


DateIntervalInfo::DateIntervalInfo(const Locale& locale, UErrorCode& status)
:   fFallbackIntervalPattern(gDefaultFallbackPattern),
    fFirstDateInPtnIsLaterDate(false),
    fIntervalPatterns(NULL)
{
    initializeData(locale, status);
}


void
DateIntervalInfo::setIntervalPattern(const UnicodeString& skeleton,
                                     UCalendarDateFields lrgDiffCalUnit,
                                     const UnicodeString& intervalPattern,
                                     UErrorCode& status) {
    
    if ( lrgDiffCalUnit == UCAL_HOUR_OF_DAY ) {
        setIntervalPatternInternally(skeleton, UCAL_AM_PM, intervalPattern, status);
        setIntervalPatternInternally(skeleton, UCAL_HOUR, intervalPattern, status);
    } else if ( lrgDiffCalUnit == UCAL_DAY_OF_MONTH ||
                lrgDiffCalUnit == UCAL_DAY_OF_WEEK ) {
        setIntervalPatternInternally(skeleton, UCAL_DATE, intervalPattern, status);
    } else {
        setIntervalPatternInternally(skeleton, lrgDiffCalUnit, intervalPattern, status);
    }
}


void
DateIntervalInfo::setFallbackIntervalPattern(
                                    const UnicodeString& fallbackPattern,
                                    UErrorCode& status) {
    if ( U_FAILURE(status) ) {
        return;
    }
    int32_t firstPatternIndex = fallbackPattern.indexOf(gFirstPattern, 
                        sizeof(gFirstPattern)/sizeof(gFirstPattern[0]), 0);
    int32_t secondPatternIndex = fallbackPattern.indexOf(gSecondPattern, 
                        sizeof(gSecondPattern)/sizeof(gSecondPattern[0]), 0);
    if ( firstPatternIndex == -1 || secondPatternIndex == -1 ) {
        status = U_ILLEGAL_ARGUMENT_ERROR;
        return;
    }
    if ( firstPatternIndex > secondPatternIndex ) { 
        fFirstDateInPtnIsLaterDate = true;
    }
    fFallbackIntervalPattern = fallbackPattern;
}


DateIntervalInfo::DateIntervalInfo(const DateIntervalInfo& dtitvinf)
:   UObject(dtitvinf),
    fIntervalPatterns(NULL)
{
    *this = dtitvinf;
}
    

DateIntervalInfo&
DateIntervalInfo::operator=(const DateIntervalInfo& dtitvinf) {
    if ( this == &dtitvinf ) {
        return *this;
    }
    
    UErrorCode status = U_ZERO_ERROR;
    deleteHash(fIntervalPatterns);
    fIntervalPatterns = initHash(status);
    copyHash(dtitvinf.fIntervalPatterns, fIntervalPatterns, status);
    if ( U_FAILURE(status) ) {
        return *this;
    } 

    fFallbackIntervalPattern = dtitvinf.fFallbackIntervalPattern;
    fFirstDateInPtnIsLaterDate = dtitvinf.fFirstDateInPtnIsLaterDate;
    return *this;
}


DateIntervalInfo*
DateIntervalInfo::clone() const {
    return new DateIntervalInfo(*this);
}


DateIntervalInfo::~DateIntervalInfo() {
    deleteHash(fIntervalPatterns);
    fIntervalPatterns = NULL;
}


UBool
DateIntervalInfo::operator==(const DateIntervalInfo& other) const {
    UBool equal = ( 
      fFallbackIntervalPattern == other.fFallbackIntervalPattern &&
      fFirstDateInPtnIsLaterDate == other.fFirstDateInPtnIsLaterDate );

    if ( equal == TRUE ) {
        equal = fIntervalPatterns->equals(*(other.fIntervalPatterns));
    }

    return equal;
}


UnicodeString&
DateIntervalInfo::getIntervalPattern(const UnicodeString& skeleton,
                                     UCalendarDateFields field,
                                     UnicodeString& result,
                                     UErrorCode& status) const {
    if ( U_FAILURE(status) ) {
        return result;
    }
   
    const UnicodeString* patternsOfOneSkeleton = (UnicodeString*) fIntervalPatterns->get(skeleton);
    if ( patternsOfOneSkeleton != NULL ) {
        IntervalPatternIndex index = calendarFieldToIntervalIndex(field, status);
        if ( U_FAILURE(status) ) {
            return result;
        }
        const UnicodeString& intervalPattern =  patternsOfOneSkeleton[index];
        if ( !intervalPattern.isEmpty() ) {
            result = intervalPattern;
        }
    }
    return result;
}


UBool
DateIntervalInfo::getDefaultOrder() const {
    return fFirstDateInPtnIsLaterDate;
}


UnicodeString&
DateIntervalInfo::getFallbackIntervalPattern(UnicodeString& result) const {
    result = fFallbackIntervalPattern;
    return result;
}


void 
DateIntervalInfo::initializeData(const Locale& locale, UErrorCode& err)
{
  fIntervalPatterns = initHash(err);
  if ( U_FAILURE(err) ) {
      return;
  }
  const char *locName = locale.getName();
  char parentLocale[ULOC_FULLNAME_CAPACITY];
  int32_t locNameLen;
  uprv_strcpy(parentLocale, locName);
  UErrorCode status = U_ZERO_ERROR;
  Hashtable skeletonSet(TRUE, status);
  if ( U_FAILURE(status) ) {
      return;
  }
  do {
    UResourceBundle *rb, *calBundle, *gregorianBundle, *itvDtPtnResource;
    rb = ures_open(NULL, parentLocale, &status);
    calBundle = ures_getByKey(rb, gCalendarTag, NULL, &status); 
    gregorianBundle = ures_getByKey(calBundle, gGregorianTag, NULL, &status);
    itvDtPtnResource = ures_getByKeyWithFallback(gregorianBundle, 
                         gIntervalDateTimePatternTag, NULL, &status);

    if ( U_SUCCESS(status) ) {
        // look for fallback first, since it establishes the default order
        const UChar* resStr;
        int32_t resStrLen = 0;
        resStr = ures_getStringByKeyWithFallback(itvDtPtnResource, 
                                             gFallbackPatternTag, 
                                             &resStrLen, &status);
        if ( U_SUCCESS(status) ) {
            UnicodeString pattern = UnicodeString(TRUE, resStr, resStrLen);
            setFallbackIntervalPattern(pattern, status);
        }

        int32_t size = ures_getSize(itvDtPtnResource);
        int32_t index;
        for ( index = 0; index < size; ++index ) {
            UResourceBundle* oneRes = ures_getByIndex(itvDtPtnResource, index, 
                                                     NULL, &status);
            if ( U_SUCCESS(status) ) {
                const char* skeleton = ures_getKey(oneRes);
                if ( skeleton == NULL || 
                     skeletonSet.geti(UnicodeString(skeleton)) == 1 ) {
                    ures_close(oneRes);
                    continue;
                }
                skeletonSet.puti(UnicodeString(skeleton), 1, status);
                if ( uprv_strcmp(skeleton, gFallbackPatternTag) == 0 ) {
                    ures_close(oneRes);
                    continue;  // fallback
                }
    
                UResourceBundle* intervalPatterns = ures_getByKey(
                                     itvDtPtnResource, skeleton, NULL, &status);
    
                if ( U_FAILURE(status) ) {
                    ures_close(intervalPatterns);
                    ures_close(oneRes);
                    break;
                }
                if ( intervalPatterns == NULL ) {
                    ures_close(intervalPatterns);
                    ures_close(oneRes);
                    continue;
                }
    
                const UChar* pattern;
                const char* key;
                int32_t ptLength;
                int32_t ptnNum = ures_getSize(intervalPatterns);
                int32_t ptnIndex;
                for ( ptnIndex = 0; ptnIndex < ptnNum; ++ptnIndex ) {
                    pattern = ures_getNextString(intervalPatterns, &ptLength, &key,
                                                 &status);
                    if ( U_FAILURE(status) ) {
                        break;
                    }
        
                    UCalendarDateFields calendarField = UCAL_FIELD_COUNT;
                    if ( !uprv_strcmp(key, "y") ) {
                        calendarField = UCAL_YEAR;
                    } else if ( !uprv_strcmp(key, "M") ) {
                        calendarField = UCAL_MONTH;
                    } else if ( !uprv_strcmp(key, "d") ) {
                        calendarField = UCAL_DATE;
                    } else if ( !uprv_strcmp(key, "a") ) {
                        calendarField = UCAL_AM_PM;
                    } else if ( !uprv_strcmp(key, "h") ) {
                        calendarField = UCAL_HOUR;
                    } else if ( !uprv_strcmp(key, "m") ) {
                        calendarField = UCAL_MINUTE;
                    }
                    if ( calendarField != UCAL_FIELD_COUNT ) {
                        setIntervalPatternInternally(skeleton, calendarField, pattern,status);
                    }
                }
                ures_close(intervalPatterns);
            }
            ures_close(oneRes);
        }
    }
    ures_close(itvDtPtnResource);
    ures_close(gregorianBundle);
    ures_close(calBundle);
    ures_close(rb);
    status = U_ZERO_ERROR;
    locNameLen = uloc_getParent(parentLocale, parentLocale,50,&status);
  } while ( locNameLen > 0 );
}


void
DateIntervalInfo::setIntervalPatternInternally(const UnicodeString& skeleton,
                                      UCalendarDateFields lrgDiffCalUnit,
                                      const UnicodeString& intervalPattern,
                                      UErrorCode& status) {
    IntervalPatternIndex index = calendarFieldToIntervalIndex(lrgDiffCalUnit,status);
    if ( U_FAILURE(status) ) {
        return;
    }
    UnicodeString* patternsOfOneSkeleton = (UnicodeString*)(fIntervalPatterns->get(skeleton));
    UBool emptyHash = false;
    if ( patternsOfOneSkeleton == NULL ) {
        patternsOfOneSkeleton = new UnicodeString[kIPI_MAX_INDEX];
        emptyHash = true;
    }
    
    patternsOfOneSkeleton[index] = intervalPattern;
    if ( emptyHash == TRUE ) {
        fIntervalPatterns->put(skeleton, patternsOfOneSkeleton, status);
    }
}


void 
DateIntervalInfo::parseSkeleton(const UnicodeString& skeleton, 
                                int32_t* skeletonFieldWidth) {
    const int8_t PATTERN_CHAR_BASE = 0x41;
    int32_t i;
    for ( i = 0; i < skeleton.length(); ++i ) {
        // it is an ASCII char in skeleton
        int8_t ch = (int8_t)skeleton.charAt(i);  
        ++skeletonFieldWidth[ch - PATTERN_CHAR_BASE];
    }
}


UBool 
DateIntervalInfo::stringNumeric(int32_t fieldWidth, int32_t anotherFieldWidth,
                                char patternLetter) {
    if ( patternLetter == 'M' ) {
        if ( fieldWidth <= 2 && anotherFieldWidth > 2 ||
             fieldWidth > 2 && anotherFieldWidth <= 2 ) {
            return true;
        }
    }
    return false;
}


const UnicodeString* 
DateIntervalInfo::getBestSkeleton(const UnicodeString& skeleton,
                                  int8_t& bestMatchDistanceInfo) const {
#ifdef DTITVINF_DEBUG
    char result[1000];
    char result_1[1000];
    char mesg[2000];
    skeleton.extract(0,  skeleton.length(), result, "UTF-8");
    sprintf(mesg, "in getBestSkeleton: skeleton: %s; \n", result);
    PRINTMESG(mesg)
#endif


    int32_t inputSkeletonFieldWidth[] =
    {
    //       A   B   C   D   E   F   G   H   I   J   K   L   M   N   O
             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
    //   P   Q   R   S   T   U   V   W   X   Y   Z
         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0, 0,  0, 0, 0,
    //       a   b   c   d   e   f   g   h   i   j   k   l   m   n   o
         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
    //   p   q   r   s   t   u   v   w   x   y   z
         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
    };

    int32_t skeletonFieldWidth[] =
    {
    //       A   B   C   D   E   F   G   H   I   J   K   L   M   N   O
             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
    //   P   Q   R   S   T   U   V   W   X   Y   Z
         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0, 0,  0, 0, 0,
    //       a   b   c   d   e   f   g   h   i   j   k   l   m   n   o
         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
    //   p   q   r   s   t   u   v   w   x   y   z
         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
    };

    const int32_t DIFFERENT_FIELD = 0x1000;
    const int32_t STRING_NUMERIC_DIFFERENCE = 0x100;
    const int32_t BASE = 0x41;
    const UChar CHAR_V = 0x0076;
    const UChar CHAR_Z = 0x007A;

    // hack for 'v' and 'z'.
    // resource bundle only have time skeletons ending with 'v',
    // but not for time skeletons ending with 'z'.
    UBool replaceZWithV = false;
    const UnicodeString* inputSkeleton = &skeleton; 
    UnicodeString copySkeleton;
    if ( skeleton.indexOf(CHAR_Z) != -1 ) {
        UChar zstr[2];
        UChar vstr[2]; 
        zstr[0]=CHAR_Z;
        vstr[0]=CHAR_V;
        zstr[1]=0;
        vstr[1]=0;
        copySkeleton = skeleton;
        copySkeleton.findAndReplace(zstr, vstr);
        inputSkeleton = &copySkeleton;
        replaceZWithV = true;
    }

    parseSkeleton(*inputSkeleton, inputSkeletonFieldWidth);
    int32_t bestDistance = MAX_POSITIVE_INT;
    const UnicodeString* bestSkeleton = NULL;

    // 0 means exact the same skeletons;
    // 1 means having the same field, but with different length,
    // 2 means only z/v differs
    // -1 means having different field.
    bestMatchDistanceInfo = 0;
    int8_t fieldLength = sizeof(skeletonFieldWidth)/sizeof(skeletonFieldWidth[0]);

    int32_t pos = -1;
    const UHashElement* elem = NULL;
    while ( (elem = fIntervalPatterns->nextElement(pos)) != NULL ) {
        const UHashTok keyTok = elem->key;
        UnicodeString* skeleton = (UnicodeString*)keyTok.pointer;
#ifdef DTITVINF_DEBUG
    skeleton->extract(0,  skeleton->length(), result, "UTF-8");
    sprintf(mesg, "available skeletons: skeleton: %s; \n", result);
    PRINTMESG(mesg)
#endif

        // clear skeleton field width
        int8_t i;
        for ( i = 0; i < fieldLength; ++i ) {
            skeletonFieldWidth[i] = 0;    
        }
        parseSkeleton(*skeleton, skeletonFieldWidth);
        // calculate distance
        int32_t distance = 0;
        int8_t fieldDifference = 1;
        for ( i = 0; i < fieldLength; ++i ) {
            int32_t inputFieldWidth = inputSkeletonFieldWidth[i];
            int32_t fieldWidth = skeletonFieldWidth[i];
            if ( inputFieldWidth == fieldWidth ) {
                continue;
            }
            if ( inputFieldWidth == 0 ) {
                fieldDifference = -1;
                distance += DIFFERENT_FIELD;
            } else if ( fieldWidth == 0 ) {
                fieldDifference = -1;
                distance += DIFFERENT_FIELD;
            } else if (stringNumeric(inputFieldWidth, fieldWidth, 
                                     (char)(i+BASE) ) ) {
                distance += STRING_NUMERIC_DIFFERENCE;
            } else {
                distance += (inputFieldWidth > fieldWidth) ? 
                            (inputFieldWidth - fieldWidth) : 
                            (fieldWidth - inputFieldWidth);
            }
        }
        if ( distance < bestDistance ) {
            bestSkeleton = skeleton;
            bestDistance = distance;
            bestMatchDistanceInfo = fieldDifference;
        }
        if ( distance == 0 ) {
            bestMatchDistanceInfo = 0;
            break;
        }
    }
    if ( replaceZWithV && bestMatchDistanceInfo != -1 ) {
        bestMatchDistanceInfo = 2;
    }
    return bestSkeleton;
}


DateIntervalInfo::IntervalPatternIndex
DateIntervalInfo::calendarFieldToIntervalIndex(UCalendarDateFields field, 
                                               UErrorCode& status) {
    if ( U_FAILURE(status) ) {
        return kIPI_MAX_INDEX;
    }
    IntervalPatternIndex index = kIPI_MAX_INDEX;
    switch ( field ) {
      case UCAL_ERA:
        index = kIPI_ERA;
        break;
      case UCAL_YEAR:
        index = kIPI_YEAR;
        break;
      case UCAL_MONTH:
        index = kIPI_MONTH;
        break;
      case UCAL_DATE:
      case UCAL_DAY_OF_WEEK:
      //case UCAL_DAY_OF_MONTH:
        index = kIPI_DATE;
        break;
      case UCAL_AM_PM:
        index = kIPI_AM_PM;
        break;
      case UCAL_HOUR:
      case UCAL_HOUR_OF_DAY:
        index = kIPI_HOUR;
        break;
      case UCAL_MINUTE:
        index = kIPI_MINUTE;
        break;
      default:
        status = U_ILLEGAL_ARGUMENT_ERROR;
    }
    return index;
}


void
DateIntervalInfo::deleteHash(Hashtable* hTable) 
{
    if ( hTable == NULL ) {
        return;
    }
    int32_t pos = -1;
    const UHashElement* element = NULL;
    while ( (element = hTable->nextElement(pos)) != NULL ) {
        const UHashTok keyTok = element->key;
        const UHashTok valueTok = element->value;
        const UnicodeString* value = (UnicodeString*)valueTok.pointer;
        delete[] value;
    }
    delete fIntervalPatterns;
}


U_CDECL_BEGIN 

/**
 * set hash table value comparator
 *
 * @param val1  one value in comparison
 * @param val2  the other value in comparison
 * @return      TRUE if 2 values are the same, FALSE otherwise
 */
static UBool U_CALLCONV hashTableValueComparator(UHashTok val1, UHashTok val2);

U_CDECL_END

UBool 
U_CALLCONV hashTableValueComparator(UHashTok val1, UHashTok val2) {
    const UnicodeString* pattern1 = (UnicodeString*)val1.pointer;
    const UnicodeString* pattern2 = (UnicodeString*)val2.pointer;
    UBool ret = TRUE;
    int8_t i;
    for ( i = 0; i < DateIntervalInfo::kIPI_MAX_INDEX && ret == TRUE; ++i ) {
        ret = (pattern1[i] == pattern2[i]);
    }
    return ret;
}


Hashtable*
DateIntervalInfo::initHash(UErrorCode& status) {
    if ( U_FAILURE(status) ) {
        return NULL;
    }
    Hashtable* hTable;
    if ( (hTable = new Hashtable(TRUE, status)) == NULL ) {
        status = U_MEMORY_ALLOCATION_ERROR;
        return NULL;
    }
    hTable->setValueCompartor(hashTableValueComparator);
    return hTable;
}


void
DateIntervalInfo::copyHash(const Hashtable* source,
                           Hashtable* target,
                           UErrorCode& status) {
    if ( U_FAILURE(status) ) {
        return;
    }
    int32_t pos = -1;
    const UHashElement* element = NULL;
    if ( source ) {
        while ( (element = source->nextElement(pos)) != NULL ) {
            const UHashTok keyTok = element->key;
            const UnicodeString* key = (UnicodeString*)keyTok.pointer;
            const UHashTok valueTok = element->value;
            const UnicodeString* value = (UnicodeString*)valueTok.pointer;
            UnicodeString* copy = new UnicodeString[kIPI_MAX_INDEX];
            int8_t i;
            for ( i = 0; i < kIPI_MAX_INDEX; ++i ) {
                copy[i] = value[i];
            }
            target->put(UnicodeString(*key), copy, status);
            if ( U_FAILURE(status) ) {
                return;
            }
        }
    }
}


U_NAMESPACE_END

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