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

/********************************************************************
 * COPYRIGHT:
 * Copyright (c) 1997-2010, International Business Machines Corporation and
 * others. All Rights Reserved.
 * Copyright (C) 2010 , Yahoo! Inc.
 ********************************************************************
 *
 * File SELFMT.CPP
 *
 * Modification History:
 *
 *   Date        Name        Description
 *   11/11/09    kirtig      Finished first cut of implementation.
 *   11/16/09    kirtig      Improved version
 ********************************************************************/

#include <typeinfo>  // for 'typeid' to work

#include "unicode/utypes.h"
#include "unicode/ustring.h"
#include "unicode/ucnv_err.h"
#include "unicode/uchar.h"
#include "unicode/umsg.h"
#include "unicode/rbnf.h"
#include "cmemory.h"
#include "util.h"
#include "uassert.h"
#include "ustrfmt.h"
#include "uvector.h"

#include "unicode/selfmt.h"
#include "selfmtimpl.h"

#if !UCONFIG_NO_FORMATTING

U_NAMESPACE_BEGIN

UOBJECT_DEFINE_RTTI_IMPLEMENTATION(SelectFormat)

#define MAX_KEYWORD_SIZE 30
static const UChar SELECT_KEYWORD_OTHER[] = {LOW_O, LOW_T, LOW_H, LOW_E, LOW_R, 0};

SelectFormat::SelectFormat(const UnicodeString& pat, UErrorCode& status) : parsedValuesHash(NULL) {
   if (U_FAILURE(status)) {
      return;
   }
   initHashTable(status);
   applyPattern(pat, status);
}

SelectFormat::SelectFormat(const SelectFormat& other) : Format(other), parsedValuesHash(NULL) {
   UErrorCode status = U_ZERO_ERROR;
   pattern = other.pattern;
   copyHashtable(other.parsedValuesHash, status);
}

SelectFormat::~SelectFormat() {
  cleanHashTable();
}

void SelectFormat::initHashTable(UErrorCode &status) {
  if (U_FAILURE(status)) {
    return;
  }
  // has inited
  if (parsedValuesHash != NULL) {
    return;
  }

  parsedValuesHash = new Hashtable(TRUE, status);
  if (U_FAILURE(status)) {
    cleanHashTable();
    return;
  } else {
    if (parsedValuesHash == NULL) {
      status = U_MEMORY_ALLOCATION_ERROR;
      return;
    }
  }
  // to use hashtable->equals(), must set Value Compartor.
  parsedValuesHash->setValueComparator(uhash_compareCaselessUnicodeString);
}

void SelectFormat::cleanHashTable() {
  if (parsedValuesHash != NULL) {
    delete parsedValuesHash;
    parsedValuesHash = NULL;
  }
}

void
SelectFormat::applyPattern(const UnicodeString& newPattern, UErrorCode& status) {
    if (U_FAILURE(status)) {
      return;
    }

    pattern = newPattern;
    enum State{ startState, keywordState, pastKeywordState, phraseState};

    //Initialization
    UnicodeString keyword ;
    UnicodeString phrase ;
    UnicodeString* ptrPhrase ;
    int32_t braceCount = 0;

    if (parsedValuesHash == NULL) {
      initHashTable(status);
      if (U_FAILURE(status)) {
        return;
      }
    }
    parsedValuesHash->removeAll();
    parsedValuesHash->setValueDeleter(uhash_deleteUnicodeString);

    //Process the state machine
    State state = startState;
    for (int32_t i = 0; i < pattern.length(); ++i) {
        //Get the character and check its type
        UChar ch = pattern.charAt(i);
        CharacterClass type = classifyCharacter(ch);

        //Allow any character in phrase but nowhere else
        if ( type == tOther ) {
            if ( state == phraseState ){
                phrase += ch;
                continue;
            }else {
                status = U_PATTERN_SYNTAX_ERROR;
                cleanHashTable();
                return;
            }
        }

        //Process the state machine
        switch (state) {
            //At the start of pattern
            case startState:
                switch (type) {
                    case tSpace:
                        break;
                    case tStartKeyword:
                        state = keywordState;
                        keyword += ch;
                        break;
                    //If anything else is encountered, it's a syntax error
                    default:
                        status = U_PATTERN_SYNTAX_ERROR;
                        cleanHashTable();
                        return;
                }//end of switch(type)
                break;

            //Handle the keyword state
            case keywordState:
                switch (type) {
                    case tSpace:
                        state = pastKeywordState;
                        break;
                    case tStartKeyword:
                    case tContinueKeyword:
                        keyword += ch;
                        break;
                    case tLeftBrace:
                        state = phraseState;
                        break;
                    //If anything else is encountered, it's a syntax error
                    default:
                        status = U_PATTERN_SYNTAX_ERROR;
                        cleanHashTable();
                        return;
                }//end of switch(type)
                break;

            //Handle the pastkeyword state
            case pastKeywordState:
                switch (type) {
                    case tSpace:
                        break;
                    case tLeftBrace:
                        state = phraseState;
                        break;
                    //If anything else is encountered, it's a syntax error
                    default:
                        status = U_PATTERN_SYNTAX_ERROR;
                        cleanHashTable();
                        return;
                }//end of switch(type)
                break;

            //Handle the phrase state
            case phraseState:
                switch (type) {
                    case tLeftBrace:
                        braceCount++;
                        phrase += ch;
                        break;
                    case tRightBrace:
                        //Matching keyword, phrase pair found
                        if (braceCount == 0){
                            //Check validity of keyword
                            if (parsedValuesHash->get(keyword) != NULL) {
                                status = U_DUPLICATE_KEYWORD;
                                cleanHashTable();
                                return;
                            }
                            if (keyword.length() == 0) {
                                status = U_PATTERN_SYNTAX_ERROR;
                                cleanHashTable();
                                return;
                            }

                            //Store the keyword, phrase pair in hashTable
                            ptrPhrase = new UnicodeString(phrase);
                            parsedValuesHash->put( keyword, ptrPhrase, status);

                            //Reinitialize
                            keyword.remove();
                            phrase.remove();
                            ptrPhrase = NULL;
                            state = startState;
                        }

                        if (braceCount > 0){
                            braceCount-- ;
                            phrase += ch;
                        }
                        break;
                    default:
                        phrase += ch;
                }//end of switch(type)
                break;

            //Handle the  default case of switch(state)
            default:
                status = U_PATTERN_SYNTAX_ERROR;
                cleanHashTable();
                return;

        }//end of switch(state)
    }

    //Check if the state machine is back to startState
    if ( state != startState){
        status = U_PATTERN_SYNTAX_ERROR;
        cleanHashTable();
        return;
    }

    //Check if "other" keyword is present
    if ( !checkSufficientDefinition() ) {
        status = U_DEFAULT_KEYWORD_MISSING;
        cleanHashTable();
    }
    return;
}

UnicodeString&
SelectFormat::format(const Formattable& obj,
                   UnicodeString& appendTo,
                   FieldPosition& pos,
                   UErrorCode& status) const
{
    switch (obj.getType())
    {
    case Formattable::kString:
        return format(obj.getString(), appendTo, pos, status);
    default:
        if( U_SUCCESS(status) ){
            status = U_ILLEGAL_ARGUMENT_ERROR;
        }
        return appendTo;
    }
}

UnicodeString&
SelectFormat::format(const UnicodeString& keyword,
                     UnicodeString& appendTo,
                     FieldPosition& /*pos */,
                     UErrorCode& status) const {

    if (U_FAILURE(status)) return appendTo;

    if (parsedValuesHash == NULL) {
        status = U_INVALID_FORMAT_ERROR;
        return appendTo;
    }

    //Check for the validity of the keyword
    if ( !checkValidKeyword(keyword) ){
        status = U_ILLEGAL_ARGUMENT_ERROR;
        return appendTo;
    }

    UnicodeString *selectedPattern = (UnicodeString *)parsedValuesHash->get(keyword);
    if (selectedPattern == NULL) {
        selectedPattern = (UnicodeString *)parsedValuesHash->get(SELECT_KEYWORD_OTHER);
    }

    return appendTo += *selectedPattern;
}

UnicodeString&
SelectFormat::toPattern(UnicodeString& appendTo) {
    return appendTo += pattern;
}

SelectFormat::CharacterClass
SelectFormat::classifyCharacter(UChar ch) const{
    if ((ch >= CAP_A) && (ch <= CAP_Z)) {
        return tStartKeyword;
    }
    if ((ch >= LOW_A) && (ch <= LOW_Z)) {
        return tStartKeyword;
    }
    if ((ch >= U_ZERO) && (ch <= U_NINE)) {
        return tContinueKeyword;
    }
    if ( uprv_isRuleWhiteSpace(ch) ){
        return tSpace;
    }
    switch (ch) {
        case LEFTBRACE:
            return tLeftBrace;
        case RIGHTBRACE:
            return tRightBrace;
        case HYPHEN:
        case LOWLINE:
            return tContinueKeyword;
        default :
            return tOther;
    }
}

UBool
SelectFormat::checkSufficientDefinition() {
    // Check that at least the default rule is defined.
    return (parsedValuesHash != NULL &&
           parsedValuesHash->get(SELECT_KEYWORD_OTHER) != NULL) ;
}

UBool
SelectFormat::checkValidKeyword(const UnicodeString& argKeyword ) const{
    int32_t len = argKeyword.length();
    if (len < 1){
        return FALSE;
    }
    CharacterClass type = classifyCharacter(argKeyword.charAt(0));
    if( type != tStartKeyword ){
        return FALSE;
    }

    for (int32_t i = 0; i < argKeyword.length(); ++i) {
        type = classifyCharacter(argKeyword.charAt(i));
        if( type != tStartKeyword && type != tContinueKeyword ){
            return FALSE;
        }
    }
    return TRUE;
}

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

SelectFormat&
SelectFormat::operator=(const SelectFormat& other) {
    if (this != &other) {
        UErrorCode status = U_ZERO_ERROR;
        pattern = other.pattern;
        copyHashtable(other.parsedValuesHash, status);
    }
    return *this;
}

UBool
SelectFormat::operator==(const Format& other) const {
    if( this == &other){
        return TRUE;
    }
    if (typeid(*this) != typeid(other)) {
        return  FALSE;
    }
    SelectFormat* fmt = (SelectFormat*)&other;
    Hashtable* hashOther = fmt->parsedValuesHash;
    if ( parsedValuesHash == NULL && hashOther == NULL)
        return TRUE;
    if ( parsedValuesHash == NULL || hashOther == NULL)
        return FALSE;
    return parsedValuesHash->equals(*hashOther);
}

UBool
SelectFormat::operator!=(const Format& other) const {
    return  !operator==(other);
}

void
SelectFormat::parseObject(const UnicodeString& /*source*/,
                        Formattable& /*result*/,
                        ParsePosition& pos) const
{
    // TODO: not yet supported in icu4j and icu4c
    pos.setErrorIndex(pos.getIndex());
}

void
SelectFormat::copyHashtable(Hashtable *other, UErrorCode& status) {
    if (U_FAILURE(status)) {
      return;
    }
    if (other == NULL) {
      cleanHashTable();
      return;
    }
    if (parsedValuesHash == NULL) {
      initHashTable(status);
      if (U_FAILURE(status)) {
        return;
      }
    }

    parsedValuesHash->removeAll();
    parsedValuesHash->setValueDeleter(uhash_deleteUnicodeString);

    int32_t pos = -1;
    const UHashElement* elem = NULL;

    // walk through the hash table and create a deep clone
    while ((elem = other->nextElement(pos)) != NULL){
        const UHashTok otherKeyTok = elem->key;
        UnicodeString* otherKey = (UnicodeString*)otherKeyTok.pointer;
        const UHashTok otherKeyToVal = elem->value;
        UnicodeString* otherValue = (UnicodeString*)otherKeyToVal.pointer;
        parsedValuesHash->put(*otherKey, new UnicodeString(*otherValue), status);
        if (U_FAILURE(status)){
            cleanHashTable();
            return;
        }
    }
}

U_NAMESPACE_END

#endif /* #if !UCONFIG_NO_FORMATTING */

//eof
Commit	Line	Data
729e4ab9 A	1	/********************************************************************
	2	* COPYRIGHT:
	3	* Copyright (c) 1997-2010, International Business Machines Corporation and
	4	* others. All Rights Reserved.
	5	* Copyright (C) 2010 , Yahoo! Inc.
	6	********************************************************************
	7	*
	8	* File SELFMT.CPP
	9	*
	10	* Modification History:
	11	*
	12	* Date Name Description
	13	* 11/11/09 kirtig Finished first cut of implementation.
	14	* 11/16/09 kirtig Improved version
	15	********************************************************************/
	16
	17	#include <typeinfo> // for 'typeid' to work
	18
	19	#include "unicode/utypes.h"
	20	#include "unicode/ustring.h"
	21	#include "unicode/ucnv_err.h"
	22	#include "unicode/uchar.h"
	23	#include "unicode/umsg.h"
	24	#include "unicode/rbnf.h"
	25	#include "cmemory.h"
	26	#include "util.h"
	27	#include "uassert.h"
	28	#include "ustrfmt.h"
	29	#include "uvector.h"
	30
	31	#include "unicode/selfmt.h"
	32	#include "selfmtimpl.h"
	33
	34	#if !UCONFIG_NO_FORMATTING
	35
	36	U_NAMESPACE_BEGIN
	37
	38	UOBJECT_DEFINE_RTTI_IMPLEMENTATION(SelectFormat)
	39
	40	#define MAX_KEYWORD_SIZE 30
	41	static const UChar SELECT_KEYWORD_OTHER[] = {LOW_O, LOW_T, LOW_H, LOW_E, LOW_R, 0};
	42
	43	SelectFormat::SelectFormat(const UnicodeString& pat, UErrorCode& status) : parsedValuesHash(NULL) {
	44	if (U_FAILURE(status)) {
	45	return;
	46	}
	47	initHashTable(status);
	48	applyPattern(pat, status);
	49	}
	50
	51	SelectFormat::SelectFormat(const SelectFormat& other) : Format(other), parsedValuesHash(NULL) {
	52	UErrorCode status = U_ZERO_ERROR;
	53	pattern = other.pattern;
	54	copyHashtable(other.parsedValuesHash, status);
	55	}
	56
	57	SelectFormat::~SelectFormat() {
	58	cleanHashTable();
	59	}
	60
	61	void SelectFormat::initHashTable(UErrorCode &status) {
	62	if (U_FAILURE(status)) {
	63	return;
	64	}
65	// has inited
66	if (parsedValuesHash != NULL) {
67	return;
68	}
69
70	parsedValuesHash = new Hashtable(TRUE, status);
71	if (U_FAILURE(status)) {
72	cleanHashTable();
73	return;
74	} else {
75	if (parsedValuesHash == NULL) {
76	status = U_MEMORY_ALLOCATION_ERROR;
77	return;
78	}
79	}
80	// to use hashtable->equals(), must set Value Compartor.
81	parsedValuesHash->setValueComparator(uhash_compareCaselessUnicodeString);
82	}
83
84	void SelectFormat::cleanHashTable() {
85	if (parsedValuesHash != NULL) {
86	delete parsedValuesHash;
87	parsedValuesHash = NULL;
88	}
89	}
90
91	void
92	SelectFormat::applyPattern(const UnicodeString& newPattern, UErrorCode& status) {
93	if (U_FAILURE(status)) {
94	return;
95	}
96
97	pattern = newPattern;
98	enum State{ startState, keywordState, pastKeywordState, phraseState};
99
100	//Initialization
101	UnicodeString keyword ;
102	UnicodeString phrase ;
103	UnicodeString* ptrPhrase ;
104	int32_t braceCount = 0;
105
106	if (parsedValuesHash == NULL) {
107	initHashTable(status);
108	if (U_FAILURE(status)) {
109	return;
110	}
111	}
112	parsedValuesHash->removeAll();
113	parsedValuesHash->setValueDeleter(uhash_deleteUnicodeString);
114
115	//Process the state machine
116	State state = startState;
117	for (int32_t i = 0; i < pattern.length(); ++i) {
118	//Get the character and check its type
119	UChar ch = pattern.charAt(i);
120	CharacterClass type = classifyCharacter(ch);
121
122	//Allow any character in phrase but nowhere else
123	if ( type == tOther ) {
124	if ( state == phraseState ){
125	phrase += ch;
126	continue;
127	}else {
128	status = U_PATTERN_SYNTAX_ERROR;
129	cleanHashTable();
130	return;
131	}
132	}
133
134	//Process the state machine
135	switch (state) {
136	//At the start of pattern
137	case startState:
138	switch (type) {
139	case tSpace:
140	break;
141	case tStartKeyword:
142	state = keywordState;
143	keyword += ch;
144	break;
145	//If anything else is encountered, it's a syntax error
146	default:
147	status = U_PATTERN_SYNTAX_ERROR;
148	cleanHashTable();
149	return;
150	}//end of switch(type)
151	break;
152
153	//Handle the keyword state
154	case keywordState:
155	switch (type) {
156	case tSpace:
157	state = pastKeywordState;
158	break;
159	case tStartKeyword:
160	case tContinueKeyword:
161	keyword += ch;
162	break;
163	case tLeftBrace:
164	state = phraseState;
165	break;
166	//If anything else is encountered, it's a syntax error
167	default:
168	status = U_PATTERN_SYNTAX_ERROR;
169	cleanHashTable();
170	return;
171	}//end of switch(type)
172	break;
173
174	//Handle the pastkeyword state
175	case pastKeywordState:
176	switch (type) {
177	case tSpace:
178	break;
179	case tLeftBrace:
180	state = phraseState;
181	break;
182	//If anything else is encountered, it's a syntax error
183	default:
184	status = U_PATTERN_SYNTAX_ERROR;
185	cleanHashTable();
186	return;
187	}//end of switch(type)
188	break;
189
190	//Handle the phrase state
191	case phraseState:
192	switch (type) {
193	case tLeftBrace:
194	braceCount++;
195	phrase += ch;
196	break;
197	case tRightBrace:
198	//Matching keyword, phrase pair found
199	if (braceCount == 0){
200	//Check validity of keyword
201	if (parsedValuesHash->get(keyword) != NULL) {
202	status = U_DUPLICATE_KEYWORD;
203	cleanHashTable();
204	return;
205	}
206	if (keyword.length() == 0) {
207	status = U_PATTERN_SYNTAX_ERROR;
208	cleanHashTable();
209	return;
210	}
211
212	//Store the keyword, phrase pair in hashTable
213	ptrPhrase = new UnicodeString(phrase);
214	parsedValuesHash->put( keyword, ptrPhrase, status);
215
216	//Reinitialize
217	keyword.remove();
218	phrase.remove();
219	ptrPhrase = NULL;
220	state = startState;
221	}
222
223	if (braceCount > 0){
224	braceCount-- ;
225	phrase += ch;
226	}
227	break;
228	default:
229	phrase += ch;
230	}//end of switch(type)
231	break;
232
233	//Handle the default case of switch(state)
234	default:
235	status = U_PATTERN_SYNTAX_ERROR;
236	cleanHashTable();
237	return;
238
239	}//end of switch(state)
240	}
241
242	//Check if the state machine is back to startState
243	if ( state != startState){
244	status = U_PATTERN_SYNTAX_ERROR;
245	cleanHashTable();
246	return;
247	}
248
249	//Check if "other" keyword is present
250	if ( !checkSufficientDefinition() ) {
251	status = U_DEFAULT_KEYWORD_MISSING;
252	cleanHashTable();
253	}
254	return;
255	}
256
257	UnicodeString&
258	SelectFormat::format(const Formattable& obj,
259	UnicodeString& appendTo,
260	FieldPosition& pos,
261	UErrorCode& status) const
262	{
263	switch (obj.getType())
264	{
265	case Formattable::kString:
266	return format(obj.getString(), appendTo, pos, status);
267	default:
268	if( U_SUCCESS(status) ){
269	status = U_ILLEGAL_ARGUMENT_ERROR;
270	}
271	return appendTo;
272	}
273	}
274
275	UnicodeString&
276	SelectFormat::format(const UnicodeString& keyword,
277	UnicodeString& appendTo,
278	FieldPosition& /pos /,
279	UErrorCode& status) const {
280
281	if (U_FAILURE(status)) return appendTo;
282
283	if (parsedValuesHash == NULL) {
284	status = U_INVALID_FORMAT_ERROR;
285	return appendTo;
286	}
287
288	//Check for the validity of the keyword
289	if ( !checkValidKeyword(keyword) ){
290	status = U_ILLEGAL_ARGUMENT_ERROR;
291	return appendTo;
292	}
293
294	UnicodeString selectedPattern = (UnicodeString )parsedValuesHash->get(keyword);
295	if (selectedPattern == NULL) {
296	selectedPattern = (UnicodeString *)parsedValuesHash->get(SELECT_KEYWORD_OTHER);
297	}
298
299	return appendTo += *selectedPattern;
300	}
301
302	UnicodeString&
303	SelectFormat::toPattern(UnicodeString& appendTo) {
304	return appendTo += pattern;
305	}
306
307	SelectFormat::CharacterClass
308	SelectFormat::classifyCharacter(UChar ch) const{
309	if ((ch >= CAP_A) && (ch <= CAP_Z)) {
310	return tStartKeyword;
311	}
312	if ((ch >= LOW_A) && (ch <= LOW_Z)) {
313	return tStartKeyword;
314	}
315	if ((ch >= U_ZERO) && (ch <= U_NINE)) {
316	return tContinueKeyword;
317	}
318	if ( uprv_isRuleWhiteSpace(ch) ){
319	return tSpace;
320	}
321	switch (ch) {
322	case LEFTBRACE:
323	return tLeftBrace;
324	case RIGHTBRACE:
325	return tRightBrace;
326	case HYPHEN:
327	case LOWLINE:
328	return tContinueKeyword;
329	default :
330	return tOther;
331	}
332	}
333
334	UBool
335	SelectFormat::checkSufficientDefinition() {
336	// Check that at least the default rule is defined.
337	return (parsedValuesHash != NULL &&
338	parsedValuesHash->get(SELECT_KEYWORD_OTHER) != NULL) ;
339	}
340
341	UBool
342	SelectFormat::checkValidKeyword(const UnicodeString& argKeyword ) const{
343	int32_t len = argKeyword.length();
344	if (len < 1){
345	return FALSE;
346	}
347	CharacterClass type = classifyCharacter(argKeyword.charAt(0));
348	if( type != tStartKeyword ){
349	return FALSE;
350	}
351
352	for (int32_t i = 0; i < argKeyword.length(); ++i) {
353	type = classifyCharacter(argKeyword.charAt(i));
354	if( type != tStartKeyword && type != tContinueKeyword ){
355	return FALSE;
356	}
357	}
358	return TRUE;
359	}
360
361	Format* SelectFormat::clone() const
362	{
363	return new SelectFormat(*this);
364	}
365
366	SelectFormat&
367	SelectFormat::operator=(const SelectFormat& other) {
368	if (this != &other) {
369	UErrorCode status = U_ZERO_ERROR;
370	pattern = other.pattern;
371	copyHashtable(other.parsedValuesHash, status);
372	}
373	return *this;
374	}
375
376	UBool
377	SelectFormat::operator==(const Format& other) const {
378	if( this == &other){
379	return TRUE;
380	}
381	if (typeid(*this) != typeid(other)) {
382	return FALSE;
383	}
384	SelectFormat* fmt = (SelectFormat*)&other;
385	Hashtable* hashOther = fmt->parsedValuesHash;
386	if ( parsedValuesHash == NULL && hashOther == NULL)
387	return TRUE;
388	if ( parsedValuesHash == NULL \|\| hashOther == NULL)
389	return FALSE;
390	return parsedValuesHash->equals(*hashOther);
391	}
392
393	UBool
394	SelectFormat::operator!=(const Format& other) const {
395	return !operator==(other);
396	}
397
398	void
399	SelectFormat::parseObject(const UnicodeString& /source/,
400	Formattable& /result/,
401	ParsePosition& pos) const
402	{
403	// TODO: not yet supported in icu4j and icu4c
404	pos.setErrorIndex(pos.getIndex());
405	}
406
407	void
408	SelectFormat::copyHashtable(Hashtable *other, UErrorCode& status) {
409	if (U_FAILURE(status)) {
410	return;
411	}
412	if (other == NULL) {
413	cleanHashTable();
414	return;
415	}
416	if (parsedValuesHash == NULL) {
417	initHashTable(status);
418	if (U_FAILURE(status)) {
419	return;
420	}
421	}
422
423	parsedValuesHash->removeAll();
424	parsedValuesHash->setValueDeleter(uhash_deleteUnicodeString);
425
426	int32_t pos = -1;
427	const UHashElement* elem = NULL;
428
429	// walk through the hash table and create a deep clone
430	while ((elem = other->nextElement(pos)) != NULL){
431	const UHashTok otherKeyTok = elem->key;
432	UnicodeString* otherKey = (UnicodeString*)otherKeyTok.pointer;
433	const UHashTok otherKeyToVal = elem->value;
434	UnicodeString* otherValue = (UnicodeString*)otherKeyToVal.pointer;
435	parsedValuesHash->put(otherKey, new UnicodeString(otherValue), status);
436	if (U_FAILURE(status)){
437	cleanHashTable();
438	return;
439	}
440	}
441	}
442
443	U_NAMESPACE_END
444
445	#endif /* #if !UCONFIG_NO_FORMATTING */
446
447	//eof