1 /**
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "IntlPluralRules.h"
17 #include "IntlCommon.h"
18 #include "libpandabase/macros.h"
19 #include "stdlib_ani_helpers.h"
20
21 #include "unicode/locid.h"
22 #include "unicode/numberformatter.h"
23 #include "unicode/plurrule.h"
24
25 #include <array>
26 #include <cassert>
27 #include <sstream>
28 #include <string>
29 #include <tuple>
30
31 namespace ark::ets::stdlib::intl {
32
33 using SelectOptions = std::tuple<std::string, std::string, double, double, double, double, double>;
34
35 namespace {
36 ani_field g_localeField = nullptr;
37 ani_field g_typeField = nullptr;
38 ani_field g_minimumIntegerDigitsField = nullptr;
39 ani_field g_minimumFractionDigitsField = nullptr;
40 ani_field g_maximumFractionDigitsField = nullptr;
41 ani_field g_minimumSignificantDigitsField = nullptr;
42 ani_field g_maximumSignificantDigitsField = nullptr;
43 } // namespace
44
CollectSelectOptionsFields(ani_env * env)45 static void CollectSelectOptionsFields(ani_env *env)
46 {
47 ani_class optionsClass;
48 ANI_FATAL_IF_ERROR(env->FindClass("Lstd/core/Intl/PluralRulesSelectOptions;", &optionsClass));
49
50 ANI_FATAL_IF_ERROR(env->Class_FindField(optionsClass, "locale", &g_localeField));
51 ANI_FATAL_IF_ERROR(env->Class_FindField(optionsClass, "type", &g_typeField));
52 ANI_FATAL_IF_ERROR(env->Class_FindField(optionsClass, "minimumIntegerDigits", &g_minimumIntegerDigitsField));
53 ANI_FATAL_IF_ERROR(env->Class_FindField(optionsClass, "minimumFractionDigits", &g_minimumFractionDigitsField));
54 ANI_FATAL_IF_ERROR(env->Class_FindField(optionsClass, "maximumFractionDigits", &g_maximumFractionDigitsField));
55 ANI_FATAL_IF_ERROR(
56 env->Class_FindField(optionsClass, "minimumSignificantDigits", &g_minimumSignificantDigitsField));
57 ANI_FATAL_IF_ERROR(
58 env->Class_FindField(optionsClass, "maximumSignificantDigits", &g_maximumSignificantDigitsField));
59 }
60
61 template <typename... Args>
ThrowRangeError(ani_env * env,Args &&...args)62 static void ThrowRangeError(ani_env *env, Args &&...args)
63 {
64 std::stringstream message;
65 (message << ... << args);
66 ThrowNewError(env, "Lstd/core/RangeError;", message.str().c_str(), "Lstd/core/String;:V");
67 }
68
GetLocale(const std::string & tag)69 static icu::Locale GetLocale(const std::string &tag)
70 {
71 auto status = UErrorCode::U_ZERO_ERROR;
72 auto locale = icu::Locale::forLanguageTag(tag, status);
73 if (UNLIKELY(U_FAILURE(status))) {
74 return icu::Locale::getDefault();
75 }
76 return locale;
77 }
78
GetPluralRules(ani_env * env,const icu::Locale & locale,UPluralType pluralType)79 static std::unique_ptr<icu::PluralRules> GetPluralRules(ani_env *env, const icu::Locale &locale, UPluralType pluralType)
80 {
81 auto status = UErrorCode::U_ZERO_ERROR;
82 auto rules = std::unique_ptr<icu::PluralRules>(icu::PluralRules::forLocale(locale, pluralType, status));
83 if (UNLIKELY(U_FAILURE(status))) {
84 ThrowRangeError(env, "Error creating icu::PluralRules: ", u_errorName(status));
85 return nullptr;
86 }
87 return rules;
88 }
89
ExtractOptions(ani_env * env,ani_object options)90 static SelectOptions ExtractOptions(ani_env *env, ani_object options)
91 {
92 ani_ref localeRef;
93 ANI_FATAL_IF_ERROR(env->Object_GetField_Ref(options, g_localeField, &localeRef));
94 auto locale = ConvertFromAniString(env, reinterpret_cast<ani_string>(localeRef));
95
96 ani_ref typeRef;
97 ANI_FATAL_IF_ERROR(env->Object_GetField_Ref(options, g_typeField, &typeRef));
98 auto type = ConvertFromAniString(env, reinterpret_cast<ani_string>(typeRef));
99
100 ani_double minimumIntegerDigits;
101 ANI_FATAL_IF_ERROR(env->Object_GetField_Double(options, g_minimumIntegerDigitsField, &minimumIntegerDigits));
102
103 ani_double minimumFractionDigits;
104 ANI_FATAL_IF_ERROR(env->Object_GetField_Double(options, g_minimumFractionDigitsField, &minimumFractionDigits));
105
106 ani_double maximumFractionDigits;
107 ANI_FATAL_IF_ERROR(env->Object_GetField_Double(options, g_maximumFractionDigitsField, &maximumFractionDigits));
108
109 ani_double minimumSignificantDigits;
110 ANI_FATAL_IF_ERROR(
111 env->Object_GetField_Double(options, g_minimumSignificantDigitsField, &minimumSignificantDigits));
112
113 ani_double maximumSignificantDigits;
114 ANI_FATAL_IF_ERROR(
115 env->Object_GetField_Double(options, g_maximumSignificantDigitsField, &maximumSignificantDigits));
116
117 return {locale,
118 type,
119 minimumIntegerDigits,
120 minimumFractionDigits,
121 maximumFractionDigits,
122 minimumSignificantDigits,
123 maximumSignificantDigits};
124 }
125
IcuPluralSelect(ani_env * env,ani_class klass,ani_double value,ani_object options)126 ani_string IcuPluralSelect(ani_env *env, [[maybe_unused]] ani_class klass, ani_double value, ani_object options)
127 {
128 const auto [localeStr, typeStr, minimumIntegerDigits, minimumFractionDigits, maximumFractionDigits,
129 minimumSignificantDigits, maximumSignificantDigits] = ExtractOptions(env, options);
130
131 auto locale = GetLocale(localeStr);
132 auto type = typeStr == "ordinal" ? UPluralType::UPLURAL_TYPE_ORDINAL : UPluralType::UPLURAL_TYPE_CARDINAL;
133 auto rules = GetPluralRules(env, locale, type);
134 if (UNLIKELY(rules == nullptr)) {
135 return nullptr;
136 }
137
138 auto fractionPrecision = icu::number::Precision::minMaxFraction(minimumFractionDigits, maximumFractionDigits);
139 auto formatter = icu::number::NumberFormatter::withLocale(locale)
140 .precision(fractionPrecision)
141 .integerWidth(icu::number::IntegerWidth::zeroFillTo(minimumIntegerDigits));
142 if (minimumSignificantDigits > 0) {
143 formatter = formatter.precision(icu::number::Precision::minSignificantDigits(minimumSignificantDigits));
144 }
145 if (maximumSignificantDigits > 0) {
146 formatter = formatter.precision(icu::number::Precision::maxSignificantDigits(maximumSignificantDigits));
147 }
148 auto status = UErrorCode::U_ZERO_ERROR;
149 auto formatted = formatter.formatDouble(value, status);
150 if (UNLIKELY(U_FAILURE(status))) {
151 ThrowRangeError(env, "Failed to format value: ", u_errorName(status));
152 return nullptr;
153 }
154
155 auto category = rules->select(formatted, status);
156 if (UNLIKELY(U_FAILURE(status))) {
157 ThrowRangeError(env, "Failed to select plural rules: ", u_errorName(status));
158 return nullptr;
159 }
160
161 return UnicodeToAniStr(env, category);
162 }
163
IcuGetPluralCategories(ani_env * env,ani_class klass,ani_string localeTag,ani_string pluralType)164 ani_object IcuGetPluralCategories(ani_env *env, [[maybe_unused]] ani_class klass, ani_string localeTag,
165 ani_string pluralType)
166 {
167 auto tag = ConvertFromAniString(env, localeTag);
168 auto locale = GetLocale(tag);
169 auto type = ConvertFromAniString(env, pluralType) == "ordinal" ? UPluralType::UPLURAL_TYPE_ORDINAL
170 : UPluralType::UPLURAL_TYPE_CARDINAL;
171 auto rules = GetPluralRules(env, locale, type);
172 if (UNLIKELY(rules == nullptr)) {
173 return nullptr;
174 }
175
176 auto status = UErrorCode::U_ZERO_ERROR;
177 auto enumCategories = std::unique_ptr<icu::StringEnumeration>(rules->getKeywords(status));
178 if (UNLIKELY(U_FAILURE(status))) {
179 ThrowRangeError(env, "Failed to get plural categories: ", u_errorName(status));
180 return nullptr;
181 }
182
183 std::vector<std::string> categories;
184
185 auto category = enumCategories->snext(status);
186 if (UNLIKELY(U_FAILURE(status))) {
187 ThrowRangeError(env, "Failed to iterate plural category: ", u_errorName(status));
188 return nullptr;
189 }
190 while (category != nullptr) {
191 std::string str;
192 category->toUTF8String(str);
193 categories.push_back(str);
194
195 category = enumCategories->snext(status);
196 if (UNLIKELY(U_FAILURE(status))) {
197 ThrowRangeError(env, "Failed to iterate plural category: ", u_errorName(status));
198 return nullptr;
199 }
200 }
201
202 if (UNLIKELY(categories.empty())) {
203 ThrowRangeError(env, "No plural categories found");
204 return nullptr;
205 }
206
207 auto first = StdStrToAni(env, categories[0]);
208 ani_class stringClass;
209 ANI_FATAL_IF_ERROR(env->FindClass("Lstd/core/String;", &stringClass));
210 ani_array_ref array;
211 ANI_FATAL_IF_ERROR(env->FixedArray_New_Ref(stringClass, categories.size(), first, &array));
212 for (size_t i = 1; i < categories.size(); ++i) {
213 auto item = StdStrToAni(env, categories[i]);
214 ANI_FATAL_IF_ERROR(env->Array_Set_Ref(array, i, item));
215 }
216 return array;
217 }
218
RegisterIntlPluralRules(ani_env * env)219 ani_status RegisterIntlPluralRules(ani_env *env)
220 {
221 std::array methods = {ani_native_function {"selectDouble", "DLstd/core/Object;:Lstd/core/String;",
222 reinterpret_cast<void *>(IcuPluralSelect)},
223 ani_native_function {"getPluralCategories",
224 "Lstd/core/String;Lstd/core/String;:Lstd/core/Object;",
225 reinterpret_cast<void *>(IcuGetPluralCategories)}};
226
227 CollectSelectOptionsFields(env);
228
229 ani_class pluralRulesClass;
230 ANI_FATAL_IF_ERROR(env->FindClass("Lstd/core/Intl/PluralRules;", &pluralRulesClass));
231
232 return env->Class_BindNativeMethods(pluralRulesClass, methods.data(), methods.size());
233 }
234
235 } // namespace ark::ets::stdlib::intl
236