ICU-531.30.tar.gz

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

diff --git a/icuSources/i18n/quantityformatter.cpp b/icuSources/i18n/quantityformatter.cpp
new file mode 100644 (file)
index 0000000..4138aee
--- /dev/null
+++ b/icuSources/i18n/quantityformatter.cpp
@@ -0,0 +1,181 @@
+/*
+******************************************************************************
+* Copyright (C) 2014, International Business Machines
+* Corporation and others.  All Rights Reserved.
+******************************************************************************
+* quantityformatter.cpp
+*/
+#include "quantityformatter.h"
+#include "simplepatternformatter.h"
+#include "uassert.h"
+#include "unicode/unistr.h"
+#include "unicode/decimfmt.h"
+#include "cstring.h"
+#include "plurrule_impl.h"
+#include "unicode/plurrule.h"
+#include "charstr.h"
+#include "unicode/fmtable.h"
+#include "unicode/fieldpos.h"
+
+#define LENGTHOF(array) (int32_t)(sizeof(array) / sizeof((array)[0]))
+
+#if !UCONFIG_NO_FORMATTING
+
+U_NAMESPACE_BEGIN
+
+// other must always be first.
+static const char * const gPluralForms[] = {
+        "other", "zero", "one", "two", "few", "many"};
+
+static int32_t getPluralIndex(const char *pluralForm) {
+    int32_t len = LENGTHOF(gPluralForms);
+    for (int32_t i = 0; i < len; ++i) {
+        if (uprv_strcmp(pluralForm, gPluralForms[i]) == 0) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+QuantityFormatter::QuantityFormatter() {
+    for (int32_t i = 0; i < LENGTHOF(formatters); ++i) {
+        formatters[i] = NULL;
+    }
+}
+
+QuantityFormatter::QuantityFormatter(const QuantityFormatter &other) {
+    for (int32_t i = 0; i < LENGTHOF(formatters); ++i) {
+        if (other.formatters[i] == NULL) {
+            formatters[i] = NULL;
+        } else {
+            formatters[i] = new SimplePatternFormatter(*other.formatters[i]);
+        }
+    }
+}
+
+QuantityFormatter &QuantityFormatter::operator=(
+        const QuantityFormatter& other) {
+    if (this == &other) {
+        return *this;
+    }
+    for (int32_t i = 0; i < LENGTHOF(formatters); ++i) {
+        delete formatters[i];
+        if (other.formatters[i] == NULL) {
+            formatters[i] = NULL;
+        } else {
+            formatters[i] = new SimplePatternFormatter(*other.formatters[i]);
+        }
+    }
+    return *this;
+}
+
+QuantityFormatter::~QuantityFormatter() {
+    for (int32_t i = 0; i < LENGTHOF(formatters); ++i) {
+        delete formatters[i];
+    }
+}
+
+void QuantityFormatter::reset() {
+    for (int32_t i = 0; i < LENGTHOF(formatters); ++i) {
+        delete formatters[i];
+        formatters[i] = NULL;
+    }
+}
+
+UBool QuantityFormatter::add(
+        const char *variant,
+        const UnicodeString &rawPattern,
+        UErrorCode &status) {
+    if (U_FAILURE(status)) {
+        return FALSE;
+    }
+    int32_t pluralIndex = getPluralIndex(variant);
+    if (pluralIndex == -1) {
+        status = U_ILLEGAL_ARGUMENT_ERROR;
+        return FALSE;
+    }
+    SimplePatternFormatter *newFmt =
+            new SimplePatternFormatter(rawPattern);
+    if (newFmt == NULL) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+        return FALSE;
+    }
+    if (newFmt->getPlaceholderCount() > 1) {
+        delete newFmt;
+        status = U_ILLEGAL_ARGUMENT_ERROR;
+        return FALSE;
+    }
+    delete formatters[pluralIndex];
+    formatters[pluralIndex] = newFmt;
+    return TRUE;
+}
+
+UBool QuantityFormatter::isValid() const {
+    return formatters[0] != NULL;
+}
+
+UnicodeString &QuantityFormatter::format(
+            const Formattable& quantity,
+            const NumberFormat &fmt,
+            const PluralRules &rules,
+            UnicodeString &appendTo,
+            FieldPosition &pos,
+            UErrorCode &status) const {
+    if (U_FAILURE(status)) {
+        return appendTo;
+    }
+    UnicodeString count;
+    const DecimalFormat *decFmt = dynamic_cast<const DecimalFormat *>(&fmt);
+    if (decFmt != NULL) {
+        FixedDecimal fd = decFmt->getFixedDecimal(quantity, status);
+        if (U_FAILURE(status)) {
+            return appendTo;
+        }
+        count = rules.select(fd);
+    } else {
+        if (quantity.getType() == Formattable::kDouble) {
+            count = rules.select(quantity.getDouble());
+        } else if (quantity.getType() == Formattable::kLong) {
+            count = rules.select(quantity.getLong());
+        } else if (quantity.getType() == Formattable::kInt64) {
+            count = rules.select((double) quantity.getInt64());
+        } else {
+            status = U_ILLEGAL_ARGUMENT_ERROR;
+            return appendTo;
+        }
+    }
+    CharString buffer;
+    buffer.appendInvariantChars(count, status);
+    if (U_FAILURE(status)) {
+        return appendTo;
+    }
+    int32_t pluralIndex = getPluralIndex(buffer.data());
+    if (pluralIndex == -1) {
+        pluralIndex = 0;
+    }
+    const SimplePatternFormatter *pattern = formatters[pluralIndex];
+    if (pattern == NULL) {
+        pattern = formatters[0];
+    }
+    if (pattern == NULL) {
+        status = U_INVALID_STATE_ERROR;
+        return appendTo;
+    }
+    UnicodeString formattedNumber;
+    FieldPosition fpos(pos.getField());
+    fmt.format(quantity, formattedNumber, fpos, status);
+    const UnicodeString *params[1] = {&formattedNumber};
+    int32_t offsets[1];
+    pattern->format(params, LENGTHOF(params), appendTo, offsets, LENGTHOF(offsets), status);
+    if (offsets[0] != -1) {
+        if (fpos.getBeginIndex() != 0 || fpos.getEndIndex() != 0) {
+            pos.setBeginIndex(fpos.getBeginIndex() + offsets[0]);
+            pos.setEndIndex(fpos.getEndIndex() + offsets[0]);
+        }
+    }
+    return appendTo;
+}
+
+U_NAMESPACE_END
+
+#endif /* #if !UCONFIG_NO_FORMATTING */