icuSources/i18n/plurfmt.cpp

   1 /*
   2 *******************************************************************************
   3 * Copyright (C) 2009-2012, International Business Machines Corporation and
   4 * others. All Rights Reserved.
   5 *******************************************************************************
   6 *
   7 * File PLURFMT.CPP
   8 *
   9 * Modification History:
  10 *
  11 *   Date        Name        Description
  12 *******************************************************************************
  13 */
  14
  15 #include "unicode/messagepattern.h"
  16 #include "unicode/plurfmt.h"
  17 #include "unicode/plurrule.h"
  18 #include "unicode/utypes.h"
  19 #include "cmemory.h"
  20 #include "messageimpl.h"
  21 #include "plurrule_impl.h"
  22 #include "uassert.h"
  23 #include "uhash.h"
  24
  25 #if !UCONFIG_NO_FORMATTING
  26
  27 U_NAMESPACE_BEGIN
  28
  29 static const UChar OTHER_STRING[] = {
  30     0x6F, 0x74, 0x68, 0x65, 0x72, 0  // "other"
  31 };
  32
  33 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(PluralFormat)
  34
  35 PluralFormat::PluralFormat(UErrorCode& status)
  36         : locale(Locale::getDefault()),
  37           msgPattern(status),
  38           numberFormat(NULL),
  39           offset(0) {
  40     init(NULL, UPLURAL_TYPE_CARDINAL, status);
  41 }
  42
  43 PluralFormat::PluralFormat(const Locale& loc, UErrorCode& status)
  44         : locale(loc),
  45           msgPattern(status),
  46           numberFormat(NULL),
  47           offset(0) {
  48     init(NULL, UPLURAL_TYPE_CARDINAL, status);
  49 }
  50
  51 PluralFormat::PluralFormat(const PluralRules& rules, UErrorCode& status)
  52         : locale(Locale::getDefault()),
  53           msgPattern(status),
  54           numberFormat(NULL),
  55           offset(0) {
  56     init(&rules, UPLURAL_TYPE_COUNT, status);
  57 }
  58
  59 PluralFormat::PluralFormat(const Locale& loc,
  60                            const PluralRules& rules,
  61                            UErrorCode& status)
  62         : locale(loc),
  63           msgPattern(status),
  64           numberFormat(NULL),
  65           offset(0) {
  66     init(&rules, UPLURAL_TYPE_COUNT, status);
  67 }
  68
  69 PluralFormat::PluralFormat(const Locale& loc,
  70                            UPluralType type,
  71                            UErrorCode& status)
  72         : locale(loc),
  73           msgPattern(status),
  74           numberFormat(NULL),
  75           offset(0) {
  76     init(NULL, type, status);
  77 }
  78
  79 PluralFormat::PluralFormat(const UnicodeString& pat,
  80                            UErrorCode& status)
  81         : locale(Locale::getDefault()),
  82           msgPattern(status),
  83           numberFormat(NULL),
  84           offset(0) {
  85     init(NULL, UPLURAL_TYPE_CARDINAL, status);
  86     applyPattern(pat, status);
  87 }
  88
  89 PluralFormat::PluralFormat(const Locale& loc,
  90                            const UnicodeString& pat,
  91                            UErrorCode& status)
  92         : locale(loc),
  93           msgPattern(status),
  94           numberFormat(NULL),
  95           offset(0) {
  96     init(NULL, UPLURAL_TYPE_CARDINAL, status);
  97     applyPattern(pat, status);
  98 }
  99
 100 PluralFormat::PluralFormat(const PluralRules& rules,
 101                            const UnicodeString& pat,
 102                            UErrorCode& status)
 103         : locale(Locale::getDefault()),
 104           msgPattern(status),
 105           numberFormat(NULL),
 106           offset(0) {
 107     init(&rules, UPLURAL_TYPE_COUNT, status);
 108     applyPattern(pat, status);
 109 }
 110
 111 PluralFormat::PluralFormat(const Locale& loc,
 112                            const PluralRules& rules,
 113                            const UnicodeString& pat,
 114                            UErrorCode& status)
 115         : locale(loc),
 116           msgPattern(status),
 117           numberFormat(NULL),
 118           offset(0) {
 119     init(&rules, UPLURAL_TYPE_COUNT, status);
 120     applyPattern(pat, status);
 121 }
 122
 123 PluralFormat::PluralFormat(const Locale& loc,
 124                            UPluralType type,
 125                            const UnicodeString& pat,
 126                            UErrorCode& status)
 127         : locale(loc),
 128           msgPattern(status),
 129           numberFormat(NULL),
 130           offset(0) {
 131     init(NULL, type, status);
 132     applyPattern(pat, status);
 133 }
 134
 135 PluralFormat::PluralFormat(const PluralFormat& other)
 136         : Format(other),
 137           locale(other.locale),
 138           msgPattern(other.msgPattern),
 139           numberFormat(NULL),
 140           offset(other.offset) {
 141     copyObjects(other);
 142 }
 143
 144 void
 145 PluralFormat::copyObjects(const PluralFormat& other) {
 146     UErrorCode status = U_ZERO_ERROR;
 147     if (numberFormat != NULL) {
 148         delete numberFormat;
 149     }
 150     if (pluralRulesWrapper.pluralRules != NULL) {
 151         delete pluralRulesWrapper.pluralRules;
 152     }
 153
 154     if (other.numberFormat == NULL) {
 155         numberFormat = NumberFormat::createInstance(locale, status);
 156     } else {
 157         numberFormat = (NumberFormat*)other.numberFormat->clone();
 158     }
 159     if (other.pluralRulesWrapper.pluralRules == NULL) {
 160         pluralRulesWrapper.pluralRules = PluralRules::forLocale(locale, status);
 161     } else {
 162         pluralRulesWrapper.pluralRules = other.pluralRulesWrapper.pluralRules->clone();
 163     }
 164 }
 165
 166
 167 PluralFormat::~PluralFormat() {
 168     delete numberFormat;
 169 }
 170
 171 void
 172 PluralFormat::init(const PluralRules* rules, UPluralType type, UErrorCode& status) {
 173     if (U_FAILURE(status)) {
 174         return;
 175     }
 176
 177     if (rules==NULL) {
 178         pluralRulesWrapper.pluralRules = PluralRules::forLocale(locale, type, status);
 179     } else {
 180         pluralRulesWrapper.pluralRules = rules->clone();
 181         if (pluralRulesWrapper.pluralRules == NULL) {
 182             status = U_MEMORY_ALLOCATION_ERROR;
 183             return;
 184         }
 185     }
 186
 187     numberFormat= NumberFormat::createInstance(locale, status);
 188 }
 189
 190 void
 191 PluralFormat::applyPattern(const UnicodeString& newPattern, UErrorCode& status) {
 192     msgPattern.parsePluralStyle(newPattern, NULL, status);
 193     if (U_FAILURE(status)) {
 194         msgPattern.clear();
 195         offset = 0;
 196         return;
 197     }
 198     offset = msgPattern.getPluralOffset(0);
 199 }
 200
 201 UnicodeString&
 202 PluralFormat::format(const Formattable& obj,
 203                    UnicodeString& appendTo,
 204                    FieldPosition& pos,
 205                    UErrorCode& status) const
 206 {
 207     if (U_FAILURE(status)) return appendTo;
 208
 209     if (obj.isNumeric()) {
 210         return format(obj.getDouble(), appendTo, pos, status);
 211     } else {
 212         status = U_ILLEGAL_ARGUMENT_ERROR;
 213         return appendTo;
 214     }
 215 }
 216
 217 UnicodeString
 218 PluralFormat::format(int32_t number, UErrorCode& status) const {
 219     FieldPosition fpos(0);
 220     UnicodeString result;
 221     return format(number, result, fpos, status);
 222 }
 223
 224 UnicodeString
 225 PluralFormat::format(double number, UErrorCode& status) const {
 226     FieldPosition fpos(0);
 227     UnicodeString result;
 228     return format(number, result, fpos, status);
 229 }
 230
 231
 232 UnicodeString&
 233 PluralFormat::format(int32_t number,
 234                      UnicodeString& appendTo,
 235                      FieldPosition& pos,
 236                      UErrorCode& status) const {
 237     return format((double)number, appendTo, pos, status);
 238 }
 239
 240 UnicodeString&
 241 PluralFormat::format(double number,
 242                      UnicodeString& appendTo,
 243                      FieldPosition& pos,
 244                      UErrorCode& status) const {
 245     if (U_FAILURE(status)) {
 246         return appendTo;
 247     }
 248     if (msgPattern.countParts() == 0) {
 249         return numberFormat->format(number, appendTo, pos);
 250     }
 251     // Get the appropriate sub-message.
 252     int32_t partIndex = findSubMessage(msgPattern, 0, pluralRulesWrapper, number, status);
 253     // Replace syntactic # signs in the top level of this sub-message
 254     // (not in nested arguments) with the formatted number-offset.
 255     const UnicodeString& pattern = msgPattern.getPatternString();
 256     number -= offset;
 257     int32_t prevIndex = msgPattern.getPart(partIndex).getLimit();
 258     for (;;) {
 259         const MessagePattern::Part& part = msgPattern.getPart(++partIndex);
 260         const UMessagePatternPartType type = part.getType();
 261         int32_t index = part.getIndex();
 262         if (type == UMSGPAT_PART_TYPE_MSG_LIMIT) {
 263             return appendTo.append(pattern, prevIndex, index - prevIndex);
 264         } else if ((type == UMSGPAT_PART_TYPE_REPLACE_NUMBER) ||
 265             (type == UMSGPAT_PART_TYPE_SKIP_SYNTAX && MessageImpl::jdkAposMode(msgPattern))) {
 266             appendTo.append(pattern, prevIndex, index - prevIndex);
 267             if (type == UMSGPAT_PART_TYPE_REPLACE_NUMBER) {
 268                 numberFormat->format(number, appendTo);
 269             }
 270             prevIndex = part.getLimit();
 271         } else if (type == UMSGPAT_PART_TYPE_ARG_START) {
 272             appendTo.append(pattern, prevIndex, index - prevIndex);
 273             prevIndex = index;
 274             partIndex = msgPattern.getLimitPartIndex(partIndex);
 275             index = msgPattern.getPart(partIndex).getLimit();
 276             MessageImpl::appendReducedApostrophes(pattern, prevIndex, index, appendTo);
 277             prevIndex = index;
 278         }
 279     }
 280 }
 281
 282 UnicodeString&
 283 PluralFormat::toPattern(UnicodeString& appendTo) {
 284     if (0 == msgPattern.countParts()) {
 285         appendTo.setToBogus();
 286     } else {
 287         appendTo.append(msgPattern.getPatternString());
 288     }
 289     return appendTo;
 290 }
 291
 292 void
 293 PluralFormat::setLocale(const Locale& loc, UErrorCode& status) {
 294     if (U_FAILURE(status)) {
 295         return;
 296     }
 297     locale = loc;
 298     msgPattern.clear();
 299     delete numberFormat;
 300     offset = 0;
 301     numberFormat = NULL;
 302     pluralRulesWrapper.reset();
 303     init(NULL, UPLURAL_TYPE_CARDINAL, status);
 304 }
 305
 306 void
 307 PluralFormat::setNumberFormat(const NumberFormat* format, UErrorCode& status) {
 308     if (U_FAILURE(status)) {
 309         return;
 310     }
 311     NumberFormat* nf = (NumberFormat*)format->clone();
 312     if (nf != NULL) {
 313         delete numberFormat;
 314         numberFormat = nf;
 315     } else {
 316         status = U_MEMORY_ALLOCATION_ERROR;
 317     }
 318 }
 319
 320 Format*
 321 PluralFormat::clone() const
 322 {
 323     return new PluralFormat(*this);
 324 }
 325
 326
 327 PluralFormat&
 328 PluralFormat::operator=(const PluralFormat& other) {
 329     if (this != &other) {
 330         locale = other.locale;
 331         msgPattern = other.msgPattern;
 332         offset = other.offset;
 333         copyObjects(other);
 334     }
 335
 336     return *this;
 337 }
 338
 339 UBool
 340 PluralFormat::operator==(const Format& other) const {
 341     if (this == &other) {
 342         return TRUE;
 343     }
 344     if (!Format::operator==(other)) {
 345         return FALSE;
 346     }
 347     const PluralFormat& o = (const PluralFormat&)other;
 348     return
 349         locale == o.locale &&
 350         msgPattern == o.msgPattern &&  // implies same offset
 351         (numberFormat == NULL) == (o.numberFormat == NULL) &&
 352         (numberFormat == NULL || *numberFormat == *o.numberFormat) &&
 353         (pluralRulesWrapper.pluralRules == NULL) == (o.pluralRulesWrapper.pluralRules == NULL) &&
 354         (pluralRulesWrapper.pluralRules == NULL ||
 355             *pluralRulesWrapper.pluralRules == *o.pluralRulesWrapper.pluralRules);
 356 }
 357
 358 UBool
 359 PluralFormat::operator!=(const Format& other) const {
 360     return  !operator==(other);
 361 }
 362
 363 void
 364 PluralFormat::parseObject(const UnicodeString& /*source*/,
 365                         Formattable& /*result*/,
 366                         ParsePosition& pos) const
 367 {
 368     // Parsing not supported.
 369     pos.setErrorIndex(pos.getIndex());
 370 }
 371
 372 int32_t PluralFormat::findSubMessage(const MessagePattern& pattern, int32_t partIndex,
 373                                      const PluralSelector& selector, double number, UErrorCode& ec) {
 374     if (U_FAILURE(ec)) {
 375         return 0;
 376     }
 377     int32_t count=pattern.countParts();
 378     double offset;
 379     const MessagePattern::Part* part=&pattern.getPart(partIndex);
 380     if (MessagePattern::Part::hasNumericValue(part->getType())) {
 381         offset=pattern.getNumericValue(*part);
 382         ++partIndex;
 383     } else {
 384         offset=0;
 385     }
 386     // The keyword is empty until we need to match against non-explicit, not-"other" value.
 387     // Then we get the keyword from the selector.
 388     // (In other words, we never call the selector if we match against an explicit value,
 389     // or if the only non-explicit keyword is "other".)
 390     UnicodeString keyword;
 391     UnicodeString other(FALSE, OTHER_STRING, 5);
 392     // When we find a match, we set msgStart>0 and also set this boolean to true
 393     // to avoid matching the keyword again (duplicates are allowed)
 394     // while we continue to look for an explicit-value match.
 395     UBool haveKeywordMatch=FALSE;
 396     // msgStart is 0 until we find any appropriate sub-message.
 397     // We remember the first "other" sub-message if we have not seen any
 398     // appropriate sub-message before.
 399     // We remember the first matching-keyword sub-message if we have not seen
 400     // one of those before.
 401     // (The parser allows [does not check for] duplicate keywords.
 402     // We just have to make sure to take the first one.)
 403     // We avoid matching the keyword twice by also setting haveKeywordMatch=true
 404     // at the first keyword match.
 405     // We keep going until we find an explicit-value match or reach the end of the plural style.
 406     int32_t msgStart=0;
 407     // Iterate over (ARG_SELECTOR [ARG_INT|ARG_DOUBLE] message) tuples
 408     // until ARG_LIMIT or end of plural-only pattern.
 409     do {
 410         part=&pattern.getPart(partIndex++);
 411         const UMessagePatternPartType type = part->getType();
 412         if(type==UMSGPAT_PART_TYPE_ARG_LIMIT) {
 413             break;
 414         }
 415         U_ASSERT (type==UMSGPAT_PART_TYPE_ARG_SELECTOR);
 416         // part is an ARG_SELECTOR followed by an optional explicit value, and then a message
 417         if(MessagePattern::Part::hasNumericValue(pattern.getPartType(partIndex))) {
 418             // explicit value like "=2"
 419             part=&pattern.getPart(partIndex++);
 420             if(number==pattern.getNumericValue(*part)) {
 421                 // matches explicit value
 422                 return partIndex;
 423             }
 424         } else if(!haveKeywordMatch) {
 425             // plural keyword like "few" or "other"
 426             // Compare "other" first and call the selector if this is not "other".
 427             if(pattern.partSubstringMatches(*part, other)) {
 428                 if(msgStart==0) {
 429                     msgStart=partIndex;
 430                     if(0 == keyword.compare(other)) {
 431                         // This is the first "other" sub-message,
 432                         // and the selected keyword is also "other".
 433                         // Do not match "other" again.
 434                         haveKeywordMatch=TRUE;
 435                     }
 436                 }
 437             } else {
 438                 if(keyword.isEmpty()) {
 439                     keyword=selector.select(number-offset, ec);
 440                     if(msgStart!=0 && (0 == keyword.compare(other))) {
 441                         // We have already seen an "other" sub-message.
 442                         // Do not match "other" again.
 443                         haveKeywordMatch=TRUE;
 444                         // Skip keyword matching but do getLimitPartIndex().
 445                     }
 446                 }
 447                 if(!haveKeywordMatch && pattern.partSubstringMatches(*part, keyword)) {
 448                     // keyword matches
 449                     msgStart=partIndex;
 450                     // Do not match this keyword again.
 451                     haveKeywordMatch=TRUE;
 452                 }
 453             }
 454         }
 455         partIndex=pattern.getLimitPartIndex(partIndex);
 456     } while(++partIndex<count);
 457     return msgStart;
 458 }
 459
 460 PluralFormat::PluralSelector::~PluralSelector() {}
 461
 462 PluralFormat::PluralSelectorAdapter::~PluralSelectorAdapter() {
 463     delete pluralRules;
 464 }
 465
 466 UnicodeString PluralFormat::PluralSelectorAdapter::select(double number,
 467                                                           UErrorCode& /*ec*/) const {
 468     return pluralRules->select(number);
 469 }
 470
 471 void PluralFormat::PluralSelectorAdapter::reset() {
 472     delete pluralRules;
 473     pluralRules = NULL;
 474 }
 475
 476
 477 U_NAMESPACE_END
 478
 479
 480 #endif /* #if !UCONFIG_NO_FORMATTING */
 481
 482 //eof