Skip to main content

rustjava_runtime/classes/java/util/
locale.rs

1use core::iter;
2
3use alloc::{format, string::ToString, vec};
4
5use jvm::{Array, ClassInstanceRef, Jvm, Result, runtime::JavaLangString};
6use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
7use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
8
9use crate::{
10    RuntimeClassProto, RuntimeContext,
11    classes::java::lang::{Object, String},
12};
13
14// class java.util.Locale
15pub struct Locale;
16
17impl Locale {
18    pub fn as_proto() -> RuntimeClassProto {
19        RuntimeClassProto {
20            name: "java/util/Locale",
21            parent_class: Some("java/lang/Object"),
22            interfaces: vec!["java/lang/Cloneable", "java/io/Serializable"],
23            methods: vec![
24                JavaMethodProto::new("<clinit>", "()V", Self::clinit, MethodAccessFlags::STATIC),
25                JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init_with_language, MethodAccessFlags::PUBLIC),
26                JavaMethodProto::new(
27                    "<init>",
28                    "(Ljava/lang/String;Ljava/lang/String;)V",
29                    Self::init_with_language_country,
30                    MethodAccessFlags::PUBLIC,
31                ),
32                JavaMethodProto::new(
33                    "<init>",
34                    "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
35                    Self::init,
36                    MethodAccessFlags::PUBLIC,
37                ),
38                JavaMethodProto::new("getDefault", "()Ljava/util/Locale;", Self::get_default, MethodAccessFlags::STATIC),
39                JavaMethodProto::new("setDefault", "(Ljava/util/Locale;)V", Self::set_default, MethodAccessFlags::STATIC),
40                JavaMethodProto::new(
41                    "getAvailableLocales",
42                    "()[Ljava/util/Locale;",
43                    Self::get_available_locales,
44                    MethodAccessFlags::STATIC,
45                ),
46                JavaMethodProto::new(
47                    "getISOCountries",
48                    "()[Ljava/lang/String;",
49                    Self::get_iso_countries,
50                    MethodAccessFlags::STATIC,
51                ),
52                JavaMethodProto::new(
53                    "getISOLanguages",
54                    "()[Ljava/lang/String;",
55                    Self::get_iso_languages,
56                    MethodAccessFlags::STATIC,
57                ),
58                JavaMethodProto::new("getLanguage", "()Ljava/lang/String;", Self::get_language, MethodAccessFlags::PUBLIC),
59                JavaMethodProto::new("getCountry", "()Ljava/lang/String;", Self::get_country, MethodAccessFlags::PUBLIC),
60                JavaMethodProto::new("getVariant", "()Ljava/lang/String;", Self::get_variant, MethodAccessFlags::PUBLIC),
61                JavaMethodProto::new(
62                    "getISO3Language",
63                    "()Ljava/lang/String;",
64                    Self::get_iso3_language,
65                    MethodAccessFlags::PUBLIC,
66                ),
67                JavaMethodProto::new(
68                    "getISO3Country",
69                    "()Ljava/lang/String;",
70                    Self::get_iso3_country,
71                    MethodAccessFlags::PUBLIC,
72                ),
73                JavaMethodProto::new(
74                    "getDisplayLanguage",
75                    "()Ljava/lang/String;",
76                    Self::get_display_language_default,
77                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
78                ),
79                JavaMethodProto::new(
80                    "getDisplayLanguage",
81                    "(Ljava/util/Locale;)Ljava/lang/String;",
82                    Self::get_display_language,
83                    MethodAccessFlags::PUBLIC,
84                ),
85                JavaMethodProto::new(
86                    "getDisplayCountry",
87                    "()Ljava/lang/String;",
88                    Self::get_display_country_default,
89                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
90                ),
91                JavaMethodProto::new(
92                    "getDisplayCountry",
93                    "(Ljava/util/Locale;)Ljava/lang/String;",
94                    Self::get_display_country,
95                    MethodAccessFlags::PUBLIC,
96                ),
97                JavaMethodProto::new(
98                    "getDisplayVariant",
99                    "()Ljava/lang/String;",
100                    Self::get_display_variant_default,
101                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
102                ),
103                JavaMethodProto::new(
104                    "getDisplayVariant",
105                    "(Ljava/util/Locale;)Ljava/lang/String;",
106                    Self::get_display_variant,
107                    MethodAccessFlags::PUBLIC,
108                ),
109                JavaMethodProto::new(
110                    "getDisplayName",
111                    "()Ljava/lang/String;",
112                    Self::get_display_name_default,
113                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
114                ),
115                JavaMethodProto::new(
116                    "getDisplayName",
117                    "(Ljava/util/Locale;)Ljava/lang/String;",
118                    Self::get_display_name,
119                    MethodAccessFlags::PUBLIC,
120                ),
121                JavaMethodProto::new("equals", "(Ljava/lang/Object;)Z", Self::equals, MethodAccessFlags::PUBLIC),
122                JavaMethodProto::new("hashCode", "()I", Self::hash_code, MethodAccessFlags::PUBLIC),
123                JavaMethodProto::new("clone", "()Ljava/lang/Object;", Self::clone, MethodAccessFlags::PUBLIC),
124                JavaMethodProto::new(
125                    "toString",
126                    "()Ljava/lang/String;",
127                    Self::to_string,
128                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
129                ),
130            ],
131            fields: vec![
132                JavaFieldProto::new(
133                    "ENGLISH",
134                    "Ljava/util/Locale;",
135                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
136                ),
137                JavaFieldProto::new(
138                    "FRENCH",
139                    "Ljava/util/Locale;",
140                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
141                ),
142                JavaFieldProto::new(
143                    "GERMAN",
144                    "Ljava/util/Locale;",
145                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
146                ),
147                JavaFieldProto::new(
148                    "ITALIAN",
149                    "Ljava/util/Locale;",
150                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
151                ),
152                JavaFieldProto::new(
153                    "JAPANESE",
154                    "Ljava/util/Locale;",
155                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
156                ),
157                JavaFieldProto::new(
158                    "KOREAN",
159                    "Ljava/util/Locale;",
160                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
161                ),
162                JavaFieldProto::new(
163                    "CHINESE",
164                    "Ljava/util/Locale;",
165                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
166                ),
167                JavaFieldProto::new(
168                    "SIMPLIFIED_CHINESE",
169                    "Ljava/util/Locale;",
170                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
171                ),
172                JavaFieldProto::new(
173                    "TRADITIONAL_CHINESE",
174                    "Ljava/util/Locale;",
175                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
176                ),
177                JavaFieldProto::new(
178                    "FRANCE",
179                    "Ljava/util/Locale;",
180                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
181                ),
182                JavaFieldProto::new(
183                    "GERMANY",
184                    "Ljava/util/Locale;",
185                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
186                ),
187                JavaFieldProto::new(
188                    "ITALY",
189                    "Ljava/util/Locale;",
190                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
191                ),
192                JavaFieldProto::new(
193                    "JAPAN",
194                    "Ljava/util/Locale;",
195                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
196                ),
197                JavaFieldProto::new(
198                    "KOREA",
199                    "Ljava/util/Locale;",
200                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
201                ),
202                JavaFieldProto::new(
203                    "CHINA",
204                    "Ljava/util/Locale;",
205                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
206                ),
207                JavaFieldProto::new(
208                    "PRC",
209                    "Ljava/util/Locale;",
210                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
211                ),
212                JavaFieldProto::new(
213                    "TAIWAN",
214                    "Ljava/util/Locale;",
215                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
216                ),
217                JavaFieldProto::new(
218                    "UK",
219                    "Ljava/util/Locale;",
220                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
221                ),
222                JavaFieldProto::new(
223                    "US",
224                    "Ljava/util/Locale;",
225                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
226                ),
227                JavaFieldProto::new(
228                    "CANADA",
229                    "Ljava/util/Locale;",
230                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
231                ),
232                JavaFieldProto::new(
233                    "CANADA_FRENCH",
234                    "Ljava/util/Locale;",
235                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
236                ),
237                JavaFieldProto::new(
238                    "defaultLocale",
239                    "Ljava/util/Locale;",
240                    FieldAccessFlags::PRIVATE | FieldAccessFlags::STATIC,
241                ),
242                JavaFieldProto::new("language", "Ljava/lang/String;", FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL),
243                JavaFieldProto::new("country", "Ljava/lang/String;", FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL),
244                JavaFieldProto::new("variant", "Ljava/lang/String;", FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL),
245            ],
246            access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::FINAL,
247        }
248    }
249
250    async fn clinit(jvm: &Jvm, _: &mut RuntimeContext) -> Result<()> {
251        tracing::debug!("java.util.Locale::<clinit>()");
252
253        let english = jvm
254            .new_class(
255                "java/util/Locale",
256                "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
257                (
258                    JavaLangString::from_rust_string(jvm, "en").await?,
259                    JavaLangString::from_rust_string(jvm, "").await?,
260                    JavaLangString::from_rust_string(jvm, "").await?,
261                ),
262            )
263            .await?;
264        jvm.put_static_field("java/util/Locale", "ENGLISH", "Ljava/util/Locale;", english).await?;
265
266        let french = jvm
267            .new_class(
268                "java/util/Locale",
269                "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
270                (
271                    JavaLangString::from_rust_string(jvm, "fr").await?,
272                    JavaLangString::from_rust_string(jvm, "").await?,
273                    JavaLangString::from_rust_string(jvm, "").await?,
274                ),
275            )
276            .await?;
277        jvm.put_static_field("java/util/Locale", "FRENCH", "Ljava/util/Locale;", french).await?;
278
279        let german = jvm
280            .new_class(
281                "java/util/Locale",
282                "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
283                (
284                    JavaLangString::from_rust_string(jvm, "de").await?,
285                    JavaLangString::from_rust_string(jvm, "").await?,
286                    JavaLangString::from_rust_string(jvm, "").await?,
287                ),
288            )
289            .await?;
290        jvm.put_static_field("java/util/Locale", "GERMAN", "Ljava/util/Locale;", german).await?;
291
292        let italian = jvm
293            .new_class(
294                "java/util/Locale",
295                "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
296                (
297                    JavaLangString::from_rust_string(jvm, "it").await?,
298                    JavaLangString::from_rust_string(jvm, "").await?,
299                    JavaLangString::from_rust_string(jvm, "").await?,
300                ),
301            )
302            .await?;
303        jvm.put_static_field("java/util/Locale", "ITALIAN", "Ljava/util/Locale;", italian).await?;
304
305        let japanese = jvm
306            .new_class(
307                "java/util/Locale",
308                "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
309                (
310                    JavaLangString::from_rust_string(jvm, "ja").await?,
311                    JavaLangString::from_rust_string(jvm, "").await?,
312                    JavaLangString::from_rust_string(jvm, "").await?,
313                ),
314            )
315            .await?;
316        jvm.put_static_field("java/util/Locale", "JAPANESE", "Ljava/util/Locale;", japanese)
317            .await?;
318
319        let korean = jvm
320            .new_class(
321                "java/util/Locale",
322                "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
323                (
324                    JavaLangString::from_rust_string(jvm, "ko").await?,
325                    JavaLangString::from_rust_string(jvm, "").await?,
326                    JavaLangString::from_rust_string(jvm, "").await?,
327                ),
328            )
329            .await?;
330        jvm.put_static_field("java/util/Locale", "KOREAN", "Ljava/util/Locale;", korean).await?;
331
332        let chinese = jvm
333            .new_class(
334                "java/util/Locale",
335                "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
336                (
337                    JavaLangString::from_rust_string(jvm, "zh").await?,
338                    JavaLangString::from_rust_string(jvm, "").await?,
339                    JavaLangString::from_rust_string(jvm, "").await?,
340                ),
341            )
342            .await?;
343        jvm.put_static_field("java/util/Locale", "CHINESE", "Ljava/util/Locale;", chinese).await?;
344
345        let simplified_chinese = jvm
346            .new_class(
347                "java/util/Locale",
348                "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
349                (
350                    JavaLangString::from_rust_string(jvm, "zh").await?,
351                    JavaLangString::from_rust_string(jvm, "CN").await?,
352                    JavaLangString::from_rust_string(jvm, "").await?,
353                ),
354            )
355            .await?;
356        jvm.put_static_field("java/util/Locale", "SIMPLIFIED_CHINESE", "Ljava/util/Locale;", simplified_chinese.clone())
357            .await?;
358
359        let traditional_chinese = jvm
360            .new_class(
361                "java/util/Locale",
362                "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
363                (
364                    JavaLangString::from_rust_string(jvm, "zh").await?,
365                    JavaLangString::from_rust_string(jvm, "TW").await?,
366                    JavaLangString::from_rust_string(jvm, "").await?,
367                ),
368            )
369            .await?;
370        jvm.put_static_field(
371            "java/util/Locale",
372            "TRADITIONAL_CHINESE",
373            "Ljava/util/Locale;",
374            traditional_chinese.clone(),
375        )
376        .await?;
377
378        let france = jvm
379            .new_class(
380                "java/util/Locale",
381                "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
382                (
383                    JavaLangString::from_rust_string(jvm, "fr").await?,
384                    JavaLangString::from_rust_string(jvm, "FR").await?,
385                    JavaLangString::from_rust_string(jvm, "").await?,
386                ),
387            )
388            .await?;
389        jvm.put_static_field("java/util/Locale", "FRANCE", "Ljava/util/Locale;", france).await?;
390
391        let germany = jvm
392            .new_class(
393                "java/util/Locale",
394                "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
395                (
396                    JavaLangString::from_rust_string(jvm, "de").await?,
397                    JavaLangString::from_rust_string(jvm, "DE").await?,
398                    JavaLangString::from_rust_string(jvm, "").await?,
399                ),
400            )
401            .await?;
402        jvm.put_static_field("java/util/Locale", "GERMANY", "Ljava/util/Locale;", germany).await?;
403
404        let italy = jvm
405            .new_class(
406                "java/util/Locale",
407                "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
408                (
409                    JavaLangString::from_rust_string(jvm, "it").await?,
410                    JavaLangString::from_rust_string(jvm, "IT").await?,
411                    JavaLangString::from_rust_string(jvm, "").await?,
412                ),
413            )
414            .await?;
415        jvm.put_static_field("java/util/Locale", "ITALY", "Ljava/util/Locale;", italy).await?;
416
417        let japan = jvm
418            .new_class(
419                "java/util/Locale",
420                "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
421                (
422                    JavaLangString::from_rust_string(jvm, "ja").await?,
423                    JavaLangString::from_rust_string(jvm, "JP").await?,
424                    JavaLangString::from_rust_string(jvm, "").await?,
425                ),
426            )
427            .await?;
428        jvm.put_static_field("java/util/Locale", "JAPAN", "Ljava/util/Locale;", japan).await?;
429
430        let korea = jvm
431            .new_class(
432                "java/util/Locale",
433                "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
434                (
435                    JavaLangString::from_rust_string(jvm, "ko").await?,
436                    JavaLangString::from_rust_string(jvm, "KR").await?,
437                    JavaLangString::from_rust_string(jvm, "").await?,
438                ),
439            )
440            .await?;
441        jvm.put_static_field("java/util/Locale", "KOREA", "Ljava/util/Locale;", korea).await?;
442
443        let uk = jvm
444            .new_class(
445                "java/util/Locale",
446                "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
447                (
448                    JavaLangString::from_rust_string(jvm, "en").await?,
449                    JavaLangString::from_rust_string(jvm, "GB").await?,
450                    JavaLangString::from_rust_string(jvm, "").await?,
451                ),
452            )
453            .await?;
454        jvm.put_static_field("java/util/Locale", "UK", "Ljava/util/Locale;", uk).await?;
455
456        let us = jvm
457            .new_class(
458                "java/util/Locale",
459                "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
460                (
461                    JavaLangString::from_rust_string(jvm, "en").await?,
462                    JavaLangString::from_rust_string(jvm, "US").await?,
463                    JavaLangString::from_rust_string(jvm, "").await?,
464                ),
465            )
466            .await?;
467        jvm.put_static_field("java/util/Locale", "US", "Ljava/util/Locale;", us.clone()).await?;
468
469        let canada = jvm
470            .new_class(
471                "java/util/Locale",
472                "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
473                (
474                    JavaLangString::from_rust_string(jvm, "en").await?,
475                    JavaLangString::from_rust_string(jvm, "CA").await?,
476                    JavaLangString::from_rust_string(jvm, "").await?,
477                ),
478            )
479            .await?;
480        jvm.put_static_field("java/util/Locale", "CANADA", "Ljava/util/Locale;", canada).await?;
481
482        let canada_french = jvm
483            .new_class(
484                "java/util/Locale",
485                "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
486                (
487                    JavaLangString::from_rust_string(jvm, "fr").await?,
488                    JavaLangString::from_rust_string(jvm, "CA").await?,
489                    JavaLangString::from_rust_string(jvm, "").await?,
490                ),
491            )
492            .await?;
493        jvm.put_static_field("java/util/Locale", "CANADA_FRENCH", "Ljava/util/Locale;", canada_french)
494            .await?;
495
496        jvm.put_static_field("java/util/Locale", "CHINA", "Ljava/util/Locale;", simplified_chinese.clone())
497            .await?;
498        jvm.put_static_field("java/util/Locale", "PRC", "Ljava/util/Locale;", simplified_chinese)
499            .await?;
500        jvm.put_static_field("java/util/Locale", "TAIWAN", "Ljava/util/Locale;", traditional_chinese)
501            .await?;
502        jvm.put_static_field("java/util/Locale", "defaultLocale", "Ljava/util/Locale;", us)
503            .await?;
504
505        Ok(())
506    }
507
508    async fn init_with_language(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, language: ClassInstanceRef<String>) -> Result<()> {
509        tracing::debug!("java.util.Locale::<init>({this:?}, {language:?})");
510
511        let country: ClassInstanceRef<String> = JavaLangString::from_rust_string(jvm, "").await?.into();
512        let variant: ClassInstanceRef<String> = JavaLangString::from_rust_string(jvm, "").await?.into();
513        jvm.invoke_special(
514            &this,
515            "java/util/Locale",
516            "<init>",
517            "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
518            (language, country, variant),
519        )
520        .await
521    }
522
523    async fn init_with_language_country(
524        jvm: &Jvm,
525        _: &mut RuntimeContext,
526        this: ClassInstanceRef<Self>,
527        language: ClassInstanceRef<String>,
528        country: ClassInstanceRef<String>,
529    ) -> Result<()> {
530        tracing::debug!("java.util.Locale::<init>({this:?}, {language:?}, {country:?})");
531
532        let variant: ClassInstanceRef<String> = JavaLangString::from_rust_string(jvm, "").await?.into();
533        jvm.invoke_special(
534            &this,
535            "java/util/Locale",
536            "<init>",
537            "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
538            (language, country, variant),
539        )
540        .await
541    }
542
543    async fn init(
544        jvm: &Jvm,
545        _: &mut RuntimeContext,
546        mut this: ClassInstanceRef<Self>,
547        language: ClassInstanceRef<String>,
548        country: ClassInstanceRef<String>,
549        variant: ClassInstanceRef<String>,
550    ) -> Result<()> {
551        tracing::debug!("java.util.Locale::<init>({this:?}, {language:?}, {country:?}, {variant:?})");
552
553        if language.is_null() || country.is_null() || variant.is_null() {
554            return Err(jvm.exception("java/lang/NullPointerException", "Locale component is null").await);
555        }
556
557        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
558
559        let language = JavaLangString::to_rust_string(jvm, &language).await?.to_ascii_lowercase();
560        let country = JavaLangString::to_rust_string(jvm, &country).await?.to_ascii_uppercase();
561        let variant = JavaLangString::to_rust_string(jvm, &variant).await?;
562
563        let language = JavaLangString::from_rust_string(jvm, &language).await?;
564        let country = JavaLangString::from_rust_string(jvm, &country).await?;
565        let variant = JavaLangString::from_rust_string(jvm, &variant).await?;
566
567        jvm.put_field(&mut this, "java/util/Locale", "language", "Ljava/lang/String;", language)
568            .await?;
569        jvm.put_field(&mut this, "java/util/Locale", "country", "Ljava/lang/String;", country)
570            .await?;
571        jvm.put_field(&mut this, "java/util/Locale", "variant", "Ljava/lang/String;", variant)
572            .await?;
573
574        Ok(())
575    }
576
577    async fn get_default(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Self>> {
578        tracing::debug!("java.util.Locale::getDefault()");
579
580        jvm.get_static_field("java/util/Locale", "defaultLocale", "Ljava/util/Locale;").await
581    }
582
583    async fn set_default(jvm: &Jvm, _: &mut RuntimeContext, locale: ClassInstanceRef<Self>) -> Result<()> {
584        tracing::debug!("java.util.Locale::setDefault({locale:?})");
585
586        if locale.is_null() {
587            return Err(jvm.exception("java/lang/NullPointerException", "Locale default is null").await);
588        }
589
590        jvm.put_static_field("java/util/Locale", "defaultLocale", "Ljava/util/Locale;", locale)
591            .await
592    }
593
594    async fn get_available_locales(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Array<Self>>> {
595        tracing::debug!("java.util.Locale::getAvailableLocales()");
596
597        let fields = [
598            "ENGLISH",
599            "FRENCH",
600            "GERMAN",
601            "ITALIAN",
602            "JAPANESE",
603            "KOREAN",
604            "CHINESE",
605            "SIMPLIFIED_CHINESE",
606            "TRADITIONAL_CHINESE",
607            "FRANCE",
608            "GERMANY",
609            "ITALY",
610            "JAPAN",
611            "KOREA",
612            "CHINA",
613            "PRC",
614            "TAIWAN",
615            "UK",
616            "US",
617            "CANADA",
618            "CANADA_FRENCH",
619        ];
620        let mut array: ClassInstanceRef<Array<Self>> = jvm.instantiate_array("Ljava/util/Locale;", fields.len()).await?.into();
621
622        for (i, field) in fields.iter().enumerate() {
623            let locale: ClassInstanceRef<Self> = jvm.get_static_field("java/util/Locale", field, "Ljava/util/Locale;").await?;
624            jvm.store_array(&mut array, i, iter::once(locale)).await?;
625        }
626
627        Ok(array)
628    }
629
630    async fn get_iso_countries(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Array<String>>> {
631        tracing::debug!("java.util.Locale::getISOCountries()");
632
633        Self::string_array(jvm, &["US", "GB", "CA", "FR", "DE", "IT", "JP", "KR", "CN", "TW"]).await
634    }
635
636    async fn get_iso_languages(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Array<String>>> {
637        tracing::debug!("java.util.Locale::getISOLanguages()");
638
639        Self::string_array(jvm, &["en", "fr", "de", "it", "ja", "ko", "zh"]).await
640    }
641
642    async fn string_array(jvm: &Jvm, values: &[&str]) -> Result<ClassInstanceRef<Array<String>>> {
643        let mut array: ClassInstanceRef<Array<String>> = jvm.instantiate_array("Ljava/lang/String;", values.len()).await?.into();
644        for (i, value) in values.iter().enumerate() {
645            let value: ClassInstanceRef<String> = JavaLangString::from_rust_string(jvm, value).await?.into();
646            jvm.store_array(&mut array, i, iter::once(value)).await?;
647        }
648        Ok(array)
649    }
650
651    async fn get_language(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
652        tracing::debug!("java.util.Locale::getLanguage({this:?})");
653
654        jvm.get_field(&this, "java/util/Locale", "language", "Ljava/lang/String;").await
655    }
656
657    async fn get_country(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
658        tracing::debug!("java.util.Locale::getCountry({this:?})");
659
660        jvm.get_field(&this, "java/util/Locale", "country", "Ljava/lang/String;").await
661    }
662
663    async fn get_variant(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
664        tracing::debug!("java.util.Locale::getVariant({this:?})");
665
666        jvm.get_field(&this, "java/util/Locale", "variant", "Ljava/lang/String;").await
667    }
668
669    async fn get_iso3_language(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
670        tracing::debug!("java.util.Locale::getISO3Language({this:?})");
671
672        let language: ClassInstanceRef<String> = jvm.get_field(&this, "java/util/Locale", "language", "Ljava/lang/String;").await?;
673        let language = JavaLangString::to_rust_string(jvm, &language).await?;
674        let iso3 = match language.as_str() {
675            "" => "",
676            "en" => "eng",
677            "fr" => "fra",
678            "de" => "deu",
679            "it" => "ita",
680            "ja" => "jpn",
681            "ko" => "kor",
682            "zh" => "zho",
683            _ => return Err(jvm.exception("java/lang/IllegalArgumentException", "Unsupported ISO3 language").await),
684        };
685
686        Ok(JavaLangString::from_rust_string(jvm, iso3).await?.into())
687    }
688
689    async fn get_iso3_country(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
690        tracing::debug!("java.util.Locale::getISO3Country({this:?})");
691
692        let country: ClassInstanceRef<String> = jvm.get_field(&this, "java/util/Locale", "country", "Ljava/lang/String;").await?;
693        let country = JavaLangString::to_rust_string(jvm, &country).await?;
694        let iso3 = match country.as_str() {
695            "" => "",
696            "US" => "USA",
697            "GB" => "GBR",
698            "CA" => "CAN",
699            "FR" => "FRA",
700            "DE" => "DEU",
701            "IT" => "ITA",
702            "JP" => "JPN",
703            "KR" => "KOR",
704            "CN" => "CHN",
705            "TW" => "TWN",
706            _ => return Err(jvm.exception("java/lang/IllegalArgumentException", "Unsupported ISO3 country").await),
707        };
708
709        Ok(JavaLangString::from_rust_string(jvm, iso3).await?.into())
710    }
711
712    async fn get_display_language_default(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
713        let default = Self::get_default(jvm, context).await?;
714        Self::get_display_language(jvm, context, this, default).await
715    }
716
717    async fn get_display_language(
718        jvm: &Jvm,
719        _: &mut RuntimeContext,
720        this: ClassInstanceRef<Self>,
721        display_locale: ClassInstanceRef<Self>,
722    ) -> Result<ClassInstanceRef<String>> {
723        tracing::debug!("java.util.Locale::getDisplayLanguage({this:?})");
724
725        if display_locale.is_null() {
726            return Err(jvm.exception("java/lang/NullPointerException", "display locale is null").await);
727        }
728
729        let language: ClassInstanceRef<String> = jvm.get_field(&this, "java/util/Locale", "language", "Ljava/lang/String;").await?;
730        let language = JavaLangString::to_rust_string(jvm, &language).await?;
731
732        Ok(JavaLangString::from_rust_string(jvm, Self::display_language(&language)).await?.into())
733    }
734
735    async fn get_display_country_default(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
736        let default = Self::get_default(jvm, context).await?;
737        Self::get_display_country(jvm, context, this, default).await
738    }
739
740    async fn get_display_country(
741        jvm: &Jvm,
742        _: &mut RuntimeContext,
743        this: ClassInstanceRef<Self>,
744        display_locale: ClassInstanceRef<Self>,
745    ) -> Result<ClassInstanceRef<String>> {
746        tracing::debug!("java.util.Locale::getDisplayCountry({this:?})");
747
748        if display_locale.is_null() {
749            return Err(jvm.exception("java/lang/NullPointerException", "display locale is null").await);
750        }
751
752        let country: ClassInstanceRef<String> = jvm.get_field(&this, "java/util/Locale", "country", "Ljava/lang/String;").await?;
753        let country = JavaLangString::to_rust_string(jvm, &country).await?;
754
755        Ok(JavaLangString::from_rust_string(jvm, Self::display_country(&country)).await?.into())
756    }
757
758    async fn get_display_variant_default(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
759        let default = Self::get_default(jvm, context).await?;
760        Self::get_display_variant(jvm, context, this, default).await
761    }
762
763    async fn get_display_variant(
764        jvm: &Jvm,
765        _: &mut RuntimeContext,
766        this: ClassInstanceRef<Self>,
767        display_locale: ClassInstanceRef<Self>,
768    ) -> Result<ClassInstanceRef<String>> {
769        tracing::debug!("java.util.Locale::getDisplayVariant({this:?})");
770
771        if display_locale.is_null() {
772            return Err(jvm.exception("java/lang/NullPointerException", "display locale is null").await);
773        }
774
775        jvm.get_field(&this, "java/util/Locale", "variant", "Ljava/lang/String;").await
776    }
777
778    async fn get_display_name_default(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
779        let default = Self::get_default(jvm, context).await?;
780        Self::get_display_name(jvm, context, this, default).await
781    }
782
783    async fn get_display_name(
784        jvm: &Jvm,
785        _: &mut RuntimeContext,
786        this: ClassInstanceRef<Self>,
787        display_locale: ClassInstanceRef<Self>,
788    ) -> Result<ClassInstanceRef<String>> {
789        tracing::debug!("java.util.Locale::getDisplayName({this:?})");
790
791        if display_locale.is_null() {
792            return Err(jvm.exception("java/lang/NullPointerException", "display locale is null").await);
793        }
794
795        let language: ClassInstanceRef<String> = jvm.get_field(&this, "java/util/Locale", "language", "Ljava/lang/String;").await?;
796        let country: ClassInstanceRef<String> = jvm.get_field(&this, "java/util/Locale", "country", "Ljava/lang/String;").await?;
797        let variant: ClassInstanceRef<String> = jvm.get_field(&this, "java/util/Locale", "variant", "Ljava/lang/String;").await?;
798
799        let language = JavaLangString::to_rust_string(jvm, &language).await?;
800        let country = JavaLangString::to_rust_string(jvm, &country).await?;
801        let variant = JavaLangString::to_rust_string(jvm, &variant).await?;
802
803        let language = Self::display_language(&language);
804        let country = Self::display_country(&country);
805
806        let result = if language.is_empty() {
807            if country.is_empty() {
808                variant
809            } else if variant.is_empty() {
810                country.to_string()
811            } else {
812                format!("{country} ({variant})")
813            }
814        } else if country.is_empty() && variant.is_empty() {
815            language.to_string()
816        } else {
817            let mut suffixes = vec![];
818            if !country.is_empty() {
819                suffixes.push(country.to_string());
820            }
821            if !variant.is_empty() {
822                suffixes.push(variant);
823            }
824            format!("{language} ({})", suffixes.join(", "))
825        };
826
827        Ok(JavaLangString::from_rust_string(jvm, &result).await?.into())
828    }
829
830    fn display_language(language: &str) -> &str {
831        match language {
832            "en" => "English",
833            "fr" => "French",
834            "de" => "German",
835            "it" => "Italian",
836            "ja" => "Japanese",
837            "ko" => "Korean",
838            "zh" => "Chinese",
839            _ => language,
840        }
841    }
842
843    fn display_country(country: &str) -> &str {
844        match country {
845            "US" => "United States",
846            "GB" => "United Kingdom",
847            "CA" => "Canada",
848            "FR" => "France",
849            "DE" => "Germany",
850            "IT" => "Italy",
851            "JP" => "Japan",
852            "KR" => "South Korea",
853            "CN" => "China",
854            "TW" => "Taiwan",
855            _ => country,
856        }
857    }
858
859    async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<bool> {
860        tracing::debug!("java.util.Locale::equals({this:?}, {other:?})");
861
862        if other.is_null() || !jvm.is_instance(&**other, "java/util/Locale") {
863            return Ok(false);
864        }
865
866        let other: ClassInstanceRef<Self> = ClassInstanceRef::new(other.instance);
867
868        let this_language: ClassInstanceRef<String> = jvm.get_field(&this, "java/util/Locale", "language", "Ljava/lang/String;").await?;
869        let this_country: ClassInstanceRef<String> = jvm.get_field(&this, "java/util/Locale", "country", "Ljava/lang/String;").await?;
870        let this_variant: ClassInstanceRef<String> = jvm.get_field(&this, "java/util/Locale", "variant", "Ljava/lang/String;").await?;
871        let other_language: ClassInstanceRef<String> = jvm.get_field(&other, "java/util/Locale", "language", "Ljava/lang/String;").await?;
872        let other_country: ClassInstanceRef<String> = jvm.get_field(&other, "java/util/Locale", "country", "Ljava/lang/String;").await?;
873        let other_variant: ClassInstanceRef<String> = jvm.get_field(&other, "java/util/Locale", "variant", "Ljava/lang/String;").await?;
874
875        let this_language = JavaLangString::to_rust_string(jvm, &this_language).await?;
876        let this_country = JavaLangString::to_rust_string(jvm, &this_country).await?;
877        let this_variant = JavaLangString::to_rust_string(jvm, &this_variant).await?;
878        let other_language = JavaLangString::to_rust_string(jvm, &other_language).await?;
879        let other_country = JavaLangString::to_rust_string(jvm, &other_country).await?;
880        let other_variant = JavaLangString::to_rust_string(jvm, &other_variant).await?;
881
882        Ok(this_language == other_language && this_country == other_country && this_variant == other_variant)
883    }
884
885    async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
886        tracing::debug!("java.util.Locale::hashCode({this:?})");
887
888        let language: ClassInstanceRef<String> = jvm.get_field(&this, "java/util/Locale", "language", "Ljava/lang/String;").await?;
889        let country: ClassInstanceRef<String> = jvm.get_field(&this, "java/util/Locale", "country", "Ljava/lang/String;").await?;
890        let variant: ClassInstanceRef<String> = jvm.get_field(&this, "java/util/Locale", "variant", "Ljava/lang/String;").await?;
891
892        let language = JavaLangString::to_rust_string(jvm, &language).await?;
893        let country = JavaLangString::to_rust_string(jvm, &country).await?;
894        let variant = JavaLangString::to_rust_string(jvm, &variant).await?;
895
896        Ok(Self::string_hash(&language) ^ Self::string_hash(&country) ^ Self::string_hash(&variant))
897    }
898
899    fn string_hash(value: &str) -> i32 {
900        value.encode_utf16().fold(0i32, |acc, ch| acc.wrapping_mul(31).wrapping_add(ch as i32))
901    }
902
903    async fn clone(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
904        tracing::debug!("java.util.Locale::clone({this:?})");
905
906        let language: ClassInstanceRef<String> = jvm.get_field(&this, "java/util/Locale", "language", "Ljava/lang/String;").await?;
907        let country: ClassInstanceRef<String> = jvm.get_field(&this, "java/util/Locale", "country", "Ljava/lang/String;").await?;
908        let variant: ClassInstanceRef<String> = jvm.get_field(&this, "java/util/Locale", "variant", "Ljava/lang/String;").await?;
909
910        let language = JavaLangString::to_rust_string(jvm, &language).await?;
911        let country = JavaLangString::to_rust_string(jvm, &country).await?;
912        let variant = JavaLangString::to_rust_string(jvm, &variant).await?;
913
914        Ok(jvm
915            .new_class(
916                "java/util/Locale",
917                "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
918                (
919                    JavaLangString::from_rust_string(jvm, &language).await?,
920                    JavaLangString::from_rust_string(jvm, &country).await?,
921                    JavaLangString::from_rust_string(jvm, &variant).await?,
922                ),
923            )
924            .await?
925            .into())
926    }
927
928    async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
929        tracing::debug!("java.util.Locale::toString({this:?})");
930
931        let language: ClassInstanceRef<String> = jvm.get_field(&this, "java/util/Locale", "language", "Ljava/lang/String;").await?;
932        let country: ClassInstanceRef<String> = jvm.get_field(&this, "java/util/Locale", "country", "Ljava/lang/String;").await?;
933        let variant: ClassInstanceRef<String> = jvm.get_field(&this, "java/util/Locale", "variant", "Ljava/lang/String;").await?;
934
935        let language = JavaLangString::to_rust_string(jvm, &language).await?;
936        let country = JavaLangString::to_rust_string(jvm, &country).await?;
937        let variant = JavaLangString::to_rust_string(jvm, &variant).await?;
938
939        let result = if variant.is_empty() {
940            if country.is_empty() { language } else { format!("{language}_{country}") }
941        } else {
942            format!("{language}_{country}_{variant}")
943        };
944
945        Ok(JavaLangString::from_rust_string(jvm, &result).await?.into())
946    }
947}