Skip to main content

rustjava_runtime/classes/java/text/
number_format.rs

1use alloc::vec;
2
3use jvm::{Array, ClassInstanceRef, JavaError, Jvm, Result, runtime::JavaLangString};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{
8    RuntimeClassProto, RuntimeContext,
9    classes::java::{
10        lang::{Number, Object, String, StringBuffer},
11        text::{FieldPosition, ParseException, ParsePosition},
12        util::Locale,
13    },
14};
15
16// public abstract class java.text.NumberFormat
17pub struct NumberFormat;
18
19impl NumberFormat {
20    pub fn as_proto() -> RuntimeClassProto {
21        RuntimeClassProto {
22            name: "java/text/NumberFormat",
23            parent_class: Some("java/text/Format"),
24            interfaces: vec![],
25            methods: vec![
26                JavaMethodProto::new("<clinit>", "()V", Self::clinit, MethodAccessFlags::STATIC),
27                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PROTECTED),
28                JavaMethodProto::new(
29                    "format",
30                    "(Ljava/lang/Object;Ljava/lang/StringBuffer;Ljava/text/FieldPosition;)Ljava/lang/StringBuffer;",
31                    Self::format_object,
32                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
33                ),
34                JavaMethodProto::new(
35                    "format",
36                    "(D)Ljava/lang/String;",
37                    Self::format_double,
38                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
39                ),
40                JavaMethodProto::new(
41                    "format",
42                    "(J)Ljava/lang/String;",
43                    Self::format_long,
44                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
45                ),
46                JavaMethodProto::new_abstract(
47                    "format",
48                    "(DLjava/lang/StringBuffer;Ljava/text/FieldPosition;)Ljava/lang/StringBuffer;",
49                    MethodAccessFlags::PUBLIC | MethodAccessFlags::ABSTRACT,
50                ),
51                JavaMethodProto::new_abstract(
52                    "format",
53                    "(JLjava/lang/StringBuffer;Ljava/text/FieldPosition;)Ljava/lang/StringBuffer;",
54                    MethodAccessFlags::PUBLIC | MethodAccessFlags::ABSTRACT,
55                ),
56                JavaMethodProto::new("parse", "(Ljava/lang/String;)Ljava/lang/Number;", Self::parse, MethodAccessFlags::PUBLIC),
57                JavaMethodProto::new_abstract(
58                    "parse",
59                    "(Ljava/lang/String;Ljava/text/ParsePosition;)Ljava/lang/Number;",
60                    MethodAccessFlags::PUBLIC | MethodAccessFlags::ABSTRACT,
61                ),
62                JavaMethodProto::new(
63                    "parseObject",
64                    "(Ljava/lang/String;Ljava/text/ParsePosition;)Ljava/lang/Object;",
65                    Self::parse_object,
66                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
67                ),
68                JavaMethodProto::new(
69                    "getInstance",
70                    "()Ljava/text/NumberFormat;",
71                    Self::get_instance,
72                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC | MethodAccessFlags::FINAL,
73                ),
74                JavaMethodProto::new(
75                    "getInstance",
76                    "(Ljava/util/Locale;)Ljava/text/NumberFormat;",
77                    Self::get_instance_with_locale,
78                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
79                ),
80                JavaMethodProto::new(
81                    "getNumberInstance",
82                    "()Ljava/text/NumberFormat;",
83                    Self::get_number_instance,
84                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC | MethodAccessFlags::FINAL,
85                ),
86                JavaMethodProto::new(
87                    "getNumberInstance",
88                    "(Ljava/util/Locale;)Ljava/text/NumberFormat;",
89                    Self::get_number_instance_with_locale,
90                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
91                ),
92                JavaMethodProto::new(
93                    "getIntegerInstance",
94                    "()Ljava/text/NumberFormat;",
95                    Self::get_integer_instance,
96                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC | MethodAccessFlags::FINAL,
97                ),
98                JavaMethodProto::new(
99                    "getIntegerInstance",
100                    "(Ljava/util/Locale;)Ljava/text/NumberFormat;",
101                    Self::get_integer_instance_with_locale,
102                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
103                ),
104                JavaMethodProto::new(
105                    "getCurrencyInstance",
106                    "()Ljava/text/NumberFormat;",
107                    Self::get_currency_instance,
108                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC | MethodAccessFlags::FINAL,
109                ),
110                JavaMethodProto::new(
111                    "getCurrencyInstance",
112                    "(Ljava/util/Locale;)Ljava/text/NumberFormat;",
113                    Self::get_currency_instance_with_locale,
114                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
115                ),
116                JavaMethodProto::new(
117                    "getPercentInstance",
118                    "()Ljava/text/NumberFormat;",
119                    Self::get_percent_instance,
120                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC | MethodAccessFlags::FINAL,
121                ),
122                JavaMethodProto::new(
123                    "getPercentInstance",
124                    "(Ljava/util/Locale;)Ljava/text/NumberFormat;",
125                    Self::get_percent_instance_with_locale,
126                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
127                ),
128                JavaMethodProto::new(
129                    "getAvailableLocales",
130                    "()[Ljava/util/Locale;",
131                    Self::get_available_locales,
132                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
133                ),
134                JavaMethodProto::new("isGroupingUsed", "()Z", Self::is_grouping_used, MethodAccessFlags::PUBLIC),
135                JavaMethodProto::new("setGroupingUsed", "(Z)V", Self::set_grouping_used, MethodAccessFlags::PUBLIC),
136                JavaMethodProto::new("isParseIntegerOnly", "()Z", Self::is_parse_integer_only, MethodAccessFlags::PUBLIC),
137                JavaMethodProto::new("setParseIntegerOnly", "(Z)V", Self::set_parse_integer_only, MethodAccessFlags::PUBLIC),
138                JavaMethodProto::new(
139                    "getMaximumIntegerDigits",
140                    "()I",
141                    Self::get_maximum_integer_digits,
142                    MethodAccessFlags::PUBLIC,
143                ),
144                JavaMethodProto::new(
145                    "setMaximumIntegerDigits",
146                    "(I)V",
147                    Self::set_maximum_integer_digits,
148                    MethodAccessFlags::PUBLIC,
149                ),
150                JavaMethodProto::new(
151                    "getMinimumIntegerDigits",
152                    "()I",
153                    Self::get_minimum_integer_digits,
154                    MethodAccessFlags::PUBLIC,
155                ),
156                JavaMethodProto::new(
157                    "setMinimumIntegerDigits",
158                    "(I)V",
159                    Self::set_minimum_integer_digits,
160                    MethodAccessFlags::PUBLIC,
161                ),
162                JavaMethodProto::new(
163                    "getMaximumFractionDigits",
164                    "()I",
165                    Self::get_maximum_fraction_digits,
166                    MethodAccessFlags::PUBLIC,
167                ),
168                JavaMethodProto::new(
169                    "setMaximumFractionDigits",
170                    "(I)V",
171                    Self::set_maximum_fraction_digits,
172                    MethodAccessFlags::PUBLIC,
173                ),
174                JavaMethodProto::new(
175                    "getMinimumFractionDigits",
176                    "()I",
177                    Self::get_minimum_fraction_digits,
178                    MethodAccessFlags::PUBLIC,
179                ),
180                JavaMethodProto::new(
181                    "setMinimumFractionDigits",
182                    "(I)V",
183                    Self::set_minimum_fraction_digits,
184                    MethodAccessFlags::PUBLIC,
185                ),
186                JavaMethodProto::new("equals", "(Ljava/lang/Object;)Z", Self::equals, MethodAccessFlags::PUBLIC),
187                JavaMethodProto::new("hashCode", "()I", Self::hash_code, MethodAccessFlags::PUBLIC),
188            ],
189            fields: vec![
190                JavaFieldProto::new(
191                    "INTEGER_FIELD",
192                    "I",
193                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
194                ),
195                JavaFieldProto::new(
196                    "FRACTION_FIELD",
197                    "I",
198                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
199                ),
200                JavaFieldProto::new("groupingUsed", "Z", FieldAccessFlags::PRIVATE),
201                JavaFieldProto::new("parseIntegerOnly", "Z", FieldAccessFlags::PRIVATE),
202                JavaFieldProto::new("maximumIntegerDigits", "I", FieldAccessFlags::PRIVATE),
203                JavaFieldProto::new("minimumIntegerDigits", "I", FieldAccessFlags::PRIVATE),
204                JavaFieldProto::new("maximumFractionDigits", "I", FieldAccessFlags::PRIVATE),
205                JavaFieldProto::new("minimumFractionDigits", "I", FieldAccessFlags::PRIVATE),
206            ],
207            access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::ABSTRACT,
208        }
209    }
210
211    async fn clinit(jvm: &Jvm, _: &mut RuntimeContext) -> Result<()> {
212        jvm.put_static_field("java/text/NumberFormat", "INTEGER_FIELD", "I", 0).await?;
213        jvm.put_static_field("java/text/NumberFormat", "FRACTION_FIELD", "I", 1).await
214    }
215
216    async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
217        let _: () = jvm.invoke_special(&this, "java/text/Format", "<init>", "()V", ()).await?;
218        jvm.put_field(&mut this, "java/text/NumberFormat", "groupingUsed", "Z", true).await?;
219        jvm.put_field(&mut this, "java/text/NumberFormat", "parseIntegerOnly", "Z", false).await?;
220        jvm.put_field(&mut this, "java/text/NumberFormat", "maximumIntegerDigits", "I", 40)
221            .await?;
222        jvm.put_field(&mut this, "java/text/NumberFormat", "minimumIntegerDigits", "I", 1).await?;
223        jvm.put_field(&mut this, "java/text/NumberFormat", "maximumFractionDigits", "I", 3)
224            .await?;
225        jvm.put_field(&mut this, "java/text/NumberFormat", "minimumFractionDigits", "I", 0).await
226    }
227
228    async fn format_object(
229        jvm: &Jvm,
230        _: &mut RuntimeContext,
231        this: ClassInstanceRef<Self>,
232        object: ClassInstanceRef<Object>,
233        buffer: ClassInstanceRef<StringBuffer>,
234        position: ClassInstanceRef<FieldPosition>,
235    ) -> Result<ClassInstanceRef<StringBuffer>> {
236        if object.is_null() || !jvm.is_instance(&**object, "java/lang/Number") {
237            return Err(jvm
238                .exception("java/lang/IllegalArgumentException", "Cannot format given Object as a Number")
239                .await);
240        }
241        if buffer.is_null() || position.is_null() {
242            return Err(jvm.exception("java/lang/NullPointerException", "buffer or position").await);
243        }
244
245        if jvm.is_instance(&**object, "java/lang/Byte")
246            || jvm.is_instance(&**object, "java/lang/Short")
247            || jvm.is_instance(&**object, "java/lang/Integer")
248            || jvm.is_instance(&**object, "java/lang/Long")
249        {
250            let value: i64 = jvm.invoke_virtual(&object, "java/lang/Number", "longValue", "()J", ()).await?;
251            return jvm
252                .invoke_virtual(
253                    &this,
254                    "java/text/NumberFormat",
255                    "format",
256                    "(JLjava/lang/StringBuffer;Ljava/text/FieldPosition;)Ljava/lang/StringBuffer;",
257                    (value, buffer, position),
258                )
259                .await;
260        }
261
262        let value: f64 = jvm.invoke_virtual(&object, "java/lang/Number", "doubleValue", "()D", ()).await?;
263        jvm.invoke_virtual(
264            &this,
265            "java/text/NumberFormat",
266            "format",
267            "(DLjava/lang/StringBuffer;Ljava/text/FieldPosition;)Ljava/lang/StringBuffer;",
268            (value, buffer, position),
269        )
270        .await
271    }
272
273    async fn format_double(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f64) -> Result<ClassInstanceRef<String>> {
274        let buffer: ClassInstanceRef<StringBuffer> = jvm.new_class("java/lang/StringBuffer", "()V", ()).await?.into();
275        let position: ClassInstanceRef<FieldPosition> = jvm.new_class("java/text/FieldPosition", "(I)V", (0,)).await?.into();
276        let buffer: ClassInstanceRef<StringBuffer> = jvm
277            .invoke_virtual(
278                &this,
279                "java/text/NumberFormat",
280                "format",
281                "(DLjava/lang/StringBuffer;Ljava/text/FieldPosition;)Ljava/lang/StringBuffer;",
282                (value, buffer, position),
283            )
284            .await?;
285        jvm.invoke_virtual(&buffer, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
286            .await
287    }
288
289    async fn format_long(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i64) -> Result<ClassInstanceRef<String>> {
290        let buffer: ClassInstanceRef<StringBuffer> = jvm.new_class("java/lang/StringBuffer", "()V", ()).await?.into();
291        let position: ClassInstanceRef<FieldPosition> = jvm.new_class("java/text/FieldPosition", "(I)V", (0,)).await?.into();
292        let buffer: ClassInstanceRef<StringBuffer> = jvm
293            .invoke_virtual(
294                &this,
295                "java/text/NumberFormat",
296                "format",
297                "(JLjava/lang/StringBuffer;Ljava/text/FieldPosition;)Ljava/lang/StringBuffer;",
298                (value, buffer, position),
299            )
300            .await?;
301        jvm.invoke_virtual(&buffer, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
302            .await
303    }
304
305    async fn parse(
306        jvm: &Jvm,
307        _: &mut RuntimeContext,
308        this: ClassInstanceRef<Self>,
309        source: ClassInstanceRef<String>,
310    ) -> Result<ClassInstanceRef<Number>> {
311        if source.is_null() {
312            return Err(jvm.exception("java/lang/NullPointerException", "source").await);
313        }
314        let position: ClassInstanceRef<ParsePosition> = jvm.new_class("java/text/ParsePosition", "(I)V", (0,)).await?.into();
315        let result: ClassInstanceRef<Number> = jvm
316            .invoke_virtual(
317                &this,
318                "java/text/NumberFormat",
319                "parse",
320                "(Ljava/lang/String;Ljava/text/ParsePosition;)Ljava/lang/Number;",
321                (source, position.clone()),
322            )
323            .await?;
324        let index: i32 = jvm.invoke_virtual(&position, "java/text/ParsePosition", "getIndex", "()I", ()).await?;
325        if index == 0 {
326            let error_index: i32 = jvm
327                .invoke_virtual(&position, "java/text/ParsePosition", "getErrorIndex", "()I", ())
328                .await?;
329            let message = JavaLangString::from_rust_string(jvm, "Unparseable number").await?;
330            let exception: ClassInstanceRef<ParseException> = jvm
331                .new_class("java/text/ParseException", "(Ljava/lang/String;I)V", (message, error_index))
332                .await?
333                .into();
334            return Err(JavaError::JavaException(exception.into()));
335        }
336        Ok(result)
337    }
338
339    async fn parse_object(
340        jvm: &Jvm,
341        _: &mut RuntimeContext,
342        this: ClassInstanceRef<Self>,
343        source: ClassInstanceRef<String>,
344        position: ClassInstanceRef<ParsePosition>,
345    ) -> Result<ClassInstanceRef<Object>> {
346        let number: ClassInstanceRef<Number> = jvm
347            .invoke_virtual(
348                &this,
349                "java/text/NumberFormat",
350                "parse",
351                "(Ljava/lang/String;Ljava/text/ParsePosition;)Ljava/lang/Number;",
352                (source, position),
353            )
354            .await?;
355        Ok(ClassInstanceRef::new(number.instance))
356    }
357
358    async fn get_instance(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Self>> {
359        jvm.invoke_static("java/text/NumberFormat", "getNumberInstance", "()Ljava/text/NumberFormat;", ())
360            .await
361    }
362
363    async fn get_instance_with_locale(jvm: &Jvm, _: &mut RuntimeContext, locale: ClassInstanceRef<Locale>) -> Result<ClassInstanceRef<Self>> {
364        jvm.invoke_static(
365            "java/text/NumberFormat",
366            "getNumberInstance",
367            "(Ljava/util/Locale;)Ljava/text/NumberFormat;",
368            (locale,),
369        )
370        .await
371    }
372
373    async fn get_number_instance(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Self>> {
374        let locale: ClassInstanceRef<Locale> = jvm.invoke_static("java/util/Locale", "getDefault", "()Ljava/util/Locale;", ()).await?;
375        jvm.invoke_static(
376            "java/text/NumberFormat",
377            "getNumberInstance",
378            "(Ljava/util/Locale;)Ljava/text/NumberFormat;",
379            (locale,),
380        )
381        .await
382    }
383
384    async fn get_number_instance_with_locale(jvm: &Jvm, _: &mut RuntimeContext, locale: ClassInstanceRef<Locale>) -> Result<ClassInstanceRef<Self>> {
385        if locale.is_null() {
386            return Err(jvm.exception("java/lang/NullPointerException", "locale").await);
387        }
388        let pattern = JavaLangString::from_rust_string(jvm, "#,##0.###").await?;
389        Ok(jvm
390            .new_class("java/text/DecimalFormat", "(Ljava/lang/String;)V", (pattern,))
391            .await?
392            .into())
393    }
394
395    async fn get_integer_instance(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Self>> {
396        let locale: ClassInstanceRef<Locale> = jvm.invoke_static("java/util/Locale", "getDefault", "()Ljava/util/Locale;", ()).await?;
397        jvm.invoke_static(
398            "java/text/NumberFormat",
399            "getIntegerInstance",
400            "(Ljava/util/Locale;)Ljava/text/NumberFormat;",
401            (locale,),
402        )
403        .await
404    }
405
406    async fn get_integer_instance_with_locale(jvm: &Jvm, _: &mut RuntimeContext, locale: ClassInstanceRef<Locale>) -> Result<ClassInstanceRef<Self>> {
407        if locale.is_null() {
408            return Err(jvm.exception("java/lang/NullPointerException", "locale").await);
409        }
410        let pattern = JavaLangString::from_rust_string(jvm, "#,##0").await?;
411        let format: ClassInstanceRef<Self> = jvm
412            .new_class("java/text/DecimalFormat", "(Ljava/lang/String;)V", (pattern,))
413            .await?
414            .into();
415        let _: () = jvm
416            .invoke_virtual(&format, "java/text/NumberFormat", "setParseIntegerOnly", "(Z)V", (true,))
417            .await?;
418        Ok(format)
419    }
420
421    async fn get_currency_instance(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Self>> {
422        let locale: ClassInstanceRef<Locale> = jvm.invoke_static("java/util/Locale", "getDefault", "()Ljava/util/Locale;", ()).await?;
423        jvm.invoke_static(
424            "java/text/NumberFormat",
425            "getCurrencyInstance",
426            "(Ljava/util/Locale;)Ljava/text/NumberFormat;",
427            (locale,),
428        )
429        .await
430    }
431
432    async fn get_currency_instance_with_locale(
433        jvm: &Jvm,
434        _: &mut RuntimeContext,
435        locale: ClassInstanceRef<Locale>,
436    ) -> Result<ClassInstanceRef<Self>> {
437        if locale.is_null() {
438            return Err(jvm.exception("java/lang/NullPointerException", "locale").await);
439        }
440        let pattern = JavaLangString::from_rust_string(jvm, "\u{00a4}#,##0.00;-\u{00a4}#,##0.00").await?;
441        Ok(jvm
442            .new_class("java/text/DecimalFormat", "(Ljava/lang/String;)V", (pattern,))
443            .await?
444            .into())
445    }
446
447    async fn get_percent_instance(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Self>> {
448        let locale: ClassInstanceRef<Locale> = jvm.invoke_static("java/util/Locale", "getDefault", "()Ljava/util/Locale;", ()).await?;
449        jvm.invoke_static(
450            "java/text/NumberFormat",
451            "getPercentInstance",
452            "(Ljava/util/Locale;)Ljava/text/NumberFormat;",
453            (locale,),
454        )
455        .await
456    }
457
458    async fn get_percent_instance_with_locale(jvm: &Jvm, _: &mut RuntimeContext, locale: ClassInstanceRef<Locale>) -> Result<ClassInstanceRef<Self>> {
459        if locale.is_null() {
460            return Err(jvm.exception("java/lang/NullPointerException", "locale").await);
461        }
462        let pattern = JavaLangString::from_rust_string(jvm, "#,##0%").await?;
463        Ok(jvm
464            .new_class("java/text/DecimalFormat", "(Ljava/lang/String;)V", (pattern,))
465            .await?
466            .into())
467    }
468
469    async fn get_available_locales(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Array<Locale>>> {
470        jvm.invoke_static("java/util/Locale", "getAvailableLocales", "()[Ljava/util/Locale;", ())
471            .await
472    }
473
474    async fn is_grouping_used(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
475        jvm.get_field(&this, "java/text/NumberFormat", "groupingUsed", "Z").await
476    }
477
478    async fn set_grouping_used(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: bool) -> Result<()> {
479        jvm.put_field(&mut this, "java/text/NumberFormat", "groupingUsed", "Z", value).await
480    }
481
482    async fn is_parse_integer_only(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
483        jvm.get_field(&this, "java/text/NumberFormat", "parseIntegerOnly", "Z").await
484    }
485
486    async fn set_parse_integer_only(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: bool) -> Result<()> {
487        jvm.put_field(&mut this, "java/text/NumberFormat", "parseIntegerOnly", "Z", value).await
488    }
489
490    async fn get_maximum_integer_digits(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
491        jvm.get_field(&this, "java/text/NumberFormat", "maximumIntegerDigits", "I").await
492    }
493
494    async fn set_maximum_integer_digits(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: i32) -> Result<()> {
495        let value = value.max(0);
496        jvm.put_field(&mut this, "java/text/NumberFormat", "maximumIntegerDigits", "I", value)
497            .await?;
498        let minimum: i32 = jvm.get_field(&this, "java/text/NumberFormat", "minimumIntegerDigits", "I").await?;
499        if minimum > value {
500            jvm.put_field(&mut this, "java/text/NumberFormat", "minimumIntegerDigits", "I", value)
501                .await?;
502        }
503        Ok(())
504    }
505
506    async fn get_minimum_integer_digits(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
507        jvm.get_field(&this, "java/text/NumberFormat", "minimumIntegerDigits", "I").await
508    }
509
510    async fn set_minimum_integer_digits(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: i32) -> Result<()> {
511        let value = value.max(0);
512        jvm.put_field(&mut this, "java/text/NumberFormat", "minimumIntegerDigits", "I", value)
513            .await?;
514        let maximum: i32 = jvm.get_field(&this, "java/text/NumberFormat", "maximumIntegerDigits", "I").await?;
515        if maximum < value {
516            jvm.put_field(&mut this, "java/text/NumberFormat", "maximumIntegerDigits", "I", value)
517                .await?;
518        }
519        Ok(())
520    }
521
522    async fn get_maximum_fraction_digits(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
523        jvm.get_field(&this, "java/text/NumberFormat", "maximumFractionDigits", "I").await
524    }
525
526    async fn set_maximum_fraction_digits(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: i32) -> Result<()> {
527        let value = value.max(0);
528        jvm.put_field(&mut this, "java/text/NumberFormat", "maximumFractionDigits", "I", value)
529            .await?;
530        let minimum: i32 = jvm.get_field(&this, "java/text/NumberFormat", "minimumFractionDigits", "I").await?;
531        if minimum > value {
532            jvm.put_field(&mut this, "java/text/NumberFormat", "minimumFractionDigits", "I", value)
533                .await?;
534        }
535        Ok(())
536    }
537
538    async fn get_minimum_fraction_digits(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
539        jvm.get_field(&this, "java/text/NumberFormat", "minimumFractionDigits", "I").await
540    }
541
542    async fn set_minimum_fraction_digits(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: i32) -> Result<()> {
543        let value = value.max(0);
544        jvm.put_field(&mut this, "java/text/NumberFormat", "minimumFractionDigits", "I", value)
545            .await?;
546        let maximum: i32 = jvm.get_field(&this, "java/text/NumberFormat", "maximumFractionDigits", "I").await?;
547        if maximum < value {
548            jvm.put_field(&mut this, "java/text/NumberFormat", "maximumFractionDigits", "I", value)
549                .await?;
550        }
551        Ok(())
552    }
553
554    async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<bool> {
555        if other.is_null() || !jvm.is_instance(&**other, "java/text/NumberFormat") {
556            return Ok(false);
557        }
558        let other: ClassInstanceRef<Self> = ClassInstanceRef::new(other.instance);
559        for (name, descriptor) in [
560            ("groupingUsed", "Z"),
561            ("parseIntegerOnly", "Z"),
562            ("maximumIntegerDigits", "I"),
563            ("minimumIntegerDigits", "I"),
564            ("maximumFractionDigits", "I"),
565            ("minimumFractionDigits", "I"),
566        ] {
567            if descriptor == "Z" {
568                let value: bool = jvm.get_field(&this, "java/text/NumberFormat", name, descriptor).await?;
569                let other_value: bool = jvm.get_field(&other, "java/text/NumberFormat", name, descriptor).await?;
570                if value != other_value {
571                    return Ok(false);
572                }
573            } else {
574                let value: i32 = jvm.get_field(&this, "java/text/NumberFormat", name, descriptor).await?;
575                let other_value: i32 = jvm.get_field(&other, "java/text/NumberFormat", name, descriptor).await?;
576                if value != other_value {
577                    return Ok(false);
578                }
579            }
580        }
581        Ok(true)
582    }
583
584    async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
585        let maximum_integer_digits: i32 = jvm.get_field(&this, "java/text/NumberFormat", "maximumIntegerDigits", "I").await?;
586        let maximum_fraction_digits: i32 = jvm.get_field(&this, "java/text/NumberFormat", "maximumFractionDigits", "I").await?;
587        Ok(maximum_integer_digits * 37 + maximum_fraction_digits)
588    }
589}