icuSources/i18n/selfmt.cpp

   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