ICU 56 update step 1

source/i18n/plurfmt.cpp

 /*
 *******************************************************************************
-* Copyright (C) 2009-2014, International Business Machines Corporation and
+* Copyright (C) 2009-2015, International Business Machines Corporation and
 * others. All Rights Reserved.
 *******************************************************************************
 *
 * File PLURFMT.CPP
 *******************************************************************************
 */
 
 #include "unicode/decimfmt.h"
 #include "unicode/messagepattern.h"
 #include "unicode/plurfmt.h"
 #include "unicode/plurrule.h"
 #include "unicode/utypes.h"
 #include "cmemory.h"
 #include "messageimpl.h"
 #include "nfrule.h"
 #include "plurrule_impl.h"
 #include "uassert.h"
 #include "uhash.h"
+#include "precision.h"
+#include "visibledigits.h"
 
 #if !UCONFIG_NO_FORMATTING
 
 U_NAMESPACE_BEGIN
 
 static const UChar OTHER_STRING[] = {
     0x6F, 0x74, 0x68, 0x65, 0x72, 0  // "other"
 };
 
 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(PluralFormat)
@@ skipping 220 matching lines @@
         return appendTo;
     }
     if (msgPattern.countParts() == 0) {
         return numberFormat->format(numberObject, appendTo, pos, status);
     }
     // Get the appropriate sub-message.
     // Select it based on the formatted number-offset.
     double numberMinusOffset = number - offset;
     UnicodeString numberString;
     FieldPosition ignorePos;
-    FixedDecimal dec(numberMinusOffset);
+    FixedPrecision fp;
+    VisibleDigitsWithExponent dec;
+    fp.initVisibleDigitsWithExponent(numberMinusOffset, dec, status);
+    if (U_FAILURE(status)) {
+        return appendTo;
+    }
     if (offset == 0) {
-        numberFormat->format(numberObject, numberString, ignorePos, status);  // could be BigDecimal etc.
         DecimalFormat *decFmt = dynamic_cast<DecimalFormat *>(numberFormat);
         if(decFmt != NULL) {
-            dec = decFmt->getFixedDecimal(numberObject, status);
+            decFmt->initVisibleDigitsWithExponent(
+                    numberObject, dec, status);
+            if (U_FAILURE(status)) {
+                return appendTo;
+            }
+            decFmt->format(dec, numberString, ignorePos, status);
+        } else {
+            numberFormat->format(
+                    numberObject, numberString, ignorePos, status);  // could be BigDecimal etc.
         }
     } else {
-        numberFormat->format(numberMinusOffset, numberString, ignorePos, status);
         DecimalFormat *decFmt = dynamic_cast<DecimalFormat *>(numberFormat);
         if(decFmt != NULL) {
-            dec = decFmt->getFixedDecimal(numberMinusOffset, status);
+            decFmt->initVisibleDigitsWithExponent(
+                    numberMinusOffset, dec, status);
+            if (U_FAILURE(status)) {
+                return appendTo;
+            }
+            decFmt->format(dec, numberString, ignorePos, status);
+        } else {
+            numberFormat->format(
+                    numberMinusOffset, numberString, ignorePos, status);
         }
     }
     int32_t partIndex = findSubMessage(msgPattern, 0, pluralRulesWrapper, &dec, number, status);
     if (U_FAILURE(status)) { return appendTo; }
     // Replace syntactic # signs in the top level of this sub-message
     // (not in nested arguments) with the formatted number-offset.
     const UnicodeString& pattern = msgPattern.getPatternString();
     int32_t prevIndex = msgPattern.getPart(partIndex).getLimit();
     for (;;) {
         const MessagePattern::Part& part = msgPattern.getPart(++partIndex);
@@ skipping 242 matching lines @@
             continue;
         }
 
         UnicodeString currArg = pattern.tempSubString(partStart->getLimit(), partLimit->getIndex() - partStart->getLimit());
         if (rbnfLenientScanner != NULL) {
             // If lenient parsing is turned ON, we've got some time consuming parsing ahead of us.
             int32_t length = -1;
             currMatchIndex = rbnfLenientScanner->findTextLenient(source, currArg, startingAt, &length);
         }
         else {
-            currMatchIndex = source.indexOf(currArg);
+            currMatchIndex = source.indexOf(currArg, startingAt);
         }
         if (currMatchIndex >= 0 && currMatchIndex >= matchedIndex && currArg.length() > matchedWord.length()) {
             matchedIndex = currMatchIndex;
             matchedWord = currArg;
             keyword = pattern.tempSubString(partStart->getLimit(), partLimit->getIndex() - partStart->getLimit());
         }
     }
     if (matchedIndex >= 0) {
         pos.setBeginIndex(matchedIndex);
         pos.setEndIndex(matchedIndex + matchedWord.length());
         result.setString(keyword);
         return;
     }
 
     // Not found!
     pos.setBeginIndex(-1);
     pos.setEndIndex(-1);
 }
 
 PluralFormat::PluralSelector::~PluralSelector() {}
 
 PluralFormat::PluralSelectorAdapter::~PluralSelectorAdapter() {
     delete pluralRules;
 }
 
 UnicodeString PluralFormat::PluralSelectorAdapter::select(void *context, double number,
                                                           UErrorCode& /*ec*/) const {
     (void)number;  // unused except in the assertion
-    FixedDecimal *dec=static_cast<FixedDecimal *>(context);
-    U_ASSERT(dec->source==number);
+    VisibleDigitsWithExponent *dec=static_cast<VisibleDigitsWithExponent *>(context);
     return pluralRules->select(*dec);
 }
 
 void PluralFormat::PluralSelectorAdapter::reset() {
     delete pluralRules;
     pluralRules = NULL;
 }
 
 
 U_NAMESPACE_END
 
 
 #endif /* #if !UCONFIG_NO_FORMATTING */
 
 //eof