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

/*
 *******************************************************************************
 * Copyright (C) 2009-2014, International Business Machines Corporation and
 * others. All Rights Reserved.
 *******************************************************************************
 */

#include "unicode/currpinf.h"

#if !UCONFIG_NO_FORMATTING

//#define CURRENCY_PLURAL_INFO_DEBUG 1

#ifdef CURRENCY_PLURAL_INFO_DEBUG
#include <iostream>
#endif


#include "unicode/locid.h"
#include "unicode/plurrule.h"
#include "unicode/ures.h"
#include "unicode/numsys.h"
#include "cstring.h"
#include "hash.h"
#include "uresimp.h"
#include "ureslocs.h"

U_NAMESPACE_BEGIN


static const UChar gNumberPatternSeparator = 0x3B; // ;

U_CDECL_BEGIN

/**
 * @internal ICU 4.2
 */
static UBool U_CALLCONV ValueComparator(UHashTok val1, UHashTok val2);

UBool
U_CALLCONV ValueComparator(UHashTok val1, UHashTok val2) {
    const UnicodeString* affix_1 = (UnicodeString*)val1.pointer;
    const UnicodeString* affix_2 = (UnicodeString*)val2.pointer;
    return  *affix_1 == *affix_2;
}

U_CDECL_END


UOBJECT_DEFINE_RTTI_IMPLEMENTATION(CurrencyPluralInfo)

static const UChar gDefaultCurrencyPluralPattern[] = {'0', '.', '#', '#', ' ', 0xA4, 0xA4, 0xA4, 0};
static const UChar gTripleCurrencySign[] = {0xA4, 0xA4, 0xA4, 0};
static const UChar gPluralCountOther[] = {0x6F, 0x74, 0x68, 0x65, 0x72, 0};
static const UChar gPart0[] = {0x7B, 0x30, 0x7D, 0};
static const UChar gPart1[] = {0x7B, 0x31, 0x7D, 0};

static const char gNumberElementsTag[]="NumberElements";
static const char gLatnTag[]="latn";
static const char gPatternsTag[]="patterns";
static const char gDecimalFormatTag[]="decimalFormat";
static const char gCurrUnitPtnTag[]="CurrencyUnitPatterns";

CurrencyPluralInfo::CurrencyPluralInfo(UErrorCode& status)
:   fPluralCountToCurrencyUnitPattern(NULL),
    fPluralRules(NULL),
    fLocale(NULL) {
    initialize(Locale::getDefault(), status);
}

CurrencyPluralInfo::CurrencyPluralInfo(const Locale& locale, UErrorCode& status)
:   fPluralCountToCurrencyUnitPattern(NULL),
    fPluralRules(NULL),
    fLocale(NULL) {
    initialize(locale, status);
}

CurrencyPluralInfo::CurrencyPluralInfo(const CurrencyPluralInfo& info) 
:   UObject(info),
    fPluralCountToCurrencyUnitPattern(NULL),
    fPluralRules(NULL),
    fLocale(NULL) {
    *this = info;
}


CurrencyPluralInfo&
CurrencyPluralInfo::operator=(const CurrencyPluralInfo& info) {
    if (this == &info) {
        return *this;
    }

    deleteHash(fPluralCountToCurrencyUnitPattern);
    UErrorCode status = U_ZERO_ERROR;
    fPluralCountToCurrencyUnitPattern = initHash(status);
    copyHash(info.fPluralCountToCurrencyUnitPattern, 
             fPluralCountToCurrencyUnitPattern, status);
    if ( U_FAILURE(status) ) {
        return *this;
    }

    delete fPluralRules;
    delete fLocale;
    if (info.fPluralRules) {
        fPluralRules = info.fPluralRules->clone();
    } else {
        fPluralRules = NULL;
    }
    if (info.fLocale) {
        fLocale = info.fLocale->clone();
    } else {
        fLocale = NULL;
    }
    return *this;
}


CurrencyPluralInfo::~CurrencyPluralInfo() {
    deleteHash(fPluralCountToCurrencyUnitPattern);
    fPluralCountToCurrencyUnitPattern = NULL;
    delete fPluralRules;
    delete fLocale;
    fPluralRules = NULL;
    fLocale = NULL;
}

UBool
CurrencyPluralInfo::operator==(const CurrencyPluralInfo& info) const {
#ifdef CURRENCY_PLURAL_INFO_DEBUG
    if (*fPluralRules == *info.fPluralRules) {
        std::cout << "same plural rules\n";
    }
    if (*fLocale == *info.fLocale) {
        std::cout << "same locale\n";
    }
    if (fPluralCountToCurrencyUnitPattern->equals(*info.fPluralCountToCurrencyUnitPattern)) {
        std::cout << "same pattern\n";
    }
#endif
    return *fPluralRules == *info.fPluralRules &&
           *fLocale == *info.fLocale &&
           fPluralCountToCurrencyUnitPattern->equals(*info.fPluralCountToCurrencyUnitPattern);
}


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

const PluralRules* 
CurrencyPluralInfo::getPluralRules() const {
    return fPluralRules;
}

UnicodeString&
CurrencyPluralInfo::getCurrencyPluralPattern(const UnicodeString&  pluralCount,
                                             UnicodeString& result) const {
    const UnicodeString* currencyPluralPattern = 
        (UnicodeString*)fPluralCountToCurrencyUnitPattern->get(pluralCount);
    if (currencyPluralPattern == NULL) {
        // fall back to "other"
        if (pluralCount.compare(gPluralCountOther, 5)) {
            currencyPluralPattern = 
                (UnicodeString*)fPluralCountToCurrencyUnitPattern->get(UnicodeString(TRUE, gPluralCountOther, 5));
        }
        if (currencyPluralPattern == NULL) {
            // no currencyUnitPatterns defined, 
            // fallback to predefined defult.
            // This should never happen when ICU resource files are
            // available, since currencyUnitPattern of "other" is always
            // defined in root.
            result = UnicodeString(gDefaultCurrencyPluralPattern);
            return result;
        }
    }
    result = *currencyPluralPattern;
    return result;
}

const Locale&
CurrencyPluralInfo::getLocale() const {
    return *fLocale;
}

void
CurrencyPluralInfo::setPluralRules(const UnicodeString& ruleDescription,
                                   UErrorCode& status) {
    if (U_SUCCESS(status)) {
        if (fPluralRules) {
            delete fPluralRules;
        }
        fPluralRules = PluralRules::createRules(ruleDescription, status);
    }
}


void
CurrencyPluralInfo::setCurrencyPluralPattern(const UnicodeString& pluralCount,
                                             const UnicodeString& pattern,
                                             UErrorCode& status) {
    if (U_SUCCESS(status)) {
        fPluralCountToCurrencyUnitPattern->put(pluralCount, new UnicodeString(pattern), status);
    }
}


void
CurrencyPluralInfo::setLocale(const Locale& loc, UErrorCode& status) {
    initialize(loc, status);
}


void 
CurrencyPluralInfo::initialize(const Locale& loc, UErrorCode& status) {
    if (U_FAILURE(status)) {
        return;
    }
    delete fLocale;
    fLocale = loc.clone();
    if (fPluralRules) {
        delete fPluralRules;
    }
    fPluralRules = PluralRules::forLocale(loc, status);
    setupCurrencyPluralPattern(loc, status);
}

   
void
CurrencyPluralInfo::setupCurrencyPluralPattern(const Locale& loc, UErrorCode& status) {
    if (U_FAILURE(status)) {
        return;
    }

    if (fPluralCountToCurrencyUnitPattern) {
        deleteHash(fPluralCountToCurrencyUnitPattern);
    }
    fPluralCountToCurrencyUnitPattern = initHash(status);
    if (U_FAILURE(status)) {
        return;
    }

    NumberingSystem *ns = NumberingSystem::createInstance(loc,status);
    UErrorCode ec = U_ZERO_ERROR;
    UResourceBundle *rb = ures_open(NULL, loc.getName(), &ec);
    UResourceBundle *numElements = ures_getByKeyWithFallback(rb, gNumberElementsTag, NULL, &ec);
    rb = ures_getByKeyWithFallback(numElements, ns->getName(), rb, &ec);
    rb = ures_getByKeyWithFallback(rb, gPatternsTag, rb, &ec);
    int32_t ptnLen;
    const UChar* numberStylePattern = ures_getStringByKeyWithFallback(rb, gDecimalFormatTag, &ptnLen, &ec);
    // Fall back to "latn" if num sys specific pattern isn't there.
    if ( ec == U_MISSING_RESOURCE_ERROR && uprv_strcmp(ns->getName(),gLatnTag)) {
        ec = U_ZERO_ERROR;
        rb = ures_getByKeyWithFallback(numElements, gLatnTag, rb, &ec);
        rb = ures_getByKeyWithFallback(rb, gPatternsTag, rb, &ec);
        numberStylePattern = ures_getStringByKeyWithFallback(rb, gDecimalFormatTag, &ptnLen, &ec);
    }
    int32_t numberStylePatternLen = ptnLen;
    const UChar* negNumberStylePattern = NULL;
    int32_t negNumberStylePatternLen = 0;
    // TODO: Java
    // parse to check whether there is ";" separator in the numberStylePattern
    UBool hasSeparator = false;
    if (U_SUCCESS(ec)) {
        for (int32_t styleCharIndex = 0; styleCharIndex < ptnLen; ++styleCharIndex) {
            if (numberStylePattern[styleCharIndex] == gNumberPatternSeparator) {
                hasSeparator = true;
                // split the number style pattern into positive and negative
                negNumberStylePattern = numberStylePattern + styleCharIndex + 1;
                negNumberStylePatternLen = ptnLen - styleCharIndex - 1;
                numberStylePatternLen = styleCharIndex;
            }
        }
    }

    ures_close(numElements);
    ures_close(rb);
    delete ns;

    if (U_FAILURE(ec)) {
        return;
    }

    UResourceBundle *currRb = ures_open(U_ICUDATA_CURR, loc.getName(), &ec);
    UResourceBundle *currencyRes = ures_getByKeyWithFallback(currRb, gCurrUnitPtnTag, NULL, &ec);
    
#ifdef CURRENCY_PLURAL_INFO_DEBUG
    std::cout << "in set up\n";
#endif
    StringEnumeration* keywords = fPluralRules->getKeywords(ec);
    if (U_SUCCESS(ec)) {
        const char* pluralCount;
        while ((pluralCount = keywords->next(NULL, ec)) != NULL) {
            if ( U_SUCCESS(ec) ) {
                int32_t ptnLen;
                UErrorCode err = U_ZERO_ERROR;
                const UChar* patternChars = ures_getStringByKeyWithFallback(
                    currencyRes, pluralCount, &ptnLen, &err);
                if (U_SUCCESS(err) && ptnLen > 0) {
                    UnicodeString* pattern = new UnicodeString(patternChars, ptnLen);
#ifdef CURRENCY_PLURAL_INFO_DEBUG
                    char result_1[1000];
                    pattern->extract(0, pattern->length(), result_1, "UTF-8");
                    std::cout << "pluralCount: " << pluralCount << "; pattern: " << result_1 << "\n";
#endif
                    pattern->findAndReplace(UnicodeString(TRUE, gPart0, 3), 
                      UnicodeString(numberStylePattern, numberStylePatternLen));
                    pattern->findAndReplace(UnicodeString(TRUE, gPart1, 3), UnicodeString(TRUE, gTripleCurrencySign, 3));

                    if (hasSeparator) {
                        UnicodeString negPattern(patternChars, ptnLen);
                        negPattern.findAndReplace(UnicodeString(TRUE, gPart0, 3), 
                          UnicodeString(negNumberStylePattern, negNumberStylePatternLen));
                        negPattern.findAndReplace(UnicodeString(TRUE, gPart1, 3), UnicodeString(TRUE, gTripleCurrencySign, 3));
                        pattern->append(gNumberPatternSeparator);
                        pattern->append(negPattern);
                    }
#ifdef CURRENCY_PLURAL_INFO_DEBUG
                    pattern->extract(0, pattern->length(), result_1, "UTF-8");
                    std::cout << "pluralCount: " << pluralCount << "; pattern: " << result_1 << "\n";
#endif

                    fPluralCountToCurrencyUnitPattern->put(UnicodeString(pluralCount, -1, US_INV), pattern, status);
                }
            }
        }
    }
    delete keywords;
    ures_close(currencyRes);
    ures_close(currRb);
}


void
CurrencyPluralInfo::deleteHash(Hashtable* hTable) 
{
    if ( hTable == NULL ) {
        return;
    }
    int32_t pos = UHASH_FIRST;
    const UHashElement* element = NULL;
    while ( (element = hTable->nextElement(pos)) != NULL ) {
        const UHashTok valueTok = element->value;
        const UnicodeString* value = (UnicodeString*)valueTok.pointer;
        delete value;
    }
    delete hTable;
    hTable = NULL;
}


Hashtable*
CurrencyPluralInfo::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;
    }
    if ( U_FAILURE(status) ) {
        delete hTable; 
        return NULL;
    }
    hTable->setValueComparator(ValueComparator);
    return hTable;
}


void
CurrencyPluralInfo::copyHash(const Hashtable* source,
                           Hashtable* target,
                           UErrorCode& status) {
    if ( U_FAILURE(status) ) {
        return;
    }
    int32_t pos = UHASH_FIRST;
    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(*value);
            target->put(UnicodeString(*key), copy, status);
            if ( U_FAILURE(status) ) {
                return;
            }
        }
    }
}


U_NAMESPACE_END

#endif
Commit	Line	Data
729e4ab9 A	1	/*
729e4ab9 A	2	*******************************************************************************
b331163b	3	* Copyright (C) 2009-2014, International Business Machines Corporation and
729e4ab9 A	4	* others. All Rights Reserved.
	5	*******************************************************************************
	6	*/
	7
	8	#include "unicode/currpinf.h"
	9
	10	#if !UCONFIG_NO_FORMATTING
	11
	12	//#define CURRENCY_PLURAL_INFO_DEBUG 1
	13
	14	#ifdef CURRENCY_PLURAL_INFO_DEBUG
	15	#include <iostream>
	16	#endif
	17
	18
	19	#include "unicode/locid.h"
	20	#include "unicode/plurrule.h"
	21	#include "unicode/ures.h"
4388f060	22	#include "unicode/numsys.h"
729e4ab9 A	23	#include "cstring.h"
	24	#include "hash.h"
	25	#include "uresimp.h"
	26	#include "ureslocs.h"
	27
	28	U_NAMESPACE_BEGIN
	29
	30
	31	static const UChar gNumberPatternSeparator = 0x3B; // ;
	32
	33	U_CDECL_BEGIN
	34
	35	/**
	36	* @internal ICU 4.2
	37	*/
	38	static UBool U_CALLCONV ValueComparator(UHashTok val1, UHashTok val2);
	39
	40	UBool
	41	U_CALLCONV ValueComparator(UHashTok val1, UHashTok val2) {
	42	const UnicodeString* affix_1 = (UnicodeString*)val1.pointer;
	43	const UnicodeString* affix_2 = (UnicodeString*)val2.pointer;
	44	return affix_1 == affix_2;
	45	}
	46
	47	U_CDECL_END
	48
	49
	50	UOBJECT_DEFINE_RTTI_IMPLEMENTATION(CurrencyPluralInfo)
	51
	52	static const UChar gDefaultCurrencyPluralPattern[] = {'0', '.', '#', '#', ' ', 0xA4, 0xA4, 0xA4, 0};
	53	static const UChar gTripleCurrencySign[] = {0xA4, 0xA4, 0xA4, 0};
	54	static const UChar gPluralCountOther[] = {0x6F, 0x74, 0x68, 0x65, 0x72, 0};
	55	static const UChar gPart0[] = {0x7B, 0x30, 0x7D, 0};
	56	static const UChar gPart1[] = {0x7B, 0x31, 0x7D, 0};
	57
	58	static const char gNumberElementsTag[]="NumberElements";
	59	static const char gLatnTag[]="latn";
	60	static const char gPatternsTag[]="patterns";
	61	static const char gDecimalFormatTag[]="decimalFormat";
	62	static const char gCurrUnitPtnTag[]="CurrencyUnitPatterns";
	63
	64	CurrencyPluralInfo::CurrencyPluralInfo(UErrorCode& status)
	65	: fPluralCountToCurrencyUnitPattern(NULL),
	66	fPluralRules(NULL),
	67	fLocale(NULL) {
	68	initialize(Locale::getDefault(), status);
	69	}
	70
	71	CurrencyPluralInfo::CurrencyPluralInfo(const Locale& locale, UErrorCode& status)
	72	: fPluralCountToCurrencyUnitPattern(NULL),
	73	fPluralRules(NULL),
	74	fLocale(NULL) {
	75	initialize(locale, status);
	76	}
	77
	78	CurrencyPluralInfo::CurrencyPluralInfo(const CurrencyPluralInfo& info)
	79	: UObject(info),
	80	fPluralCountToCurrencyUnitPattern(NULL),
	81	fPluralRules(NULL),
	82	fLocale(NULL) {
	83	*this = info;
	84	}
	85
	86
87	CurrencyPluralInfo&
88	CurrencyPluralInfo::operator=(const CurrencyPluralInfo& info) {
89	if (this == &info) {
90	return *this;
91	}
92
93	deleteHash(fPluralCountToCurrencyUnitPattern);
94	UErrorCode status = U_ZERO_ERROR;
95	fPluralCountToCurrencyUnitPattern = initHash(status);
96	copyHash(info.fPluralCountToCurrencyUnitPattern,
97	fPluralCountToCurrencyUnitPattern, status);
98	if ( U_FAILURE(status) ) {
99	return *this;
100	}
101
102	delete fPluralRules;
103	delete fLocale;
104	if (info.fPluralRules) {
105	fPluralRules = info.fPluralRules->clone();
106	} else {
107	fPluralRules = NULL;
108	}
109	if (info.fLocale) {
110	fLocale = info.fLocale->clone();
111	} else {
112	fLocale = NULL;
113	}
114	return *this;
115	}
116
117
118	CurrencyPluralInfo::~CurrencyPluralInfo() {
119	deleteHash(fPluralCountToCurrencyUnitPattern);
120	fPluralCountToCurrencyUnitPattern = NULL;
121	delete fPluralRules;
122	delete fLocale;
123	fPluralRules = NULL;
124	fLocale = NULL;
125	}
126
127	UBool
128	CurrencyPluralInfo::operator==(const CurrencyPluralInfo& info) const {
129	#ifdef CURRENCY_PLURAL_INFO_DEBUG
130	if (fPluralRules == info.fPluralRules) {
131	std::cout << "same plural rules\n";
132	}
133	if (fLocale == info.fLocale) {
134	std::cout << "same locale\n";
135	}
136	if (fPluralCountToCurrencyUnitPattern->equals(*info.fPluralCountToCurrencyUnitPattern)) {
137	std::cout << "same pattern\n";
138	}
139	#endif
140	return fPluralRules == info.fPluralRules &&
141	fLocale == info.fLocale &&
142	fPluralCountToCurrencyUnitPattern->equals(*info.fPluralCountToCurrencyUnitPattern);
143	}
144
145
146	CurrencyPluralInfo*
147	CurrencyPluralInfo::clone() const {
148	return new CurrencyPluralInfo(*this);
149	}
150
151	const PluralRules*
152	CurrencyPluralInfo::getPluralRules() const {
153	return fPluralRules;
154	}
155
156	UnicodeString&
157	CurrencyPluralInfo::getCurrencyPluralPattern(const UnicodeString& pluralCount,
158	UnicodeString& result) const {
159	const UnicodeString* currencyPluralPattern =
160	(UnicodeString*)fPluralCountToCurrencyUnitPattern->get(pluralCount);
161	if (currencyPluralPattern == NULL) {
162	// fall back to "other"
4388f060	163	if (pluralCount.compare(gPluralCountOther, 5)) {
729e4ab9	164	currencyPluralPattern =
4388f060	165	(UnicodeString*)fPluralCountToCurrencyUnitPattern->get(UnicodeString(TRUE, gPluralCountOther, 5));
729e4ab9 A	166	}
	167	if (currencyPluralPattern == NULL) {
	168	// no currencyUnitPatterns defined,
	169	// fallback to predefined defult.
	170	// This should never happen when ICU resource files are
	171	// available, since currencyUnitPattern of "other" is always
	172	// defined in root.
	173	result = UnicodeString(gDefaultCurrencyPluralPattern);
	174	return result;
	175	}
	176	}
	177	result = *currencyPluralPattern;
	178	return result;
	179	}
	180
	181	const Locale&
	182	CurrencyPluralInfo::getLocale() const {
	183	return *fLocale;
	184	}
	185
	186	void
	187	CurrencyPluralInfo::setPluralRules(const UnicodeString& ruleDescription,
	188	UErrorCode& status) {
	189	if (U_SUCCESS(status)) {
	190	if (fPluralRules) {
	191	delete fPluralRules;
	192	}
	193	fPluralRules = PluralRules::createRules(ruleDescription, status);
	194	}
	195	}
	196
	197
	198	void
	199	CurrencyPluralInfo::setCurrencyPluralPattern(const UnicodeString& pluralCount,
	200	const UnicodeString& pattern,
	201	UErrorCode& status) {
	202	if (U_SUCCESS(status)) {
	203	fPluralCountToCurrencyUnitPattern->put(pluralCount, new UnicodeString(pattern), status);
	204	}
	205	}
	206
	207
	208	void
	209	CurrencyPluralInfo::setLocale(const Locale& loc, UErrorCode& status) {
	210	initialize(loc, status);
	211	}
	212
	213
	214	void
	215	CurrencyPluralInfo::initialize(const Locale& loc, UErrorCode& status) {
	216	if (U_FAILURE(status)) {
	217	return;
	218	}
	219	delete fLocale;
	220	fLocale = loc.clone();
	221	if (fPluralRules) {
	222	delete fPluralRules;
	223	}
	224	fPluralRules = PluralRules::forLocale(loc, status);
	225	setupCurrencyPluralPattern(loc, status);
	226	}
	227
	228
	229	void
230	CurrencyPluralInfo::setupCurrencyPluralPattern(const Locale& loc, UErrorCode& status) {
231	if (U_FAILURE(status)) {
232	return;
233	}
234
235	if (fPluralCountToCurrencyUnitPattern) {
236	deleteHash(fPluralCountToCurrencyUnitPattern);
237	}
238	fPluralCountToCurrencyUnitPattern = initHash(status);
239	if (U_FAILURE(status)) {
240	return;
241	}
242
4388f060	243	NumberingSystem *ns = NumberingSystem::createInstance(loc,status);
729e4ab9 A	244	UErrorCode ec = U_ZERO_ERROR;
729e4ab9 A	245	UResourceBundle *rb = ures_open(NULL, loc.getName(), &ec);
4388f060 A	246	UResourceBundle *numElements = ures_getByKeyWithFallback(rb, gNumberElementsTag, NULL, &ec);
	247	rb = ures_getByKeyWithFallback(numElements, ns->getName(), rb, &ec);
	248	rb = ures_getByKeyWithFallback(rb, gPatternsTag, rb, &ec);
729e4ab9 A	249	int32_t ptnLen;
729e4ab9 A	250	const UChar* numberStylePattern = ures_getStringByKeyWithFallback(rb, gDecimalFormatTag, &ptnLen, &ec);
4388f060 A	251	// Fall back to "latn" if num sys specific pattern isn't there.
	252	if ( ec == U_MISSING_RESOURCE_ERROR && uprv_strcmp(ns->getName(),gLatnTag)) {
	253	ec = U_ZERO_ERROR;
	254	rb = ures_getByKeyWithFallback(numElements, gLatnTag, rb, &ec);
	255	rb = ures_getByKeyWithFallback(rb, gPatternsTag, rb, &ec);
	256	numberStylePattern = ures_getStringByKeyWithFallback(rb, gDecimalFormatTag, &ptnLen, &ec);
	257	}
729e4ab9 A	258	int32_t numberStylePatternLen = ptnLen;
	259	const UChar* negNumberStylePattern = NULL;
	260	int32_t negNumberStylePatternLen = 0;
	261	// TODO: Java
	262	// parse to check whether there is ";" separator in the numberStylePattern
	263	UBool hasSeparator = false;
	264	if (U_SUCCESS(ec)) {
	265	for (int32_t styleCharIndex = 0; styleCharIndex < ptnLen; ++styleCharIndex) {
	266	if (numberStylePattern[styleCharIndex] == gNumberPatternSeparator) {
	267	hasSeparator = true;
	268	// split the number style pattern into positive and negative
	269	negNumberStylePattern = numberStylePattern + styleCharIndex + 1;
	270	negNumberStylePatternLen = ptnLen - styleCharIndex - 1;
	271	numberStylePatternLen = styleCharIndex;
	272	}
	273	}
	274	}
4388f060 A	275
4388f060 A	276	ures_close(numElements);
729e4ab9	277	ures_close(rb);
4388f060	278	delete ns;
729e4ab9 A	279
	280	if (U_FAILURE(ec)) {
	281	return;
	282	}
	283
	284	UResourceBundle *currRb = ures_open(U_ICUDATA_CURR, loc.getName(), &ec);
	285	UResourceBundle *currencyRes = ures_getByKeyWithFallback(currRb, gCurrUnitPtnTag, NULL, &ec);
	286
	287	#ifdef CURRENCY_PLURAL_INFO_DEBUG
	288	std::cout << "in set up\n";
	289	#endif
	290	StringEnumeration* keywords = fPluralRules->getKeywords(ec);
	291	if (U_SUCCESS(ec)) {
	292	const char* pluralCount;
	293	while ((pluralCount = keywords->next(NULL, ec)) != NULL) {
	294	if ( U_SUCCESS(ec) ) {
	295	int32_t ptnLen;
	296	UErrorCode err = U_ZERO_ERROR;
	297	const UChar* patternChars = ures_getStringByKeyWithFallback(
	298	currencyRes, pluralCount, &ptnLen, &err);
	299	if (U_SUCCESS(err) && ptnLen > 0) {
	300	UnicodeString* pattern = new UnicodeString(patternChars, ptnLen);
	301	#ifdef CURRENCY_PLURAL_INFO_DEBUG
	302	char result_1[1000];
	303	pattern->extract(0, pattern->length(), result_1, "UTF-8");
	304	std::cout << "pluralCount: " << pluralCount << "; pattern: " << result_1 << "\n";
	305	#endif
4388f060	306	pattern->findAndReplace(UnicodeString(TRUE, gPart0, 3),
729e4ab9	307	UnicodeString(numberStylePattern, numberStylePatternLen));
4388f060	308	pattern->findAndReplace(UnicodeString(TRUE, gPart1, 3), UnicodeString(TRUE, gTripleCurrencySign, 3));
729e4ab9 A	309
	310	if (hasSeparator) {
	311	UnicodeString negPattern(patternChars, ptnLen);
4388f060	312	negPattern.findAndReplace(UnicodeString(TRUE, gPart0, 3),
729e4ab9	313	UnicodeString(negNumberStylePattern, negNumberStylePatternLen));
4388f060	314	negPattern.findAndReplace(UnicodeString(TRUE, gPart1, 3), UnicodeString(TRUE, gTripleCurrencySign, 3));
729e4ab9 A	315	pattern->append(gNumberPatternSeparator);
	316	pattern->append(negPattern);
	317	}
	318	#ifdef CURRENCY_PLURAL_INFO_DEBUG
	319	pattern->extract(0, pattern->length(), result_1, "UTF-8");
	320	std::cout << "pluralCount: " << pluralCount << "; pattern: " << result_1 << "\n";
	321	#endif
	322
4388f060	323	fPluralCountToCurrencyUnitPattern->put(UnicodeString(pluralCount, -1, US_INV), pattern, status);
729e4ab9 A	324	}
	325	}
	326	}
	327	}
	328	delete keywords;
	329	ures_close(currencyRes);
	330	ures_close(currRb);
	331	}
	332
	333
	334
	335	void
	336	CurrencyPluralInfo::deleteHash(Hashtable* hTable)
	337	{
	338	if ( hTable == NULL ) {
	339	return;
	340	}
b331163b	341	int32_t pos = UHASH_FIRST;
729e4ab9 A	342	const UHashElement* element = NULL;
729e4ab9 A	343	while ( (element = hTable->nextElement(pos)) != NULL ) {
729e4ab9 A	344	const UHashTok valueTok = element->value;
	345	const UnicodeString* value = (UnicodeString*)valueTok.pointer;
	346	delete value;
	347	}
	348	delete hTable;
	349	hTable = NULL;
	350	}
	351
	352
	353	Hashtable*
	354	CurrencyPluralInfo::initHash(UErrorCode& status) {
	355	if ( U_FAILURE(status) ) {
	356	return NULL;
	357	}
	358	Hashtable* hTable;
	359	if ( (hTable = new Hashtable(TRUE, status)) == NULL ) {
	360	status = U_MEMORY_ALLOCATION_ERROR;
	361	return NULL;
	362	}
	363	if ( U_FAILURE(status) ) {
	364	delete hTable;
	365	return NULL;
	366	}
	367	hTable->setValueComparator(ValueComparator);
	368	return hTable;
	369	}
	370
	371
	372	void
	373	CurrencyPluralInfo::copyHash(const Hashtable* source,
	374	Hashtable* target,
	375	UErrorCode& status) {
	376	if ( U_FAILURE(status) ) {
	377	return;
	378	}
b331163b	379	int32_t pos = UHASH_FIRST;
729e4ab9 A	380	const UHashElement* element = NULL;
	381	if ( source ) {
	382	while ( (element = source->nextElement(pos)) != NULL ) {
	383	const UHashTok keyTok = element->key;
	384	const UnicodeString* key = (UnicodeString*)keyTok.pointer;
	385	const UHashTok valueTok = element->value;
	386	const UnicodeString* value = (UnicodeString*)valueTok.pointer;
	387	UnicodeString* copy = new UnicodeString(*value);
	388	target->put(UnicodeString(*key), copy, status);
	389	if ( U_FAILURE(status) ) {
	390	return;
	391	}
	392	}
	393	}
	394	}
	395
	396
	397	U_NAMESPACE_END
	398
	399	#endif