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, "language", "Ljava/lang/String;", language).await?;
568        jvm.put_field(&mut this, "country", "Ljava/lang/String;", country).await?;
569        jvm.put_field(&mut this, "variant", "Ljava/lang/String;", variant).await?;
570
571        Ok(())
572    }
573
574    async fn get_default(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Self>> {
575        tracing::debug!("java.util.Locale::getDefault()");
576
577        jvm.get_static_field("java/util/Locale", "defaultLocale", "Ljava/util/Locale;").await
578    }
579
580    async fn set_default(jvm: &Jvm, _: &mut RuntimeContext, locale: ClassInstanceRef<Self>) -> Result<()> {
581        tracing::debug!("java.util.Locale::setDefault({locale:?})");
582
583        if locale.is_null() {
584            return Err(jvm.exception("java/lang/NullPointerException", "Locale default is null").await);
585        }
586
587        jvm.put_static_field("java/util/Locale", "defaultLocale", "Ljava/util/Locale;", locale)
588            .await
589    }
590
591    async fn get_available_locales(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Array<Self>>> {
592        tracing::debug!("java.util.Locale::getAvailableLocales()");
593
594        let fields = [
595            "ENGLISH",
596            "FRENCH",
597            "GERMAN",
598            "ITALIAN",
599            "JAPANESE",
600            "KOREAN",
601            "CHINESE",
602            "SIMPLIFIED_CHINESE",
603            "TRADITIONAL_CHINESE",
604            "FRANCE",
605            "GERMANY",
606            "ITALY",
607            "JAPAN",
608            "KOREA",
609            "CHINA",
610            "PRC",
611            "TAIWAN",
612            "UK",
613            "US",
614            "CANADA",
615            "CANADA_FRENCH",
616        ];
617        let mut array: ClassInstanceRef<Array<Self>> = jvm.instantiate_array("Ljava/util/Locale;", fields.len()).await?.into();
618
619        for (i, field) in fields.iter().enumerate() {
620            let locale: ClassInstanceRef<Self> = jvm.get_static_field("java/util/Locale", field, "Ljava/util/Locale;").await?;
621            jvm.store_array(&mut array, i, iter::once(locale)).await?;
622        }
623
624        Ok(array)
625    }
626
627    async fn get_iso_countries(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Array<String>>> {
628        tracing::debug!("java.util.Locale::getISOCountries()");
629
630        Self::string_array(jvm, &["US", "GB", "CA", "FR", "DE", "IT", "JP", "KR", "CN", "TW"]).await
631    }
632
633    async fn get_iso_languages(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Array<String>>> {
634        tracing::debug!("java.util.Locale::getISOLanguages()");
635
636        Self::string_array(jvm, &["en", "fr", "de", "it", "ja", "ko", "zh"]).await
637    }
638
639    async fn string_array(jvm: &Jvm, values: &[&str]) -> Result<ClassInstanceRef<Array<String>>> {
640        let mut array: ClassInstanceRef<Array<String>> = jvm.instantiate_array("Ljava/lang/String;", values.len()).await?.into();
641        for (i, value) in values.iter().enumerate() {
642            let value: ClassInstanceRef<String> = JavaLangString::from_rust_string(jvm, value).await?.into();
643            jvm.store_array(&mut array, i, iter::once(value)).await?;
644        }
645        Ok(array)
646    }
647
648    async fn get_language(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
649        tracing::debug!("java.util.Locale::getLanguage({this:?})");
650
651        jvm.get_field(&this, "language", "Ljava/lang/String;").await
652    }
653
654    async fn get_country(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
655        tracing::debug!("java.util.Locale::getCountry({this:?})");
656
657        jvm.get_field(&this, "country", "Ljava/lang/String;").await
658    }
659
660    async fn get_variant(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
661        tracing::debug!("java.util.Locale::getVariant({this:?})");
662
663        jvm.get_field(&this, "variant", "Ljava/lang/String;").await
664    }
665
666    async fn get_iso3_language(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
667        tracing::debug!("java.util.Locale::getISO3Language({this:?})");
668
669        let language: ClassInstanceRef<String> = jvm.get_field(&this, "language", "Ljava/lang/String;").await?;
670        let language = JavaLangString::to_rust_string(jvm, &language).await?;
671        let iso3 = match language.as_str() {
672            "" => "",
673            "en" => "eng",
674            "fr" => "fra",
675            "de" => "deu",
676            "it" => "ita",
677            "ja" => "jpn",
678            "ko" => "kor",
679            "zh" => "zho",
680            _ => return Err(jvm.exception("java/lang/IllegalArgumentException", "Unsupported ISO3 language").await),
681        };
682
683        Ok(JavaLangString::from_rust_string(jvm, iso3).await?.into())
684    }
685
686    async fn get_iso3_country(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
687        tracing::debug!("java.util.Locale::getISO3Country({this:?})");
688
689        let country: ClassInstanceRef<String> = jvm.get_field(&this, "country", "Ljava/lang/String;").await?;
690        let country = JavaLangString::to_rust_string(jvm, &country).await?;
691        let iso3 = match country.as_str() {
692            "" => "",
693            "US" => "USA",
694            "GB" => "GBR",
695            "CA" => "CAN",
696            "FR" => "FRA",
697            "DE" => "DEU",
698            "IT" => "ITA",
699            "JP" => "JPN",
700            "KR" => "KOR",
701            "CN" => "CHN",
702            "TW" => "TWN",
703            _ => return Err(jvm.exception("java/lang/IllegalArgumentException", "Unsupported ISO3 country").await),
704        };
705
706        Ok(JavaLangString::from_rust_string(jvm, iso3).await?.into())
707    }
708
709    async fn get_display_language_default(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
710        let default = Self::get_default(jvm, context).await?;
711        Self::get_display_language(jvm, context, this, default).await
712    }
713
714    async fn get_display_language(
715        jvm: &Jvm,
716        _: &mut RuntimeContext,
717        this: ClassInstanceRef<Self>,
718        display_locale: ClassInstanceRef<Self>,
719    ) -> Result<ClassInstanceRef<String>> {
720        tracing::debug!("java.util.Locale::getDisplayLanguage({this:?})");
721
722        if display_locale.is_null() {
723            return Err(jvm.exception("java/lang/NullPointerException", "display locale is null").await);
724        }
725
726        let language: ClassInstanceRef<String> = jvm.get_field(&this, "language", "Ljava/lang/String;").await?;
727        let language = JavaLangString::to_rust_string(jvm, &language).await?;
728
729        Ok(JavaLangString::from_rust_string(jvm, Self::display_language(&language)).await?.into())
730    }
731
732    async fn get_display_country_default(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
733        let default = Self::get_default(jvm, context).await?;
734        Self::get_display_country(jvm, context, this, default).await
735    }
736
737    async fn get_display_country(
738        jvm: &Jvm,
739        _: &mut RuntimeContext,
740        this: ClassInstanceRef<Self>,
741        display_locale: ClassInstanceRef<Self>,
742    ) -> Result<ClassInstanceRef<String>> {
743        tracing::debug!("java.util.Locale::getDisplayCountry({this:?})");
744
745        if display_locale.is_null() {
746            return Err(jvm.exception("java/lang/NullPointerException", "display locale is null").await);
747        }
748
749        let country: ClassInstanceRef<String> = jvm.get_field(&this, "country", "Ljava/lang/String;").await?;
750        let country = JavaLangString::to_rust_string(jvm, &country).await?;
751
752        Ok(JavaLangString::from_rust_string(jvm, Self::display_country(&country)).await?.into())
753    }
754
755    async fn get_display_variant_default(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
756        let default = Self::get_default(jvm, context).await?;
757        Self::get_display_variant(jvm, context, this, default).await
758    }
759
760    async fn get_display_variant(
761        jvm: &Jvm,
762        _: &mut RuntimeContext,
763        this: ClassInstanceRef<Self>,
764        display_locale: ClassInstanceRef<Self>,
765    ) -> Result<ClassInstanceRef<String>> {
766        tracing::debug!("java.util.Locale::getDisplayVariant({this:?})");
767
768        if display_locale.is_null() {
769            return Err(jvm.exception("java/lang/NullPointerException", "display locale is null").await);
770        }
771
772        jvm.get_field(&this, "variant", "Ljava/lang/String;").await
773    }
774
775    async fn get_display_name_default(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
776        let default = Self::get_default(jvm, context).await?;
777        Self::get_display_name(jvm, context, this, default).await
778    }
779
780    async fn get_display_name(
781        jvm: &Jvm,
782        _: &mut RuntimeContext,
783        this: ClassInstanceRef<Self>,
784        display_locale: ClassInstanceRef<Self>,
785    ) -> Result<ClassInstanceRef<String>> {
786        tracing::debug!("java.util.Locale::getDisplayName({this:?})");
787
788        if display_locale.is_null() {
789            return Err(jvm.exception("java/lang/NullPointerException", "display locale is null").await);
790        }
791
792        let language: ClassInstanceRef<String> = jvm.get_field(&this, "language", "Ljava/lang/String;").await?;
793        let country: ClassInstanceRef<String> = jvm.get_field(&this, "country", "Ljava/lang/String;").await?;
794        let variant: ClassInstanceRef<String> = jvm.get_field(&this, "variant", "Ljava/lang/String;").await?;
795
796        let language = JavaLangString::to_rust_string(jvm, &language).await?;
797        let country = JavaLangString::to_rust_string(jvm, &country).await?;
798        let variant = JavaLangString::to_rust_string(jvm, &variant).await?;
799
800        let language = Self::display_language(&language);
801        let country = Self::display_country(&country);
802
803        let result = if language.is_empty() {
804            if country.is_empty() {
805                variant
806            } else if variant.is_empty() {
807                country.to_string()
808            } else {
809                format!("{country} ({variant})")
810            }
811        } else if country.is_empty() && variant.is_empty() {
812            language.to_string()
813        } else {
814            let mut suffixes = vec![];
815            if !country.is_empty() {
816                suffixes.push(country.to_string());
817            }
818            if !variant.is_empty() {
819                suffixes.push(variant);
820            }
821            format!("{language} ({})", suffixes.join(", "))
822        };
823
824        Ok(JavaLangString::from_rust_string(jvm, &result).await?.into())
825    }
826
827    fn display_language(language: &str) -> &str {
828        match language {
829            "en" => "English",
830            "fr" => "French",
831            "de" => "German",
832            "it" => "Italian",
833            "ja" => "Japanese",
834            "ko" => "Korean",
835            "zh" => "Chinese",
836            _ => language,
837        }
838    }
839
840    fn display_country(country: &str) -> &str {
841        match country {
842            "US" => "United States",
843            "GB" => "United Kingdom",
844            "CA" => "Canada",
845            "FR" => "France",
846            "DE" => "Germany",
847            "IT" => "Italy",
848            "JP" => "Japan",
849            "KR" => "South Korea",
850            "CN" => "China",
851            "TW" => "Taiwan",
852            _ => country,
853        }
854    }
855
856    async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<bool> {
857        tracing::debug!("java.util.Locale::equals({this:?}, {other:?})");
858
859        if other.is_null() || !jvm.is_instance(&**other, "java/util/Locale") {
860            return Ok(false);
861        }
862
863        let other: ClassInstanceRef<Self> = ClassInstanceRef::new(other.instance);
864
865        let this_language: ClassInstanceRef<String> = jvm.get_field(&this, "language", "Ljava/lang/String;").await?;
866        let this_country: ClassInstanceRef<String> = jvm.get_field(&this, "country", "Ljava/lang/String;").await?;
867        let this_variant: ClassInstanceRef<String> = jvm.get_field(&this, "variant", "Ljava/lang/String;").await?;
868        let other_language: ClassInstanceRef<String> = jvm.get_field(&other, "language", "Ljava/lang/String;").await?;
869        let other_country: ClassInstanceRef<String> = jvm.get_field(&other, "country", "Ljava/lang/String;").await?;
870        let other_variant: ClassInstanceRef<String> = jvm.get_field(&other, "variant", "Ljava/lang/String;").await?;
871
872        let this_language = JavaLangString::to_rust_string(jvm, &this_language).await?;
873        let this_country = JavaLangString::to_rust_string(jvm, &this_country).await?;
874        let this_variant = JavaLangString::to_rust_string(jvm, &this_variant).await?;
875        let other_language = JavaLangString::to_rust_string(jvm, &other_language).await?;
876        let other_country = JavaLangString::to_rust_string(jvm, &other_country).await?;
877        let other_variant = JavaLangString::to_rust_string(jvm, &other_variant).await?;
878
879        Ok(this_language == other_language && this_country == other_country && this_variant == other_variant)
880    }
881
882    async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
883        tracing::debug!("java.util.Locale::hashCode({this:?})");
884
885        let language: ClassInstanceRef<String> = jvm.get_field(&this, "language", "Ljava/lang/String;").await?;
886        let country: ClassInstanceRef<String> = jvm.get_field(&this, "country", "Ljava/lang/String;").await?;
887        let variant: ClassInstanceRef<String> = jvm.get_field(&this, "variant", "Ljava/lang/String;").await?;
888
889        let language = JavaLangString::to_rust_string(jvm, &language).await?;
890        let country = JavaLangString::to_rust_string(jvm, &country).await?;
891        let variant = JavaLangString::to_rust_string(jvm, &variant).await?;
892
893        Ok(Self::string_hash(&language) ^ Self::string_hash(&country) ^ Self::string_hash(&variant))
894    }
895
896    fn string_hash(value: &str) -> i32 {
897        value.encode_utf16().fold(0i32, |acc, ch| acc.wrapping_mul(31).wrapping_add(ch as i32))
898    }
899
900    async fn clone(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
901        tracing::debug!("java.util.Locale::clone({this:?})");
902
903        let language: ClassInstanceRef<String> = jvm.get_field(&this, "language", "Ljava/lang/String;").await?;
904        let country: ClassInstanceRef<String> = jvm.get_field(&this, "country", "Ljava/lang/String;").await?;
905        let variant: ClassInstanceRef<String> = jvm.get_field(&this, "variant", "Ljava/lang/String;").await?;
906
907        let language = JavaLangString::to_rust_string(jvm, &language).await?;
908        let country = JavaLangString::to_rust_string(jvm, &country).await?;
909        let variant = JavaLangString::to_rust_string(jvm, &variant).await?;
910
911        Ok(jvm
912            .new_class(
913                "java/util/Locale",
914                "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
915                (
916                    JavaLangString::from_rust_string(jvm, &language).await?,
917                    JavaLangString::from_rust_string(jvm, &country).await?,
918                    JavaLangString::from_rust_string(jvm, &variant).await?,
919                ),
920            )
921            .await?
922            .into())
923    }
924
925    async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
926        tracing::debug!("java.util.Locale::toString({this:?})");
927
928        let language: ClassInstanceRef<String> = jvm.get_field(&this, "language", "Ljava/lang/String;").await?;
929        let country: ClassInstanceRef<String> = jvm.get_field(&this, "country", "Ljava/lang/String;").await?;
930        let variant: ClassInstanceRef<String> = jvm.get_field(&this, "variant", "Ljava/lang/String;").await?;
931
932        let language = JavaLangString::to_rust_string(jvm, &language).await?;
933        let country = JavaLangString::to_rust_string(jvm, &country).await?;
934        let variant = JavaLangString::to_rust_string(jvm, &variant).await?;
935
936        let result = if variant.is_empty() {
937            if country.is_empty() { language } else { format!("{language}_{country}") }
938        } else {
939            format!("{language}_{country}_{variant}")
940        };
941
942        Ok(JavaLangString::from_rust_string(jvm, &result).await?.into())
943    }
944}