123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892 |
- /*
- * Copyright (c) 2021-2024, Tim Flynn <trflynn89@serenityos.org>
- *
- * SPDX-License-Identifier: BSD-2-Clause
- */
- #define AK_DONT_REPLACE_STD
- #include <AK/CharacterTypes.h>
- #include <AK/QuickSort.h>
- #include <AK/Utf8View.h>
- #include <LibUnicode/ICU.h>
- #include <LibUnicode/Locale.h>
- #include <LibUnicode/NumberFormat.h>
- #include <LibUnicode/PartitionRange.h>
- #include <math.h>
- #include <unicode/numberformatter.h>
- #include <unicode/numberrangeformatter.h>
- #include <unicode/plurrule.h>
- namespace Unicode {
- NumberFormatStyle number_format_style_from_string(StringView number_format_style)
- {
- if (number_format_style == "decimal"sv)
- return NumberFormatStyle::Decimal;
- if (number_format_style == "percent"sv)
- return NumberFormatStyle::Percent;
- if (number_format_style == "currency"sv)
- return NumberFormatStyle::Currency;
- if (number_format_style == "unit"sv)
- return NumberFormatStyle::Unit;
- VERIFY_NOT_REACHED();
- }
- StringView number_format_style_to_string(NumberFormatStyle number_format_style)
- {
- switch (number_format_style) {
- case NumberFormatStyle::Decimal:
- return "decimal"sv;
- case NumberFormatStyle::Percent:
- return "percent"sv;
- case NumberFormatStyle::Currency:
- return "currency"sv;
- case NumberFormatStyle::Unit:
- return "unit"sv;
- }
- VERIFY_NOT_REACHED();
- }
- SignDisplay sign_display_from_string(StringView sign_display)
- {
- if (sign_display == "auto"sv)
- return SignDisplay::Auto;
- if (sign_display == "never"sv)
- return SignDisplay::Never;
- if (sign_display == "always"sv)
- return SignDisplay::Always;
- if (sign_display == "exceptZero"sv)
- return SignDisplay::ExceptZero;
- if (sign_display == "negative"sv)
- return SignDisplay::Negative;
- VERIFY_NOT_REACHED();
- }
- StringView sign_display_to_string(SignDisplay sign_display)
- {
- switch (sign_display) {
- case SignDisplay::Auto:
- return "auto"sv;
- case SignDisplay::Never:
- return "never"sv;
- case SignDisplay::Always:
- return "always"sv;
- case SignDisplay::ExceptZero:
- return "exceptZero"sv;
- case SignDisplay::Negative:
- return "negative"sv;
- }
- VERIFY_NOT_REACHED();
- }
- static constexpr UNumberSignDisplay icu_sign_display(SignDisplay sign_display, Optional<CurrencySign> const& currency_sign)
- {
- switch (sign_display) {
- case SignDisplay::Auto:
- return currency_sign == CurrencySign::Standard ? UNUM_SIGN_AUTO : UNUM_SIGN_ACCOUNTING;
- case SignDisplay::Never:
- return UNUM_SIGN_NEVER;
- case SignDisplay::Always:
- return currency_sign == CurrencySign::Standard ? UNUM_SIGN_ALWAYS : UNUM_SIGN_ACCOUNTING_ALWAYS;
- case SignDisplay::ExceptZero:
- return currency_sign == CurrencySign::Standard ? UNUM_SIGN_EXCEPT_ZERO : UNUM_SIGN_ACCOUNTING_EXCEPT_ZERO;
- case SignDisplay::Negative:
- return currency_sign == CurrencySign::Standard ? UNUM_SIGN_NEGATIVE : UNUM_SIGN_ACCOUNTING_NEGATIVE;
- }
- VERIFY_NOT_REACHED();
- }
- Notation notation_from_string(StringView notation)
- {
- if (notation == "standard"sv)
- return Notation::Standard;
- if (notation == "scientific"sv)
- return Notation::Scientific;
- if (notation == "engineering"sv)
- return Notation::Engineering;
- if (notation == "compact"sv)
- return Notation::Compact;
- VERIFY_NOT_REACHED();
- }
- StringView notation_to_string(Notation notation)
- {
- switch (notation) {
- case Notation::Standard:
- return "standard"sv;
- case Notation::Scientific:
- return "scientific"sv;
- case Notation::Engineering:
- return "engineering"sv;
- case Notation::Compact:
- return "compact"sv;
- }
- VERIFY_NOT_REACHED();
- }
- static icu::number::Notation icu_notation(Notation notation, Optional<CompactDisplay> const& compact_display)
- {
- switch (notation) {
- case Notation::Standard:
- return icu::number::Notation::simple();
- case Notation::Scientific:
- return icu::number::Notation::scientific();
- case Notation::Engineering:
- return icu::number::Notation::engineering();
- case Notation::Compact:
- switch (*compact_display) {
- case CompactDisplay::Short:
- return icu::number::Notation::compactShort();
- case CompactDisplay::Long:
- return icu::number::Notation::compactLong();
- }
- }
- VERIFY_NOT_REACHED();
- }
- CompactDisplay compact_display_from_string(StringView compact_display)
- {
- if (compact_display == "short"sv)
- return CompactDisplay::Short;
- if (compact_display == "long"sv)
- return CompactDisplay::Long;
- VERIFY_NOT_REACHED();
- }
- StringView compact_display_to_string(CompactDisplay compact_display)
- {
- switch (compact_display) {
- case CompactDisplay::Short:
- return "short"sv;
- case CompactDisplay::Long:
- return "long"sv;
- }
- VERIFY_NOT_REACHED();
- }
- Grouping grouping_from_string(StringView grouping)
- {
- if (grouping == "always"sv)
- return Grouping::Always;
- if (grouping == "auto"sv)
- return Grouping::Auto;
- if (grouping == "min2"sv)
- return Grouping::Min2;
- if (grouping == "false"sv)
- return Grouping::False;
- VERIFY_NOT_REACHED();
- }
- StringView grouping_to_string(Grouping grouping)
- {
- switch (grouping) {
- case Grouping::Always:
- return "always"sv;
- case Grouping::Auto:
- return "auto"sv;
- case Grouping::Min2:
- return "min2"sv;
- case Grouping::False:
- return "false"sv;
- }
- VERIFY_NOT_REACHED();
- }
- static constexpr UNumberGroupingStrategy icu_grouping_strategy(Grouping grouping)
- {
- switch (grouping) {
- case Grouping::Always:
- return UNUM_GROUPING_ON_ALIGNED;
- case Grouping::Auto:
- return UNUM_GROUPING_AUTO;
- case Grouping::Min2:
- return UNUM_GROUPING_MIN2;
- case Grouping::False:
- return UNUM_GROUPING_OFF;
- }
- VERIFY_NOT_REACHED();
- }
- CurrencyDisplay currency_display_from_string(StringView currency_display)
- {
- if (currency_display == "code"sv)
- return CurrencyDisplay::Code;
- if (currency_display == "symbol"sv)
- return CurrencyDisplay::Symbol;
- if (currency_display == "narrowSymbol"sv)
- return CurrencyDisplay::NarrowSymbol;
- if (currency_display == "name"sv)
- return CurrencyDisplay::Name;
- VERIFY_NOT_REACHED();
- }
- StringView currency_display_to_string(CurrencyDisplay currency_display)
- {
- switch (currency_display) {
- case CurrencyDisplay::Code:
- return "code"sv;
- case CurrencyDisplay::Symbol:
- return "symbol"sv;
- case CurrencyDisplay::NarrowSymbol:
- return "narrowSymbol"sv;
- case CurrencyDisplay::Name:
- return "name"sv;
- }
- VERIFY_NOT_REACHED();
- }
- static constexpr UNumberUnitWidth icu_currency_display(CurrencyDisplay currency_display)
- {
- switch (currency_display) {
- case CurrencyDisplay::Code:
- return UNUM_UNIT_WIDTH_ISO_CODE;
- case CurrencyDisplay::Symbol:
- return UNUM_UNIT_WIDTH_SHORT;
- case CurrencyDisplay::NarrowSymbol:
- return UNUM_UNIT_WIDTH_NARROW;
- case CurrencyDisplay::Name:
- return UNUM_UNIT_WIDTH_FULL_NAME;
- }
- VERIFY_NOT_REACHED();
- }
- CurrencySign currency_sign_from_string(StringView currency_sign)
- {
- if (currency_sign == "standard"sv)
- return CurrencySign::Standard;
- if (currency_sign == "accounting"sv)
- return CurrencySign::Accounting;
- VERIFY_NOT_REACHED();
- }
- StringView currency_sign_to_string(CurrencySign currency_sign)
- {
- switch (currency_sign) {
- case CurrencySign::Standard:
- return "standard"sv;
- case CurrencySign::Accounting:
- return "accounting"sv;
- }
- VERIFY_NOT_REACHED();
- }
- RoundingType rounding_type_from_string(StringView rounding_type)
- {
- if (rounding_type == "significantDigits"sv)
- return RoundingType::SignificantDigits;
- if (rounding_type == "fractionDigits"sv)
- return RoundingType::FractionDigits;
- if (rounding_type == "morePrecision"sv)
- return RoundingType::MorePrecision;
- if (rounding_type == "lessPrecision"sv)
- return RoundingType::LessPrecision;
- VERIFY_NOT_REACHED();
- }
- StringView rounding_type_to_string(RoundingType rounding_type)
- {
- switch (rounding_type) {
- case RoundingType::SignificantDigits:
- return "significantDigits"sv;
- case RoundingType::FractionDigits:
- return "fractionDigits"sv;
- case RoundingType::MorePrecision:
- return "morePrecision"sv;
- case RoundingType::LessPrecision:
- return "lessPrecision"sv;
- }
- VERIFY_NOT_REACHED();
- }
- RoundingMode rounding_mode_from_string(StringView rounding_mode)
- {
- if (rounding_mode == "ceil"sv)
- return RoundingMode::Ceil;
- if (rounding_mode == "expand"sv)
- return RoundingMode::Expand;
- if (rounding_mode == "floor"sv)
- return RoundingMode::Floor;
- if (rounding_mode == "halfCeil"sv)
- return RoundingMode::HalfCeil;
- if (rounding_mode == "halfEven"sv)
- return RoundingMode::HalfEven;
- if (rounding_mode == "halfExpand"sv)
- return RoundingMode::HalfExpand;
- if (rounding_mode == "halfFloor"sv)
- return RoundingMode::HalfFloor;
- if (rounding_mode == "halfTrunc"sv)
- return RoundingMode::HalfTrunc;
- if (rounding_mode == "trunc"sv)
- return RoundingMode::Trunc;
- VERIFY_NOT_REACHED();
- }
- StringView rounding_mode_to_string(RoundingMode rounding_mode)
- {
- switch (rounding_mode) {
- case RoundingMode::Ceil:
- return "ceil"sv;
- case RoundingMode::Expand:
- return "expand"sv;
- case RoundingMode::Floor:
- return "floor"sv;
- case RoundingMode::HalfCeil:
- return "halfCeil"sv;
- case RoundingMode::HalfEven:
- return "halfEven"sv;
- case RoundingMode::HalfExpand:
- return "halfExpand"sv;
- case RoundingMode::HalfFloor:
- return "halfFloor"sv;
- case RoundingMode::HalfTrunc:
- return "halfTrunc"sv;
- case RoundingMode::Trunc:
- return "trunc"sv;
- }
- VERIFY_NOT_REACHED();
- }
- static constexpr UNumberFormatRoundingMode icu_rounding_mode(RoundingMode rounding_mode)
- {
- switch (rounding_mode) {
- case RoundingMode::Ceil:
- return UNUM_ROUND_CEILING;
- case RoundingMode::Expand:
- return UNUM_ROUND_UP;
- case RoundingMode::Floor:
- return UNUM_ROUND_FLOOR;
- case RoundingMode::HalfCeil:
- return UNUM_ROUND_HALF_CEILING;
- case RoundingMode::HalfEven:
- return UNUM_ROUND_HALFEVEN;
- case RoundingMode::HalfExpand:
- return UNUM_ROUND_HALFUP;
- case RoundingMode::HalfFloor:
- return UNUM_ROUND_HALF_FLOOR;
- case RoundingMode::HalfTrunc:
- return UNUM_ROUND_HALFDOWN;
- case RoundingMode::Trunc:
- return UNUM_ROUND_DOWN;
- }
- VERIFY_NOT_REACHED();
- }
- TrailingZeroDisplay trailing_zero_display_from_string(StringView trailing_zero_display)
- {
- if (trailing_zero_display == "auto"sv)
- return TrailingZeroDisplay::Auto;
- if (trailing_zero_display == "stripIfInteger"sv)
- return TrailingZeroDisplay::StripIfInteger;
- VERIFY_NOT_REACHED();
- }
- StringView trailing_zero_display_to_string(TrailingZeroDisplay trailing_zero_display)
- {
- switch (trailing_zero_display) {
- case TrailingZeroDisplay::Auto:
- return "auto"sv;
- case TrailingZeroDisplay::StripIfInteger:
- return "stripIfInteger"sv;
- }
- VERIFY_NOT_REACHED();
- }
- static constexpr UNumberTrailingZeroDisplay icu_trailing_zero_display(TrailingZeroDisplay trailing_zero_display)
- {
- switch (trailing_zero_display) {
- case TrailingZeroDisplay::Auto:
- return UNUM_TRAILING_ZERO_AUTO;
- case TrailingZeroDisplay::StripIfInteger:
- return UNUM_TRAILING_ZERO_HIDE_IF_WHOLE;
- }
- VERIFY_NOT_REACHED();
- }
- static constexpr UNumberUnitWidth icu_unit_width(Style unit_display)
- {
- switch (unit_display) {
- case Style::Long:
- return UNUM_UNIT_WIDTH_FULL_NAME;
- case Style::Short:
- return UNUM_UNIT_WIDTH_SHORT;
- case Style::Narrow:
- return UNUM_UNIT_WIDTH_NARROW;
- }
- VERIFY_NOT_REACHED();
- }
- static constexpr UPluralType icu_plural_type(PluralForm plural_form)
- {
- switch (plural_form) {
- case PluralForm::Cardinal:
- return UPluralType::UPLURAL_TYPE_CARDINAL;
- case PluralForm::Ordinal:
- return UPluralType::UPLURAL_TYPE_ORDINAL;
- }
- VERIFY_NOT_REACHED();
- }
- static void apply_display_options(icu::number::LocalizedNumberFormatter& formatter, DisplayOptions const& display_options)
- {
- UErrorCode status = U_ZERO_ERROR;
- switch (display_options.style) {
- case NumberFormatStyle::Decimal:
- break;
- case NumberFormatStyle::Percent:
- formatter = formatter.unit(icu::MeasureUnit::getPercent()).scale(icu::number::Scale::byDouble(100));
- break;
- case NumberFormatStyle::Currency:
- formatter = formatter.unit(icu::CurrencyUnit(icu_string_piece(*display_options.currency), status));
- formatter = formatter.unitWidth(icu_currency_display(*display_options.currency_display));
- VERIFY(icu_success(status));
- break;
- case NumberFormatStyle::Unit:
- formatter = formatter.unit(icu::MeasureUnit::forIdentifier(icu_string_piece(*display_options.unit), status));
- formatter = formatter.unitWidth(icu_unit_width(*display_options.unit_display));
- VERIFY(icu_success(status));
- break;
- }
- formatter = formatter.sign(icu_sign_display(display_options.sign_display, display_options.currency_sign));
- formatter = formatter.notation(icu_notation(display_options.notation, display_options.compact_display));
- formatter = formatter.grouping(icu_grouping_strategy(display_options.grouping));
- }
- static void apply_rounding_options(icu::number::LocalizedNumberFormatter& formatter, RoundingOptions const& rounding_options)
- {
- auto precision = icu::number::Precision::unlimited();
- if (rounding_options.rounding_increment == 1) {
- switch (rounding_options.type) {
- case RoundingType::SignificantDigits:
- precision = icu::number::Precision::minMaxSignificantDigits(*rounding_options.min_significant_digits, *rounding_options.max_significant_digits);
- break;
- case RoundingType::FractionDigits:
- precision = icu::number::Precision::minMaxFraction(*rounding_options.min_fraction_digits, *rounding_options.max_fraction_digits);
- break;
- case RoundingType::MorePrecision:
- precision = icu::number::Precision::minMaxFraction(*rounding_options.min_fraction_digits, *rounding_options.max_fraction_digits)
- .withSignificantDigits(*rounding_options.min_significant_digits, *rounding_options.max_significant_digits, UNUM_ROUNDING_PRIORITY_RELAXED);
- break;
- case RoundingType::LessPrecision:
- precision = icu::number::Precision::minMaxFraction(*rounding_options.min_fraction_digits, *rounding_options.max_fraction_digits)
- .withSignificantDigits(*rounding_options.min_significant_digits, *rounding_options.max_significant_digits, UNUM_ROUNDING_PRIORITY_STRICT);
- break;
- }
- } else {
- auto mantissa = rounding_options.rounding_increment;
- auto magnitude = *rounding_options.max_fraction_digits * -1;
- precision = icu::number::Precision::incrementExact(mantissa, static_cast<i16>(magnitude))
- .withMinFraction(*rounding_options.min_fraction_digits);
- }
- formatter = formatter.precision(precision.trailingZeroDisplay(icu_trailing_zero_display(rounding_options.trailing_zero_display)));
- formatter = formatter.integerWidth(icu::number::IntegerWidth::zeroFillTo(rounding_options.min_integer_digits));
- formatter = formatter.roundingMode(icu_rounding_mode(rounding_options.mode));
- }
- static constexpr StringView icu_number_format_field_to_string(i32 field, NumberFormat::Value const& value, bool is_unit)
- {
- switch (field) {
- case PartitionRange::LITERAL_FIELD:
- return "literal"sv;
- case UNUM_INTEGER_FIELD:
- if (auto const* number = value.get_pointer<double>()) {
- if (isnan(*number))
- return "nan"sv;
- if (isinf(*number))
- return "infinity"sv;
- }
- return "integer"sv;
- case UNUM_FRACTION_FIELD:
- return "fraction"sv;
- case UNUM_DECIMAL_SEPARATOR_FIELD:
- return "decimal"sv;
- case UNUM_EXPONENT_SYMBOL_FIELD:
- return "exponentSeparator"sv;
- case UNUM_EXPONENT_SIGN_FIELD:
- return "exponentMinusSign"sv;
- case UNUM_EXPONENT_FIELD:
- return "exponentInteger"sv;
- case UNUM_GROUPING_SEPARATOR_FIELD:
- return "group"sv;
- case UNUM_CURRENCY_FIELD:
- return "currency"sv;
- case UNUM_PERCENT_FIELD:
- return is_unit ? "unit"sv : "percentSign"sv;
- case UNUM_SIGN_FIELD: {
- auto is_negative = value.visit(
- [&](double number) { return signbit(number); },
- [&](String const& number) { return number.starts_with('-'); });
- return is_negative ? "minusSign"sv : "plusSign"sv;
- }
- case UNUM_MEASURE_UNIT_FIELD:
- return "unit"sv;
- case UNUM_COMPACT_FIELD:
- return "compact"sv;
- case UNUM_APPROXIMATELY_SIGN_FIELD:
- return "approximatelySign"sv;
- }
- VERIFY_NOT_REACHED();
- }
- // ICU will give us overlapping partitions, e.g. for the formatted result "1,234", we will get the following parts:
- //
- // part="," type=group start=1 end=2
- // part="1,234" type=integer start=0 end=5
- //
- // We need to massage these partitions into non-overlapping parts for ECMA-402:
- //
- // part="1" type=integer start=0 end=1
- // part="," type=group start=1 end=2
- // part="234" type=integer start=2 end=5
- static void flatten_partitions(Vector<PartitionRange>& partitions)
- {
- if (partitions.size() <= 1)
- return;
- quick_sort(partitions);
- auto subtract_range = [&](auto const& first, auto const& second) -> Vector<PartitionRange> {
- if (second.start > first.end || first.start > second.end)
- return { first };
- Vector<PartitionRange> result;
- if (second.start > first.start)
- result.empend(first.field, first.start, second.start);
- if (second.end < first.end)
- result.empend(first.field, second.end, first.end);
- return result;
- };
- for (size_t i = 0; i < partitions.size(); ++i) {
- for (size_t j = i + 1; j < partitions.size(); ++j) {
- auto& first = partitions[i];
- auto& second = partitions[j];
- auto result = subtract_range(first, second);
- if (result.is_empty()) {
- partitions.remove(i);
- --i;
- break;
- }
- first = result[0];
- if (result.size() == 2)
- partitions.insert(i + 1, result[1]);
- }
- }
- quick_sort(partitions);
- }
- class NumberFormatImpl : public NumberFormat {
- public:
- NumberFormatImpl(icu::Locale& locale, icu::number::LocalizedNumberFormatter formatter, bool is_unit)
- : m_locale(locale)
- , m_formatter(move(formatter))
- , m_is_unit(is_unit)
- {
- }
- virtual ~NumberFormatImpl() override = default;
- virtual String format(Value const& value) const override
- {
- UErrorCode status = U_ZERO_ERROR;
- auto formatted = format_impl(value);
- if (!formatted.has_value())
- return {};
- auto result = formatted->toTempString(status);
- if (icu_failure(status))
- return {};
- return icu_string_to_string(result);
- }
- virtual String format_to_decimal(Value const& value) const override
- {
- UErrorCode status = U_ZERO_ERROR;
- auto formatted = format_impl(value);
- if (!formatted.has_value())
- return {};
- auto result = formatted->toDecimalNumber<StringBuilder>(status);
- if (icu_failure(status))
- return {};
- return MUST(result.to_string());
- }
- virtual Vector<Partition> format_to_parts(Value const& value) const override
- {
- auto formatted = format_impl(value);
- if (!formatted.has_value())
- return {};
- return format_to_parts_impl(formatted, value, value);
- }
- virtual String format_range(Value const& start, Value const& end) const override
- {
- UErrorCode status = U_ZERO_ERROR;
- auto formatted = format_range_impl(start, end);
- if (!formatted.has_value())
- return {};
- auto result = formatted->toTempString(status);
- if (icu_failure(status))
- return {};
- return icu_string_to_string(result);
- }
- virtual Vector<Partition> format_range_to_parts(Value const& start, Value const& end) const override
- {
- auto formatted = format_range_impl(start, end);
- if (!formatted.has_value())
- return {};
- return format_to_parts_impl(formatted, start, end);
- }
- virtual void create_plural_rules(PluralForm plural_form) override
- {
- UErrorCode status = U_ZERO_ERROR;
- VERIFY(!m_plural_rules);
- m_plural_rules = adopt_own(*icu::PluralRules::forLocale(m_locale, icu_plural_type(plural_form), status));
- VERIFY(icu_success(status));
- }
- virtual PluralCategory select_plural(double value) const override
- {
- UErrorCode status = U_ZERO_ERROR;
- VERIFY(m_plural_rules);
- auto formatted = format_impl(value);
- if (!formatted.has_value())
- return PluralCategory::Other;
- auto result = m_plural_rules->select(*formatted, status);
- if (icu_failure(status))
- return PluralCategory::Other;
- return plural_category_from_string(icu_string_to_string(result));
- }
- virtual PluralCategory select_plural_range(double start, double end) const override
- {
- UErrorCode status = U_ZERO_ERROR;
- VERIFY(m_plural_rules);
- auto formatted = format_range_impl(start, end);
- if (!formatted.has_value())
- return PluralCategory::Other;
- auto [formatted_start, formatted_end] = formatted->getDecimalNumbers<StringBuilder>(status);
- if (icu_failure(status))
- return PluralCategory::Other;
- if (formatted_start.string_view() == formatted_end.string_view())
- return select_plural(start);
- auto result = m_plural_rules->select(*formatted, status);
- if (icu_failure(status))
- return PluralCategory::Other;
- return plural_category_from_string(icu_string_to_string(result));
- }
- virtual Vector<PluralCategory> available_plural_categories() const override
- {
- UErrorCode status = U_ZERO_ERROR;
- VERIFY(m_plural_rules);
- auto keywords = adopt_own_if_nonnull(m_plural_rules->getKeywords(status));
- if (icu_failure(status))
- return {};
- Vector<PluralCategory> result;
- while (true) {
- i32 length = 0;
- auto const* category = keywords->next(&length, status);
- if (icu_failure(status) || category == nullptr)
- break;
- result.append(plural_category_from_string({ category, static_cast<size_t>(length) }));
- }
- return result;
- }
- private:
- static icu::Formattable value_to_formattable(Value const& value)
- {
- UErrorCode status = U_ZERO_ERROR;
- auto formattable = value.visit(
- [&](double number) { return icu::Formattable { number }; },
- [&](String const& number) { return icu::Formattable(icu_string_piece(number), status); });
- VERIFY(icu_success(status));
- return formattable;
- }
- Optional<icu::number::FormattedNumber> format_impl(Value const& value) const
- {
- UErrorCode status = U_ZERO_ERROR;
- auto formatted = value.visit(
- [&](double number) {
- return m_formatter.formatDouble(number, status);
- },
- [&](String const& number) {
- return m_formatter.formatDecimal(icu_string_piece(number), status);
- });
- if (icu_failure(status))
- return {};
- return formatted;
- }
- Optional<icu::number::FormattedNumberRange> format_range_impl(Value const& start, Value const& end) const
- {
- UErrorCode status = U_ZERO_ERROR;
- if (!m_range_formatter.has_value()) {
- auto skeleton = icu::number::NumberFormatter::forSkeleton(m_formatter.toSkeleton(status), status);
- if (icu_failure(status))
- return {};
- auto formatter = icu::number::UnlocalizedNumberRangeFormatter().numberFormatterBoth(move(skeleton)).locale(m_locale);
- if (icu_failure(status))
- return {};
- m_range_formatter = move(formatter);
- }
- auto formattable_start = value_to_formattable(start);
- auto formattable_end = value_to_formattable(end);
- auto formatted = m_range_formatter->formatFormattableRange(formattable_start, formattable_end, status);
- if (icu_failure(status))
- return {};
- return formatted;
- }
- template<typename Formatted>
- Vector<Partition> format_to_parts_impl(Formatted const& formatted, Value const& start, Value const& end) const
- {
- UErrorCode status = U_ZERO_ERROR;
- auto formatted_number = formatted->toTempString(status);
- if (icu_failure(status))
- return {};
- Vector<PartitionRange> ranges;
- ranges.empend(PartitionRange::LITERAL_FIELD, 0, formatted_number.length());
- icu::ConstrainedFieldPosition position;
- Optional<PartitionRange> start_range;
- Optional<PartitionRange> end_range;
- while (static_cast<bool>(formatted->nextPosition(position, status)) && icu_success(status)) {
- if (position.getCategory() == UFIELD_CATEGORY_NUMBER_RANGE_SPAN) {
- auto& range = position.getField() == 0 ? start_range : end_range;
- range = PartitionRange { position.getField(), position.getStart(), position.getLimit() };
- } else {
- ranges.empend(position.getField(), position.getStart(), position.getLimit());
- }
- }
- flatten_partitions(ranges);
- auto apply_to_partition = [&](Partition& partition, auto field, auto index) {
- if (start_range.has_value() && start_range->contains(index)) {
- partition.type = icu_number_format_field_to_string(field, start, m_is_unit);
- partition.source = "startRange"sv;
- return;
- }
- if (end_range.has_value() && end_range->contains(index)) {
- partition.type = icu_number_format_field_to_string(field, end, m_is_unit);
- partition.source = "endRange"sv;
- return;
- }
- partition.type = icu_number_format_field_to_string(field, end, m_is_unit);
- partition.source = "shared"sv;
- };
- Vector<Partition> result;
- result.ensure_capacity(ranges.size());
- for (auto const& range : ranges) {
- auto value = formatted_number.tempSubStringBetween(range.start, range.end);
- Partition partition;
- partition.value = icu_string_to_string(value);
- apply_to_partition(partition, range.field, range.start);
- result.unchecked_append(move(partition));
- }
- return result;
- }
- icu::Locale& m_locale;
- icu::number::LocalizedNumberFormatter m_formatter;
- mutable Optional<icu::number::LocalizedNumberRangeFormatter> m_range_formatter;
- OwnPtr<icu::PluralRules> m_plural_rules;
- bool m_is_unit { false };
- };
- NonnullOwnPtr<NumberFormat> NumberFormat::create(
- StringView locale,
- StringView numbering_system,
- DisplayOptions const& display_options,
- RoundingOptions const& rounding_options)
- {
- UErrorCode status = U_ZERO_ERROR;
- auto locale_data = LocaleData::for_locale(locale);
- VERIFY(locale_data.has_value());
- auto formatter = icu::number::NumberFormatter::withLocale(locale_data->locale());
- apply_display_options(formatter, display_options);
- apply_rounding_options(formatter, rounding_options);
- if (!numbering_system.is_empty()) {
- if (auto* symbols = icu::NumberingSystem::createInstanceByName(ByteString(numbering_system).characters(), status); symbols && icu_success(status))
- formatter = formatter.adoptSymbols(symbols);
- }
- bool is_unit = display_options.style == NumberFormatStyle::Unit;
- return adopt_own(*new NumberFormatImpl(locale_data->locale(), move(formatter), is_unit));
- }
- }
|