ICU 56 update step 1

source/common/simplepatternformatter.cpp

 /*
 ******************************************************************************
 * Copyright (C) 2014, International Business Machines
 * Corporation and others.  All Rights Reserved.
 ******************************************************************************
 * simplepatternformatter.cpp
 */
 #include "simplepatternformatter.h"
 #include "cstring.h"
 #include "uassert.h"
 
 U_NAMESPACE_BEGIN
 
+static UBool isInvalidArray(const void *array, int32_t size) {
+   return (size < 0 || (size > 0 && array == NULL));
+}
+
 typedef enum SimplePatternFormatterCompileState {
     INIT,
     APOSTROPHE,
     PLACEHOLDER
 } SimplePatternFormatterCompileState;
 
+// Handles parsing placeholders in the pattern string, e.g {4} or {35}
 class SimplePatternFormatterIdBuilder {
 public:
     SimplePatternFormatterIdBuilder() : id(0), idLen(0) { }
     ~SimplePatternFormatterIdBuilder() { }
+
+    // Resets so that this object has seen no placeholder ID.
     void reset() { id = 0; idLen = 0; }
+
+    // Returns the numeric placeholder ID parsed so far
     int32_t getId() const { return id; }
+
+    // Appends the numeric placeholder ID parsed so far back to a
+    // UChar buffer. Used to recover if parser using this object finds
+    // no closing curly brace.
     void appendTo(UChar *buffer, int32_t *len) const;
+
+    // Returns true if this object has seen a placeholder ID.
     UBool isValid() const { return (idLen > 0); }
+
+    // Processes a single digit character. Pattern string parser calls this
+    // as it processes digits after an opening curly brace.
     void add(UChar ch);
 private:
     int32_t id;
     int32_t idLen;
     SimplePatternFormatterIdBuilder(
             const SimplePatternFormatterIdBuilder &other);
     SimplePatternFormatterIdBuilder &operator=(
             const SimplePatternFormatterIdBuilder &other);
 };
 
 void SimplePatternFormatterIdBuilder::appendTo(
         UChar *buffer, int32_t *len) const {
     int32_t origLen = *len;
     int32_t kId = id;
     for (int32_t i = origLen + idLen - 1; i >= origLen; i--) {
         int32_t digit = kId % 10;
         buffer[i] = digit + 0x30;
         kId /= 10;
     }
     *len = origLen + idLen;
 }
 
 void SimplePatternFormatterIdBuilder::add(UChar ch) {
     id = id * 10 + (ch - 0x30);
     idLen++;
 }
 
+// Represents placeholder values.
+class SimplePatternFormatterPlaceholderValues : public UMemory {
+public:
+    SimplePatternFormatterPlaceholderValues(
+            const UnicodeString * const *values,
+            int32_t valuesCount);
+
+    // Returns TRUE if appendTo value is at any index besides exceptIndex.
+    UBool isAppendToInAnyIndexExcept(
+            const UnicodeString &appendTo, int32_t exceptIndex) const;
+
+    // For each appendTo value, stores the snapshot of it in its place.
+    void snapshotAppendTo(const UnicodeString &appendTo);
+
+    // Returns the placeholder value at index. No range checking performed.
+    // Returned reference is valid for as long as this object exists.
+    const UnicodeString &get(int32_t index) const;
+private:
+    const UnicodeString * const *fValues;
+    int32_t fValuesCount;
+    const UnicodeString *fAppendTo;
+    UnicodeString fAppendToCopy;
+    SimplePatternFormatterPlaceholderValues(
+            const SimplePatternFormatterPlaceholderValues &);
+    SimplePatternFormatterPlaceholderValues &operator=(
+            const SimplePatternFormatterPlaceholderValues &);
+};
+
+SimplePatternFormatterPlaceholderValues::SimplePatternFormatterPlaceholderValues(
+        const UnicodeString * const *values,
+        int32_t valuesCount) 
+        : fValues(values),
+          fValuesCount(valuesCount),
+          fAppendTo(NULL),
+          fAppendToCopy() {
+}
+
+UBool SimplePatternFormatterPlaceholderValues::isAppendToInAnyIndexExcept(
+        const UnicodeString &appendTo, int32_t exceptIndex) const {
+    for (int32_t i = 0; i < fValuesCount; ++i) {
+        if (i != exceptIndex && fValues[i] == &appendTo) {
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+void SimplePatternFormatterPlaceholderValues::snapshotAppendTo(
+        const UnicodeString &appendTo) {
+    fAppendTo = &appendTo;
+    fAppendToCopy = appendTo;
+}
+
+const UnicodeString &SimplePatternFormatterPlaceholderValues::get(
+        int32_t index) const {
+    if (fAppendTo == NULL || fAppendTo != fValues[index]) {
+        return *fValues[index];
+    }
+    return fAppendToCopy;
+}
+
 SimplePatternFormatter::SimplePatternFormatter() :
         noPlaceholders(),
         placeholders(),
         placeholderSize(0),
-        placeholderCount(0) {
+        placeholderCount(0),
+        firstPlaceholderReused(FALSE) {
 }
 
 SimplePatternFormatter::SimplePatternFormatter(const UnicodeString &pattern) :
         noPlaceholders(),
         placeholders(),
         placeholderSize(0),
-        placeholderCount(0) {
+        placeholderCount(0),
+        firstPlaceholderReused(FALSE) {
     UErrorCode status = U_ZERO_ERROR;
     compile(pattern, status);
 }
 
 SimplePatternFormatter::SimplePatternFormatter(
         const SimplePatternFormatter &other) :
         noPlaceholders(other.noPlaceholders),
         placeholders(),
         placeholderSize(0),
-        placeholderCount(other.placeholderCount) {
+        placeholderCount(other.placeholderCount),
+        firstPlaceholderReused(other.firstPlaceholderReused) {
     placeholderSize = ensureCapacity(other.placeholderSize);
     uprv_memcpy(
             placeholders.getAlias(),
             other.placeholders.getAlias(),
             placeholderSize * sizeof(PlaceholderInfo));
 }
 
 SimplePatternFormatter &SimplePatternFormatter::operator=(
         const SimplePatternFormatter& other) {
     if (this == &other) {
         return *this;
     }
     noPlaceholders = other.noPlaceholders;
     placeholderSize = ensureCapacity(other.placeholderSize);
     placeholderCount = other.placeholderCount;
+    firstPlaceholderReused = other.firstPlaceholderReused;
     uprv_memcpy(
             placeholders.getAlias(),
             other.placeholders.getAlias(),
             placeholderSize * sizeof(PlaceholderInfo));
     return *this;
 }
 
 SimplePatternFormatter::~SimplePatternFormatter() {
 }
 
@@ skipping 66 matching lines @@
         idBuilder.appendTo(buffer, &len);
         break;
     default:
         U_ASSERT(false);
         break;
     }
     noPlaceholders.releaseBuffer(len);
     return TRUE;
 }
 
-UBool SimplePatternFormatter::startsWithPlaceholder(int32_t id) const {
-    if (placeholderSize == 0) {
-        return FALSE;
-    }
-    return (placeholders[0].offset == 0 && placeholders[0].id == id);
-}
-
 UnicodeString& SimplePatternFormatter::format(
         const UnicodeString &arg0,
         UnicodeString &appendTo,
         UErrorCode &status) const {
     const UnicodeString *params[] = {&arg0};
-    return format(
+    return formatAndAppend(
             params,
             UPRV_LENGTHOF(params),
             appendTo,
             NULL,
             0,
             status);
 }
 
 UnicodeString& SimplePatternFormatter::format(
         const UnicodeString &arg0,
         const UnicodeString &arg1,
         UnicodeString &appendTo,
         UErrorCode &status) const {
     const UnicodeString *params[] = {&arg0, &arg1};
-    return format(
+    return formatAndAppend(
             params,
             UPRV_LENGTHOF(params),
             appendTo,
             NULL,
             0,
             status);
 }
 
 UnicodeString& SimplePatternFormatter::format(
         const UnicodeString &arg0,
         const UnicodeString &arg1,
         const UnicodeString &arg2,
         UnicodeString &appendTo,
         UErrorCode &status) const {
     const UnicodeString *params[] = {&arg0, &arg1, &arg2};
-    return format(
+    return formatAndAppend(
             params,
             UPRV_LENGTHOF(params),
             appendTo,
             NULL,
             0,
             status);
 }
 
 static void updatePlaceholderOffset(
         int32_t placeholderId,
         int32_t placeholderOffset,
         int32_t *offsetArray,
         int32_t offsetArrayLength) {
     if (placeholderId < offsetArrayLength) {
         offsetArray[placeholderId] = placeholderOffset;
     }
 }
 
 static void appendRange(
         const UnicodeString &src,
         int32_t start,
         int32_t end,
         UnicodeString &dest) {
+    // This check improves performance significantly.
+    if (start == end) {
+        return;
+    }
     dest.append(src, start, end - start);
 }
 
-UnicodeString& SimplePatternFormatter::format(
+UnicodeString& SimplePatternFormatter::formatAndAppend(
         const UnicodeString * const *placeholderValues,
         int32_t placeholderValueCount,
         UnicodeString &appendTo,
         int32_t *offsetArray,
         int32_t offsetArrayLength,
         UErrorCode &status) const {
     if (U_FAILURE(status)) {
         return appendTo;
     }
+    if (isInvalidArray(placeholderValues, placeholderValueCount)
+            || isInvalidArray(offsetArray, offsetArrayLength)) {
+        status = U_ILLEGAL_ARGUMENT_ERROR;
+        return appendTo;
+    }
     if (placeholderValueCount < placeholderCount) {
         status = U_ILLEGAL_ARGUMENT_ERROR;
         return appendTo;
     }
+    
+    // Since we are disallowing parameter values that are the same as
+    // appendTo, we have to check all placeholderValues as opposed to
+    // the first placeholderCount placeholder values.
+    SimplePatternFormatterPlaceholderValues values(
+            placeholderValues, placeholderValueCount);
+    if (values.isAppendToInAnyIndexExcept(appendTo, -1)) {
+        status = U_ILLEGAL_ARGUMENT_ERROR;
+        return appendTo;
+    }
+    return formatAndAppend(
+            values,
+            appendTo,
+            offsetArray,
+            offsetArrayLength);
+}
+
+UnicodeString& SimplePatternFormatter::formatAndReplace(
+        const UnicodeString * const *placeholderValues,
+        int32_t placeholderValueCount,
+        UnicodeString &result,
+        int32_t *offsetArray,
+        int32_t offsetArrayLength,
+        UErrorCode &status) const {
+    if (U_FAILURE(status)) {
+        return result;
+    }
+    if (isInvalidArray(placeholderValues, placeholderValueCount)
+            || isInvalidArray(offsetArray, offsetArrayLength)) {
+        status = U_ILLEGAL_ARGUMENT_ERROR;
+        return result;
+    }
+    if (placeholderValueCount < placeholderCount) {
+        status = U_ILLEGAL_ARGUMENT_ERROR;
+        return result;
+    }
+    SimplePatternFormatterPlaceholderValues values(
+            placeholderValues, placeholderCount);
+    int32_t placeholderAtStart = getUniquePlaceholderAtStart();
+
+    // If pattern starts with a unique placeholder and that placeholder
+    // value is result, we may be able to optimize by just appending to result.
+    if (placeholderAtStart >= 0
+            && placeholderValues[placeholderAtStart] == &result) {
+
+        // If result is the value for other placeholders, call off optimization.
+        if (values.isAppendToInAnyIndexExcept(result, placeholderAtStart)) {
+            values.snapshotAppendTo(result);
+            result.remove();
+            return formatAndAppend(
+                    values,
+                    result,
+                    offsetArray,
+                    offsetArrayLength);
+        }
+
+        // Otherwise we can optimize
+        formatAndAppend(
+                values,
+                result,
+                offsetArray,
+                offsetArrayLength);
+        
+        // We have to make the offset for the placeholderAtStart
+        // placeholder be 0. Otherwise it would be the length of the
+        // previous value of result.
+        if (offsetArrayLength > placeholderAtStart) {
+            offsetArray[placeholderAtStart] = 0;
+        }
+        return result;
+    }
+    if (values.isAppendToInAnyIndexExcept(result, -1)) {
+        values.snapshotAppendTo(result);
+    }
+    result.remove();
+    return formatAndAppend(
+            values,
+            result,
+            offsetArray,
+            offsetArrayLength);
+}
+
+UnicodeString& SimplePatternFormatter::formatAndAppend(
+        const SimplePatternFormatterPlaceholderValues &values,
+        UnicodeString &appendTo,
+        int32_t *offsetArray,
+        int32_t offsetArrayLength) const {
     for (int32_t i = 0; i < offsetArrayLength; ++i) {
         offsetArray[i] = -1;
     }
     if (placeholderSize == 0) {
         appendTo.append(noPlaceholders);
         return appendTo;
     }
-    if (placeholders[0].offset > 0 ||
-            placeholderValues[placeholders[0].id] != &appendTo) {
-        appendRange(
-                noPlaceholders,
-                0,
-                placeholders[0].offset,
-                appendTo);
-        updatePlaceholderOffset(
-                placeholders[0].id,
-                appendTo.length(),
-                offsetArray,
-                offsetArrayLength);
-        appendTo.append(*placeholderValues[placeholders[0].id]);
-    } else {
-        updatePlaceholderOffset(
-                placeholders[0].id,
-                0,
-                offsetArray,
-                offsetArrayLength);
+    appendRange(
+            noPlaceholders,
+            0,
+            placeholders[0].offset,
+            appendTo);
+    updatePlaceholderOffset(
+            placeholders[0].id,
+            appendTo.length(),
+            offsetArray,
+            offsetArrayLength);
+    const UnicodeString *placeholderValue = &values.get(placeholders[0].id);
+    if (placeholderValue != &appendTo) {
+        appendTo.append(*placeholderValue);
     }
     for (int32_t i = 1; i < placeholderSize; ++i) {
         appendRange(
                 noPlaceholders,
                 placeholders[i - 1].offset,
                 placeholders[i].offset,
                 appendTo);
         updatePlaceholderOffset(
                 placeholders[i].id,
                 appendTo.length(),
                 offsetArray,
                 offsetArrayLength);
-        appendTo.append(*placeholderValues[placeholders[i].id]);
+        placeholderValue = &values.get(placeholders[i].id);
+        if (placeholderValue != &appendTo) {
+            appendTo.append(*placeholderValue);
+        }
     }
     appendRange(
             noPlaceholders,
             placeholders[placeholderSize - 1].offset,
             noPlaceholders.length(),
             appendTo);
     return appendTo;
 }
 
+int32_t SimplePatternFormatter::getUniquePlaceholderAtStart() const {
+    if (placeholderSize == 0
+            || firstPlaceholderReused || placeholders[0].offset != 0) {
+        return -1;
+    }
+    return placeholders[0].id;
+}
+
 int32_t SimplePatternFormatter::ensureCapacity(
         int32_t desiredCapacity, int32_t allocationSize) {
     if (allocationSize < desiredCapacity) {
         allocationSize = desiredCapacity;
     }
     if (desiredCapacity <= placeholders.getCapacity()) {
         return desiredCapacity;
     }
     // allocate new buffer
     if (placeholders.resize(allocationSize, placeholderSize) == NULL) {
         return placeholders.getCapacity();
     }
     return desiredCapacity;
 }
 
 UBool SimplePatternFormatter::addPlaceholder(int32_t id, int32_t offset) {
     if (ensureCapacity(placeholderSize + 1, 2 * placeholderSize) < placeholderSize + 1) {
         return FALSE;
     }
     ++placeholderSize;
     PlaceholderInfo *placeholderEnd = &placeholders[placeholderSize - 1];
     placeholderEnd->offset = offset;
     placeholderEnd->id = id;
     if (id >= placeholderCount) {
         placeholderCount = id + 1;
     }
+    if (placeholderSize > 1
+            && placeholders[placeholderSize - 1].id == placeholders[0].id) {
+        firstPlaceholderReused = TRUE;
+    }
     return TRUE;
 }
     
 U_NAMESPACE_END