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, "groupingUsed", "Z", true).await?;
219        jvm.put_field(&mut this, "parseIntegerOnly", "Z", false).await?;
220        jvm.put_field(&mut this, "maximumIntegerDigits", "I", 40).await?;
221        jvm.put_field(&mut this, "minimumIntegerDigits", "I", 1).await?;
222        jvm.put_field(&mut this, "maximumFractionDigits", "I", 3).await?;
223        jvm.put_field(&mut this, "minimumFractionDigits", "I", 0).await
224    }
225
226    async fn format_object(
227        jvm: &Jvm,
228        _: &mut RuntimeContext,
229        this: ClassInstanceRef<Self>,
230        object: ClassInstanceRef<Object>,
231        buffer: ClassInstanceRef<StringBuffer>,
232        position: ClassInstanceRef<FieldPosition>,
233    ) -> Result<ClassInstanceRef<StringBuffer>> {
234        if object.is_null() || !jvm.is_instance(&**object, "java/lang/Number") {
235            return Err(jvm
236                .exception("java/lang/IllegalArgumentException", "Cannot format given Object as a Number")
237                .await);
238        }
239        if buffer.is_null() || position.is_null() {
240            return Err(jvm.exception("java/lang/NullPointerException", "buffer or position").await);
241        }
242
243        if jvm.is_instance(&**object, "java/lang/Byte")
244            || jvm.is_instance(&**object, "java/lang/Short")
245            || jvm.is_instance(&**object, "java/lang/Integer")
246            || jvm.is_instance(&**object, "java/lang/Long")
247        {
248            let value: i64 = jvm.invoke_virtual(&object, "java/lang/Number", "longValue", "()J", ()).await?;
249            return jvm
250                .invoke_virtual(
251                    &this,
252                    "java/text/NumberFormat",
253                    "format",
254                    "(JLjava/lang/StringBuffer;Ljava/text/FieldPosition;)Ljava/lang/StringBuffer;",
255                    (value, buffer, position),
256                )
257                .await;
258        }
259
260        let value: f64 = jvm.invoke_virtual(&object, "java/lang/Number", "doubleValue", "()D", ()).await?;
261        jvm.invoke_virtual(
262            &this,
263            "java/text/NumberFormat",
264            "format",
265            "(DLjava/lang/StringBuffer;Ljava/text/FieldPosition;)Ljava/lang/StringBuffer;",
266            (value, buffer, position),
267        )
268        .await
269    }
270
271    async fn format_double(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f64) -> Result<ClassInstanceRef<String>> {
272        let buffer: ClassInstanceRef<StringBuffer> = jvm.new_class("java/lang/StringBuffer", "()V", ()).await?.into();
273        let position: ClassInstanceRef<FieldPosition> = jvm.new_class("java/text/FieldPosition", "(I)V", (0,)).await?.into();
274        let buffer: ClassInstanceRef<StringBuffer> = jvm
275            .invoke_virtual(
276                &this,
277                "java/text/NumberFormat",
278                "format",
279                "(DLjava/lang/StringBuffer;Ljava/text/FieldPosition;)Ljava/lang/StringBuffer;",
280                (value, buffer, position),
281            )
282            .await?;
283        jvm.invoke_virtual(&buffer, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
284            .await
285    }
286
287    async fn format_long(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i64) -> Result<ClassInstanceRef<String>> {
288        let buffer: ClassInstanceRef<StringBuffer> = jvm.new_class("java/lang/StringBuffer", "()V", ()).await?.into();
289        let position: ClassInstanceRef<FieldPosition> = jvm.new_class("java/text/FieldPosition", "(I)V", (0,)).await?.into();
290        let buffer: ClassInstanceRef<StringBuffer> = jvm
291            .invoke_virtual(
292                &this,
293                "java/text/NumberFormat",
294                "format",
295                "(JLjava/lang/StringBuffer;Ljava/text/FieldPosition;)Ljava/lang/StringBuffer;",
296                (value, buffer, position),
297            )
298            .await?;
299        jvm.invoke_virtual(&buffer, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
300            .await
301    }
302
303    async fn parse(
304        jvm: &Jvm,
305        _: &mut RuntimeContext,
306        this: ClassInstanceRef<Self>,
307        source: ClassInstanceRef<String>,
308    ) -> Result<ClassInstanceRef<Number>> {
309        if source.is_null() {
310            return Err(jvm.exception("java/lang/NullPointerException", "source").await);
311        }
312        let position: ClassInstanceRef<ParsePosition> = jvm.new_class("java/text/ParsePosition", "(I)V", (0,)).await?.into();
313        let result: ClassInstanceRef<Number> = jvm
314            .invoke_virtual(
315                &this,
316                "java/text/NumberFormat",
317                "parse",
318                "(Ljava/lang/String;Ljava/text/ParsePosition;)Ljava/lang/Number;",
319                (source, position.clone()),
320            )
321            .await?;
322        let index: i32 = jvm.invoke_virtual(&position, "java/text/ParsePosition", "getIndex", "()I", ()).await?;
323        if index == 0 {
324            let error_index: i32 = jvm
325                .invoke_virtual(&position, "java/text/ParsePosition", "getErrorIndex", "()I", ())
326                .await?;
327            let message = JavaLangString::from_rust_string(jvm, "Unparseable number").await?;
328            let exception: ClassInstanceRef<ParseException> = jvm
329                .new_class("java/text/ParseException", "(Ljava/lang/String;I)V", (message, error_index))
330                .await?
331                .into();
332            return Err(JavaError::JavaException(exception.into()));
333        }
334        Ok(result)
335    }
336
337    async fn parse_object(
338        jvm: &Jvm,
339        _: &mut RuntimeContext,
340        this: ClassInstanceRef<Self>,
341        source: ClassInstanceRef<String>,
342        position: ClassInstanceRef<ParsePosition>,
343    ) -> Result<ClassInstanceRef<Object>> {
344        let number: ClassInstanceRef<Number> = jvm
345            .invoke_virtual(
346                &this,
347                "java/text/NumberFormat",
348                "parse",
349                "(Ljava/lang/String;Ljava/text/ParsePosition;)Ljava/lang/Number;",
350                (source, position),
351            )
352            .await?;
353        Ok(ClassInstanceRef::new(number.instance))
354    }
355
356    async fn get_instance(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Self>> {
357        jvm.invoke_static("java/text/NumberFormat", "getNumberInstance", "()Ljava/text/NumberFormat;", ())
358            .await
359    }
360
361    async fn get_instance_with_locale(jvm: &Jvm, _: &mut RuntimeContext, locale: ClassInstanceRef<Locale>) -> Result<ClassInstanceRef<Self>> {
362        jvm.invoke_static(
363            "java/text/NumberFormat",
364            "getNumberInstance",
365            "(Ljava/util/Locale;)Ljava/text/NumberFormat;",
366            (locale,),
367        )
368        .await
369    }
370
371    async fn get_number_instance(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Self>> {
372        let locale: ClassInstanceRef<Locale> = jvm.invoke_static("java/util/Locale", "getDefault", "()Ljava/util/Locale;", ()).await?;
373        jvm.invoke_static(
374            "java/text/NumberFormat",
375            "getNumberInstance",
376            "(Ljava/util/Locale;)Ljava/text/NumberFormat;",
377            (locale,),
378        )
379        .await
380    }
381
382    async fn get_number_instance_with_locale(jvm: &Jvm, _: &mut RuntimeContext, locale: ClassInstanceRef<Locale>) -> Result<ClassInstanceRef<Self>> {
383        if locale.is_null() {
384            return Err(jvm.exception("java/lang/NullPointerException", "locale").await);
385        }
386        let pattern = JavaLangString::from_rust_string(jvm, "#,##0.###").await?;
387        Ok(jvm
388            .new_class("java/text/DecimalFormat", "(Ljava/lang/String;)V", (pattern,))
389            .await?
390            .into())
391    }
392
393    async fn get_integer_instance(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Self>> {
394        let locale: ClassInstanceRef<Locale> = jvm.invoke_static("java/util/Locale", "getDefault", "()Ljava/util/Locale;", ()).await?;
395        jvm.invoke_static(
396            "java/text/NumberFormat",
397            "getIntegerInstance",
398            "(Ljava/util/Locale;)Ljava/text/NumberFormat;",
399            (locale,),
400        )
401        .await
402    }
403
404    async fn get_integer_instance_with_locale(jvm: &Jvm, _: &mut RuntimeContext, locale: ClassInstanceRef<Locale>) -> Result<ClassInstanceRef<Self>> {
405        if locale.is_null() {
406            return Err(jvm.exception("java/lang/NullPointerException", "locale").await);
407        }
408        let pattern = JavaLangString::from_rust_string(jvm, "#,##0").await?;
409        let format: ClassInstanceRef<Self> = jvm
410            .new_class("java/text/DecimalFormat", "(Ljava/lang/String;)V", (pattern,))
411            .await?
412            .into();
413        let _: () = jvm
414            .invoke_virtual(&format, "java/text/NumberFormat", "setParseIntegerOnly", "(Z)V", (true,))
415            .await?;
416        Ok(format)
417    }
418
419    async fn get_currency_instance(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Self>> {
420        let locale: ClassInstanceRef<Locale> = jvm.invoke_static("java/util/Locale", "getDefault", "()Ljava/util/Locale;", ()).await?;
421        jvm.invoke_static(
422            "java/text/NumberFormat",
423            "getCurrencyInstance",
424            "(Ljava/util/Locale;)Ljava/text/NumberFormat;",
425            (locale,),
426        )
427        .await
428    }
429
430    async fn get_currency_instance_with_locale(
431        jvm: &Jvm,
432        _: &mut RuntimeContext,
433        locale: ClassInstanceRef<Locale>,
434    ) -> Result<ClassInstanceRef<Self>> {
435        if locale.is_null() {
436            return Err(jvm.exception("java/lang/NullPointerException", "locale").await);
437        }
438        let pattern = JavaLangString::from_rust_string(jvm, "\u{00a4}#,##0.00;-\u{00a4}#,##0.00").await?;
439        Ok(jvm
440            .new_class("java/text/DecimalFormat", "(Ljava/lang/String;)V", (pattern,))
441            .await?
442            .into())
443    }
444
445    async fn get_percent_instance(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Self>> {
446        let locale: ClassInstanceRef<Locale> = jvm.invoke_static("java/util/Locale", "getDefault", "()Ljava/util/Locale;", ()).await?;
447        jvm.invoke_static(
448            "java/text/NumberFormat",
449            "getPercentInstance",
450            "(Ljava/util/Locale;)Ljava/text/NumberFormat;",
451            (locale,),
452        )
453        .await
454    }
455
456    async fn get_percent_instance_with_locale(jvm: &Jvm, _: &mut RuntimeContext, locale: ClassInstanceRef<Locale>) -> Result<ClassInstanceRef<Self>> {
457        if locale.is_null() {
458            return Err(jvm.exception("java/lang/NullPointerException", "locale").await);
459        }
460        let pattern = JavaLangString::from_rust_string(jvm, "#,##0%").await?;
461        Ok(jvm
462            .new_class("java/text/DecimalFormat", "(Ljava/lang/String;)V", (pattern,))
463            .await?
464            .into())
465    }
466
467    async fn get_available_locales(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Array<Locale>>> {
468        jvm.invoke_static("java/util/Locale", "getAvailableLocales", "()[Ljava/util/Locale;", ())
469            .await
470    }
471
472    async fn is_grouping_used(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
473        jvm.get_field(&this, "groupingUsed", "Z").await
474    }
475
476    async fn set_grouping_used(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: bool) -> Result<()> {
477        jvm.put_field(&mut this, "groupingUsed", "Z", value).await
478    }
479
480    async fn is_parse_integer_only(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
481        jvm.get_field(&this, "parseIntegerOnly", "Z").await
482    }
483
484    async fn set_parse_integer_only(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: bool) -> Result<()> {
485        jvm.put_field(&mut this, "parseIntegerOnly", "Z", value).await
486    }
487
488    async fn get_maximum_integer_digits(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
489        jvm.get_field(&this, "maximumIntegerDigits", "I").await
490    }
491
492    async fn set_maximum_integer_digits(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: i32) -> Result<()> {
493        let value = value.max(0);
494        jvm.put_field(&mut this, "maximumIntegerDigits", "I", value).await?;
495        let minimum: i32 = jvm.get_field(&this, "minimumIntegerDigits", "I").await?;
496        if minimum > value {
497            jvm.put_field(&mut this, "minimumIntegerDigits", "I", value).await?;
498        }
499        Ok(())
500    }
501
502    async fn get_minimum_integer_digits(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
503        jvm.get_field(&this, "minimumIntegerDigits", "I").await
504    }
505
506    async fn set_minimum_integer_digits(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: i32) -> Result<()> {
507        let value = value.max(0);
508        jvm.put_field(&mut this, "minimumIntegerDigits", "I", value).await?;
509        let maximum: i32 = jvm.get_field(&this, "maximumIntegerDigits", "I").await?;
510        if maximum < value {
511            jvm.put_field(&mut this, "maximumIntegerDigits", "I", value).await?;
512        }
513        Ok(())
514    }
515
516    async fn get_maximum_fraction_digits(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
517        jvm.get_field(&this, "maximumFractionDigits", "I").await
518    }
519
520    async fn set_maximum_fraction_digits(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: i32) -> Result<()> {
521        let value = value.max(0);
522        jvm.put_field(&mut this, "maximumFractionDigits", "I", value).await?;
523        let minimum: i32 = jvm.get_field(&this, "minimumFractionDigits", "I").await?;
524        if minimum > value {
525            jvm.put_field(&mut this, "minimumFractionDigits", "I", value).await?;
526        }
527        Ok(())
528    }
529
530    async fn get_minimum_fraction_digits(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
531        jvm.get_field(&this, "minimumFractionDigits", "I").await
532    }
533
534    async fn set_minimum_fraction_digits(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: i32) -> Result<()> {
535        let value = value.max(0);
536        jvm.put_field(&mut this, "minimumFractionDigits", "I", value).await?;
537        let maximum: i32 = jvm.get_field(&this, "maximumFractionDigits", "I").await?;
538        if maximum < value {
539            jvm.put_field(&mut this, "maximumFractionDigits", "I", value).await?;
540        }
541        Ok(())
542    }
543
544    async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<bool> {
545        if other.is_null() || !jvm.is_instance(&**other, "java/text/NumberFormat") {
546            return Ok(false);
547        }
548        let other: ClassInstanceRef<Self> = ClassInstanceRef::new(other.instance);
549        for (name, descriptor) in [
550            ("groupingUsed", "Z"),
551            ("parseIntegerOnly", "Z"),
552            ("maximumIntegerDigits", "I"),
553            ("minimumIntegerDigits", "I"),
554            ("maximumFractionDigits", "I"),
555            ("minimumFractionDigits", "I"),
556        ] {
557            if descriptor == "Z" {
558                let value: bool = jvm.get_field(&this, name, descriptor).await?;
559                let other_value: bool = jvm.get_field(&other, name, descriptor).await?;
560                if value != other_value {
561                    return Ok(false);
562                }
563            } else {
564                let value: i32 = jvm.get_field(&this, name, descriptor).await?;
565                let other_value: i32 = jvm.get_field(&other, name, descriptor).await?;
566                if value != other_value {
567                    return Ok(false);
568                }
569            }
570        }
571        Ok(true)
572    }
573
574    async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
575        let maximum_integer_digits: i32 = jvm.get_field(&this, "maximumIntegerDigits", "I").await?;
576        let maximum_fraction_digits: i32 = jvm.get_field(&this, "maximumFractionDigits", "I").await?;
577        Ok(maximum_integer_digits * 37 + maximum_fraction_digits)
578    }
579}