tor-browser

quantityformatter.cpp (7733B)

---

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
******************************************************************************
* Copyright (C) 2014-2016, International Business Machines
* Corporation and others.  All Rights Reserved.
******************************************************************************
* quantityformatter.cpp
*/

#include "unicode/utypes.h"

#if !UCONFIG_NO_FORMATTING

#include "unicode/simpleformatter.h"
#include "quantityformatter.h"
#include "uassert.h"
#include "unicode/unistr.h"
#include "unicode/decimfmt.h"
#include "cstring.h"
#include "unicode/plurrule.h"
#include "charstr.h"
#include "unicode/fmtable.h"
#include "unicode/fieldpos.h"
#include "standardplural.h"
#include "uassert.h"
#include "number_decimalquantity.h"
#include "number_utypes.h"
#include "formatted_string_builder.h"

U_NAMESPACE_BEGIN

QuantityFormatter::QuantityFormatter() {
   for (int32_t i = 0; i < UPRV_LENGTHOF(formatters); ++i) {
       formatters[i] = nullptr;
   }
}

QuantityFormatter::QuantityFormatter(const QuantityFormatter &other) {
   for (int32_t i = 0; i < UPRV_LENGTHOF(formatters); ++i) {
       if (other.formatters[i] == nullptr) {
           formatters[i] = nullptr;
       } else {
           formatters[i] = new SimpleFormatter(*other.formatters[i]);
       }
   }
}

QuantityFormatter &QuantityFormatter::operator=(
       const QuantityFormatter& other) {
   if (this == &other) {
       return *this;
   }
   for (int32_t i = 0; i < UPRV_LENGTHOF(formatters); ++i) {
       delete formatters[i];
       if (other.formatters[i] == nullptr) {
           formatters[i] = nullptr;
       } else {
           formatters[i] = new SimpleFormatter(*other.formatters[i]);
       }
   }
   return *this;
}

QuantityFormatter::~QuantityFormatter() {
   for (int32_t i = 0; i < UPRV_LENGTHOF(formatters); ++i) {
       delete formatters[i];
   }
}

void QuantityFormatter::reset() {
   for (int32_t i = 0; i < UPRV_LENGTHOF(formatters); ++i) {
       delete formatters[i];
       formatters[i] = nullptr;
   }
}

UBool QuantityFormatter::addIfAbsent(
       const char *variant,
       const UnicodeString &rawPattern,
       UErrorCode &status) {
   int32_t pluralIndex = StandardPlural::indexFromString(variant, status);
   if (U_FAILURE(status)) {
       return false;
   }
   if (formatters[pluralIndex] != nullptr) {
       return true;
   }
   SimpleFormatter *newFmt = new SimpleFormatter(rawPattern, 0, 1, status);
   if (newFmt == nullptr) {
       status = U_MEMORY_ALLOCATION_ERROR;
       return false;
   }
   if (U_FAILURE(status)) {
       delete newFmt;
       return false;
   }
   formatters[pluralIndex] = newFmt;
   return true;
}

UBool QuantityFormatter::isValid() const {
   return formatters[StandardPlural::OTHER] != nullptr;
}

const SimpleFormatter *QuantityFormatter::getByVariant(
       const char *variant) const {
   U_ASSERT(isValid());
   int32_t pluralIndex = StandardPlural::indexOrOtherIndexFromString(variant);
   const SimpleFormatter *pattern = formatters[pluralIndex];
   if (pattern == nullptr) {
       pattern = formatters[StandardPlural::OTHER];
   }
   return pattern;
}

UnicodeString &QuantityFormatter::format(
           const Formattable &number,
           const NumberFormat &fmt,
           const PluralRules &rules,
           UnicodeString &appendTo,
           FieldPosition &pos,
           UErrorCode &status) const {
   UnicodeString formattedNumber;
   StandardPlural::Form p = selectPlural(number, fmt, rules, formattedNumber, pos, status);
   if (U_FAILURE(status)) {
       return appendTo;
   }
   const SimpleFormatter *pattern = formatters[p];
   if (pattern == nullptr) {
       pattern = formatters[StandardPlural::OTHER];
       if (pattern == nullptr) {
           status = U_INVALID_STATE_ERROR;
           return appendTo;
       }
   }
   return format(*pattern, formattedNumber, appendTo, pos, status);
}

// The following methods live here so that class PluralRules does not depend on number formatting,
// and the SimpleFormatter does not depend on FieldPosition.

StandardPlural::Form QuantityFormatter::selectPlural(
           const Formattable &number,
           const NumberFormat &fmt,
           const PluralRules &rules,
           UnicodeString &formattedNumber,
           FieldPosition &pos,
           UErrorCode &status) {
   if (U_FAILURE(status)) {
       return StandardPlural::OTHER;
   }
   UnicodeString pluralKeyword;
   const DecimalFormat *decFmt = dynamic_cast<const DecimalFormat *>(&fmt);
   if (decFmt != nullptr) {
       number::impl::DecimalQuantity dq;
       decFmt->formatToDecimalQuantity(number, dq, status);
       if (U_FAILURE(status)) {
           return StandardPlural::OTHER;
       }
       pluralKeyword = rules.select(dq);
       decFmt->format(number, formattedNumber, pos, status);
   } else {
       if (number.getType() == Formattable::kDouble) {
           pluralKeyword = rules.select(number.getDouble());
       } else if (number.getType() == Formattable::kLong) {
           pluralKeyword = rules.select(number.getLong());
       } else if (number.getType() == Formattable::kInt64) {
           pluralKeyword = rules.select(static_cast<double>(number.getInt64()));
       } else {
           status = U_ILLEGAL_ARGUMENT_ERROR;
           return StandardPlural::OTHER;
       }
       fmt.format(number, formattedNumber, pos, status);
   }
   return StandardPlural::orOtherFromString(pluralKeyword);
}

void QuantityFormatter::formatAndSelect(
       double quantity,
       const NumberFormat& fmt,
       const PluralRules& rules,
       FormattedStringBuilder& output,
       StandardPlural::Form& pluralForm,
       UErrorCode& status) {
   UnicodeString pluralKeyword;
   const DecimalFormat* df = dynamic_cast<const DecimalFormat*>(&fmt);
   if (df != nullptr) {
       number::impl::UFormattedNumberData fn;
       fn.quantity.setToDouble(quantity);
       const number::LocalizedNumberFormatter* lnf = df->toNumberFormatter(status);
       if (U_FAILURE(status)) {
           return;
       }
       lnf->formatImpl(&fn, status);
       if (U_FAILURE(status)) {
           return;
       }
       output = std::move(fn.getStringRef());
       pluralKeyword = rules.select(fn.quantity);
   } else {
       UnicodeString result;
       fmt.format(quantity, result, status);
       if (U_FAILURE(status)) {
           return;
       }
       // This code path is probably RBNF. Use the generic numeric field.
       output.append(result, kGeneralNumericField, status);
       if (U_FAILURE(status)) {
           return;
       }
       pluralKeyword = rules.select(quantity);
   }
   pluralForm = StandardPlural::orOtherFromString(pluralKeyword);
}

UnicodeString &QuantityFormatter::format(
           const SimpleFormatter &pattern,
           const UnicodeString &value,
           UnicodeString &appendTo,
           FieldPosition &pos,
           UErrorCode &status) {
   if (U_FAILURE(status)) {
       return appendTo;
   }
   const UnicodeString *param = &value;
   int32_t offset;
   pattern.formatAndAppend(&param, 1, appendTo, &offset, 1, status);
   if (pos.getBeginIndex() != 0 || pos.getEndIndex() != 0) {
       if (offset >= 0) {
           pos.setBeginIndex(pos.getBeginIndex() + offset);
           pos.setEndIndex(pos.getEndIndex() + offset);
       } else {
           pos.setBeginIndex(0);
           pos.setEndIndex(0);
       }
   }
   return appendTo;
}

U_NAMESPACE_END

#endif /* #if !UCONFIG_NO_FORMATTING */