Skip to main content

rustjava_runtime/classes/java/text/
decimal_format.rs

1use alloc::{
2    format,
3    string::{String as RustString, ToString},
4    vec,
5    vec::Vec,
6};
7
8use jvm::{ClassInstanceRef, Jvm, Result, runtime::JavaLangString};
9use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
10use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
11
12use crate::{
13    RuntimeClassProto, RuntimeContext,
14    classes::java::{
15        lang::{Double, Long, Number, String, StringBuffer},
16        text::{FieldPosition, ParsePosition},
17    },
18};
19
20struct DecimalPattern {
21    positive_prefix: RustString,
22    positive_suffix: RustString,
23    negative_prefix: RustString,
24    negative_suffix: RustString,
25    minimum_integer_digits: i32,
26    maximum_fraction_digits: i32,
27    minimum_fraction_digits: i32,
28    grouping_used: bool,
29    grouping_size: i32,
30    multiplier: i32,
31}
32
33// public class java.text.DecimalFormat
34pub struct DecimalFormat;
35
36impl DecimalFormat {
37    pub fn as_proto() -> RuntimeClassProto {
38        RuntimeClassProto {
39            name: "java/text/DecimalFormat",
40            parent_class: Some("java/text/NumberFormat"),
41            interfaces: vec![],
42            methods: vec![
43                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
44                JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init_with_pattern, MethodAccessFlags::PUBLIC),
45                JavaMethodProto::new(
46                    "format",
47                    "(DLjava/lang/StringBuffer;Ljava/text/FieldPosition;)Ljava/lang/StringBuffer;",
48                    Self::format_double,
49                    MethodAccessFlags::PUBLIC,
50                ),
51                JavaMethodProto::new(
52                    "format",
53                    "(JLjava/lang/StringBuffer;Ljava/text/FieldPosition;)Ljava/lang/StringBuffer;",
54                    Self::format_long,
55                    MethodAccessFlags::PUBLIC,
56                ),
57                JavaMethodProto::new(
58                    "parse",
59                    "(Ljava/lang/String;Ljava/text/ParsePosition;)Ljava/lang/Number;",
60                    Self::parse,
61                    MethodAccessFlags::PUBLIC,
62                ),
63                JavaMethodProto::new("applyPattern", "(Ljava/lang/String;)V", Self::apply_pattern, MethodAccessFlags::PUBLIC),
64                JavaMethodProto::new("toPattern", "()Ljava/lang/String;", Self::to_pattern, MethodAccessFlags::PUBLIC),
65                JavaMethodProto::new("getMultiplier", "()I", Self::get_multiplier, MethodAccessFlags::PUBLIC),
66                JavaMethodProto::new("setMultiplier", "(I)V", Self::set_multiplier, MethodAccessFlags::PUBLIC),
67            ],
68            fields: vec![
69                JavaFieldProto::new("pattern", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
70                JavaFieldProto::new("positivePrefix", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
71                JavaFieldProto::new("positiveSuffix", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
72                JavaFieldProto::new("negativePrefix", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
73                JavaFieldProto::new("negativeSuffix", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
74                JavaFieldProto::new("multiplier", "I", FieldAccessFlags::PRIVATE),
75                JavaFieldProto::new("groupingSize", "I", FieldAccessFlags::PRIVATE),
76            ],
77            access_flags: ClassAccessFlags::PUBLIC,
78        }
79    }
80
81    fn parse_affix(value: &[char]) -> Option<(RustString, bool)> {
82        let mut result = RustString::new();
83        let mut percent = false;
84        let mut quoted = false;
85        let mut index = 0;
86        while index < value.len() {
87            if value[index] == '\'' {
88                if index + 1 < value.len() && value[index + 1] == '\'' {
89                    result.push('\'');
90                    index += 2;
91                    continue;
92                }
93                quoted = !quoted;
94                index += 1;
95                continue;
96            }
97            if !quoted && value[index] == '\u{00a4}' {
98                result.push('$');
99            } else {
100                if !quoted && value[index] == '%' {
101                    percent = true;
102                }
103                result.push(value[index]);
104            }
105            index += 1;
106        }
107        if quoted { None } else { Some((result, percent)) }
108    }
109
110    fn parse_subpattern(value: &[char]) -> Option<(RustString, Vec<char>, RustString, bool)> {
111        let mut quoted = false;
112        let mut numeric_start = None;
113        let mut index = 0;
114        while index < value.len() {
115            if value[index] == '\'' {
116                if index + 1 < value.len() && value[index + 1] == '\'' {
117                    index += 2;
118                    continue;
119                }
120                quoted = !quoted;
121            } else if !quoted && matches!(value[index], '#' | '0') {
122                numeric_start = Some(index);
123                break;
124            }
125            index += 1;
126        }
127        let numeric_start = numeric_start?;
128        let mut numeric_end = numeric_start;
129        while numeric_end < value.len() && matches!(value[numeric_end], '#' | '0' | ',' | '.') {
130            numeric_end += 1;
131        }
132        quoted = false;
133        index = numeric_end;
134        while index < value.len() {
135            if value[index] == '\'' {
136                if index + 1 < value.len() && value[index + 1] == '\'' {
137                    index += 2;
138                    continue;
139                }
140                quoted = !quoted;
141            } else if !quoted && matches!(value[index], '#' | '0' | ',' | '.') {
142                return None;
143            }
144            index += 1;
145        }
146        let (prefix, prefix_percent) = Self::parse_affix(&value[..numeric_start])?;
147        let (suffix, suffix_percent) = Self::parse_affix(&value[numeric_end..])?;
148        Some((
149            prefix,
150            value[numeric_start..numeric_end].to_vec(),
151            suffix,
152            prefix_percent || suffix_percent,
153        ))
154    }
155
156    fn parse_pattern_value(pattern: &str) -> Option<DecimalPattern> {
157        let characters: Vec<char> = pattern.chars().collect();
158        let mut quoted = false;
159        let mut separator = None;
160        let mut index = 0;
161        while index < characters.len() {
162            if characters[index] == '\'' {
163                if index + 1 < characters.len() && characters[index + 1] == '\'' {
164                    index += 2;
165                    continue;
166                }
167                quoted = !quoted;
168            } else if !quoted && characters[index] == ';' {
169                if separator.is_some() {
170                    return None;
171                }
172                separator = Some(index);
173            }
174            index += 1;
175        }
176        if quoted || characters.is_empty() {
177            return None;
178        }
179
180        let positive = &characters[..separator.unwrap_or(characters.len())];
181        let (positive_prefix, number, positive_suffix, positive_percent) = Self::parse_subpattern(positive)?;
182        if number.iter().filter(|character| **character == '.').count() > 1 {
183            return None;
184        }
185        let decimal_index = number.iter().position(|character| *character == '.').unwrap_or(number.len());
186        let integer_pattern = &number[..decimal_index];
187        let fraction_pattern = if decimal_index < number.len() {
188            &number[decimal_index + 1..]
189        } else {
190            &[]
191        };
192        if integer_pattern.is_empty()
193            || integer_pattern.iter().any(|character| !matches!(character, '#' | '0' | ','))
194            || fraction_pattern.iter().any(|character| !matches!(character, '#' | '0'))
195        {
196            return None;
197        }
198        let minimum_integer_digits = integer_pattern.iter().filter(|character| **character == '0').count() as i32;
199        let maximum_fraction_digits = fraction_pattern.len() as i32;
200        let minimum_fraction_digits = fraction_pattern.iter().filter(|character| **character == '0').count() as i32;
201        let grouping_position = integer_pattern.iter().rposition(|character| *character == ',');
202        let grouping_size = grouping_position
203            .map(|position| {
204                integer_pattern[position + 1..]
205                    .iter()
206                    .filter(|character| matches!(character, '#' | '0'))
207                    .count() as i32
208            })
209            .unwrap_or(0);
210        if grouping_position.is_some() && grouping_size == 0 {
211            return None;
212        }
213
214        let (negative_prefix, negative_suffix, negative_percent) = if let Some(separator) = separator {
215            let (prefix, negative_number, suffix, percent) = Self::parse_subpattern(&characters[separator + 1..])?;
216            if negative_number != number {
217                return None;
218            }
219            (prefix, suffix, percent)
220        } else {
221            (format!("-{positive_prefix}"), positive_suffix.clone(), positive_percent)
222        };
223
224        Some(DecimalPattern {
225            positive_prefix,
226            positive_suffix,
227            negative_prefix,
228            negative_suffix,
229            minimum_integer_digits,
230            maximum_fraction_digits,
231            minimum_fraction_digits,
232            grouping_used: grouping_position.is_some(),
233            grouping_size,
234            multiplier: if positive_percent || negative_percent { 100 } else { 1 },
235        })
236    }
237
238    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
239        let pattern = JavaLangString::from_rust_string(jvm, "#,##0.###").await?;
240        jvm.invoke_special(&this, "java/text/DecimalFormat", "<init>", "(Ljava/lang/String;)V", (pattern,))
241            .await
242    }
243
244    async fn init_with_pattern(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, pattern: ClassInstanceRef<String>) -> Result<()> {
245        if pattern.is_null() {
246            return Err(jvm.exception("java/lang/NullPointerException", "pattern").await);
247        }
248        let _: () = jvm.invoke_special(&this, "java/text/NumberFormat", "<init>", "()V", ()).await?;
249        jvm.invoke_virtual(&this, "java/text/DecimalFormat", "applyPattern", "(Ljava/lang/String;)V", (pattern,))
250            .await
251    }
252
253    async fn apply_pattern(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, pattern: ClassInstanceRef<String>) -> Result<()> {
254        if pattern.is_null() {
255            return Err(jvm.exception("java/lang/NullPointerException", "pattern").await);
256        }
257        let value = JavaLangString::to_rust_string(jvm, &pattern).await?;
258        let Some(parsed) = Self::parse_pattern_value(&value) else {
259            return Err(jvm.exception("java/lang/IllegalArgumentException", "Malformed pattern").await);
260        };
261
262        let positive_prefix = JavaLangString::from_rust_string(jvm, &parsed.positive_prefix).await?;
263        let positive_suffix = JavaLangString::from_rust_string(jvm, &parsed.positive_suffix).await?;
264        let negative_prefix = JavaLangString::from_rust_string(jvm, &parsed.negative_prefix).await?;
265        let negative_suffix = JavaLangString::from_rust_string(jvm, &parsed.negative_suffix).await?;
266        jvm.put_field(&mut this, "pattern", "Ljava/lang/String;", pattern).await?;
267        jvm.put_field(&mut this, "positivePrefix", "Ljava/lang/String;", positive_prefix).await?;
268        jvm.put_field(&mut this, "positiveSuffix", "Ljava/lang/String;", positive_suffix).await?;
269        jvm.put_field(&mut this, "negativePrefix", "Ljava/lang/String;", negative_prefix).await?;
270        jvm.put_field(&mut this, "negativeSuffix", "Ljava/lang/String;", negative_suffix).await?;
271        jvm.put_field(&mut this, "multiplier", "I", parsed.multiplier).await?;
272        jvm.put_field(&mut this, "groupingSize", "I", parsed.grouping_size).await?;
273        jvm.put_field(&mut this, "groupingUsed", "Z", parsed.grouping_used).await?;
274        jvm.put_field(&mut this, "maximumIntegerDigits", "I", 309).await?;
275        jvm.put_field(&mut this, "minimumIntegerDigits", "I", parsed.minimum_integer_digits)
276            .await?;
277        jvm.put_field(&mut this, "maximumFractionDigits", "I", parsed.maximum_fraction_digits)
278            .await?;
279        jvm.put_field(&mut this, "minimumFractionDigits", "I", parsed.minimum_fraction_digits)
280            .await
281    }
282
283    async fn append_formatted(
284        jvm: &Jvm,
285        this: &ClassInstanceRef<Self>,
286        negative: bool,
287        mut integer: RustString,
288        mut fraction: RustString,
289        buffer: ClassInstanceRef<StringBuffer>,
290        position: ClassInstanceRef<FieldPosition>,
291    ) -> Result<ClassInstanceRef<StringBuffer>> {
292        if buffer.is_null() || position.is_null() {
293            return Err(jvm.exception("java/lang/NullPointerException", "buffer or position").await);
294        }
295        let minimum_integer_digits: i32 = jvm.get_field(this, "minimumIntegerDigits", "I").await?;
296        let maximum_integer_digits: i32 = jvm.get_field(this, "maximumIntegerDigits", "I").await?;
297        let minimum_fraction_digits: i32 = jvm.get_field(this, "minimumFractionDigits", "I").await?;
298        let grouping_used: bool = jvm.get_field(this, "groupingUsed", "Z").await?;
299        let grouping_size: i32 = jvm.get_field(this, "groupingSize", "I").await?;
300
301        if integer.len() > maximum_integer_digits.max(0) as usize {
302            integer = integer[integer.len() - maximum_integer_digits.max(0) as usize..].to_string();
303        }
304        while integer.len() < minimum_integer_digits.max(0) as usize {
305            integer.insert(0, '0');
306        }
307        if integer.is_empty() {
308            integer.push('0');
309        }
310        if grouping_used && grouping_size > 0 {
311            let mut grouped = RustString::new();
312            for (index, character) in integer.chars().rev().enumerate() {
313                if index > 0 && index % grouping_size as usize == 0 {
314                    grouped.push(',');
315                }
316                grouped.push(character);
317            }
318            integer = grouped.chars().rev().collect();
319        }
320        while fraction.ends_with('0') && fraction.len() > minimum_fraction_digits.max(0) as usize {
321            fraction.pop();
322        }
323        while fraction.len() < minimum_fraction_digits.max(0) as usize {
324            fraction.push('0');
325        }
326
327        let prefix: ClassInstanceRef<String> = jvm
328            .get_field(this, if negative { "negativePrefix" } else { "positivePrefix" }, "Ljava/lang/String;")
329            .await?;
330        let suffix: ClassInstanceRef<String> = jvm
331            .get_field(this, if negative { "negativeSuffix" } else { "positiveSuffix" }, "Ljava/lang/String;")
332            .await?;
333        let prefix = JavaLangString::to_rust_string(jvm, &prefix).await?;
334        let suffix = JavaLangString::to_rust_string(jvm, &suffix).await?;
335        let mut formatted = format!("{prefix}{integer}");
336        if !fraction.is_empty() {
337            formatted.push('.');
338            formatted.push_str(&fraction);
339        }
340        formatted.push_str(&suffix);
341
342        let base: i32 = jvm.invoke_virtual(&buffer, "java/lang/StringBuffer", "length", "()I", ()).await?;
343        let field: i32 = jvm.invoke_virtual(&position, "java/text/FieldPosition", "getField", "()I", ()).await?;
344        if field == 0 {
345            let begin = base + prefix.encode_utf16().count() as i32;
346            let _: () = jvm
347                .invoke_virtual(&position, "java/text/FieldPosition", "setBeginIndex", "(I)V", (begin,))
348                .await?;
349            let _: () = jvm
350                .invoke_virtual(
351                    &position,
352                    "java/text/FieldPosition",
353                    "setEndIndex",
354                    "(I)V",
355                    (begin + integer.encode_utf16().count() as i32,),
356                )
357                .await?;
358        } else if field == 1 && !fraction.is_empty() {
359            let begin = base + prefix.encode_utf16().count() as i32 + integer.encode_utf16().count() as i32 + 1;
360            let _: () = jvm
361                .invoke_virtual(&position, "java/text/FieldPosition", "setBeginIndex", "(I)V", (begin,))
362                .await?;
363            let _: () = jvm
364                .invoke_virtual(
365                    &position,
366                    "java/text/FieldPosition",
367                    "setEndIndex",
368                    "(I)V",
369                    (begin + fraction.encode_utf16().count() as i32,),
370                )
371                .await?;
372        }
373
374        let text = JavaLangString::from_rust_string(jvm, &formatted).await?;
375        jvm.invoke_virtual(
376            &buffer,
377            "java/lang/StringBuffer",
378            "append",
379            "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
380            (text,),
381        )
382        .await
383    }
384
385    async fn format_double(
386        jvm: &Jvm,
387        _: &mut RuntimeContext,
388        this: ClassInstanceRef<Self>,
389        value: f64,
390        buffer: ClassInstanceRef<StringBuffer>,
391        position: ClassInstanceRef<FieldPosition>,
392    ) -> Result<ClassInstanceRef<StringBuffer>> {
393        if buffer.is_null() || position.is_null() {
394            return Err(jvm.exception("java/lang/NullPointerException", "buffer or position").await);
395        }
396        if value.is_nan() {
397            let text = JavaLangString::from_rust_string(jvm, "NaN").await?;
398            return jvm
399                .invoke_virtual(
400                    &buffer,
401                    "java/lang/StringBuffer",
402                    "append",
403                    "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
404                    (text,),
405                )
406                .await;
407        }
408
409        let negative = value.is_sign_negative();
410        let multiplier: i32 = jvm.get_field(&this, "multiplier", "I").await?;
411        let scaled = value.abs() * f64::from(multiplier);
412        if scaled.is_infinite() {
413            return Self::append_formatted(jvm, &this, negative, "\u{221e}".to_string(), RustString::new(), buffer, position).await;
414        }
415        let maximum_fraction_digits: i32 = jvm.get_field(&this, "maximumFractionDigits", "I").await?;
416        let precision = maximum_fraction_digits.clamp(0, 340) as usize;
417        let numeric = format!("{scaled:.precision$}");
418        let (integer, fraction) = numeric
419            .split_once('.')
420            .map(|(integer, fraction)| (integer.to_string(), fraction.to_string()))
421            .unwrap_or((numeric, RustString::new()));
422        Self::append_formatted(jvm, &this, negative, integer, fraction, buffer, position).await
423    }
424
425    async fn format_long(
426        jvm: &Jvm,
427        _: &mut RuntimeContext,
428        this: ClassInstanceRef<Self>,
429        value: i64,
430        buffer: ClassInstanceRef<StringBuffer>,
431        position: ClassInstanceRef<FieldPosition>,
432    ) -> Result<ClassInstanceRef<StringBuffer>> {
433        let multiplier: i32 = jvm.get_field(&this, "multiplier", "I").await?;
434        let scaled = i128::from(value) * i128::from(multiplier);
435        let negative = scaled < 0;
436        Self::append_formatted(
437            jvm,
438            &this,
439            negative,
440            scaled.unsigned_abs().to_string(),
441            RustString::new(),
442            buffer,
443            position,
444        )
445        .await
446    }
447
448    async fn parse(
449        jvm: &Jvm,
450        _: &mut RuntimeContext,
451        this: ClassInstanceRef<Self>,
452        source: ClassInstanceRef<String>,
453        position: ClassInstanceRef<ParsePosition>,
454    ) -> Result<ClassInstanceRef<Number>> {
455        if source.is_null() || position.is_null() {
456            return Err(jvm.exception("java/lang/NullPointerException", "source or position").await);
457        }
458        let source = JavaLangString::to_rust_string(jvm, &source).await?;
459        let characters: Vec<char> = source.chars().collect();
460        let mut utf16_indices = Vec::with_capacity(characters.len() + 1);
461        let mut utf16_index = 0;
462        for character in &characters {
463            utf16_indices.push(utf16_index);
464            utf16_index += character.len_utf16();
465        }
466        utf16_indices.push(utf16_index);
467        let start: i32 = jvm.invoke_virtual(&position, "java/text/ParsePosition", "getIndex", "()I", ()).await?;
468        if start < 0 {
469            let _: () = jvm
470                .invoke_virtual(&position, "java/text/ParsePosition", "setErrorIndex", "(I)V", (start,))
471                .await?;
472            return Ok(ClassInstanceRef::new(None));
473        }
474        let Some(start_index) = utf16_indices.iter().position(|index| *index == start as usize) else {
475            let _: () = jvm
476                .invoke_virtual(&position, "java/text/ParsePosition", "setErrorIndex", "(I)V", (start,))
477                .await?;
478            return Ok(ClassInstanceRef::new(None));
479        };
480
481        let positive_prefix: ClassInstanceRef<String> = jvm.get_field(&this, "positivePrefix", "Ljava/lang/String;").await?;
482        let positive_suffix: ClassInstanceRef<String> = jvm.get_field(&this, "positiveSuffix", "Ljava/lang/String;").await?;
483        let negative_prefix: ClassInstanceRef<String> = jvm.get_field(&this, "negativePrefix", "Ljava/lang/String;").await?;
484        let negative_suffix: ClassInstanceRef<String> = jvm.get_field(&this, "negativeSuffix", "Ljava/lang/String;").await?;
485        let positive_prefix: Vec<char> = JavaLangString::to_rust_string(jvm, &positive_prefix).await?.chars().collect();
486        let positive_suffix: Vec<char> = JavaLangString::to_rust_string(jvm, &positive_suffix).await?.chars().collect();
487        let negative_prefix: Vec<char> = JavaLangString::to_rust_string(jvm, &negative_prefix).await?.chars().collect();
488        let negative_suffix: Vec<char> = JavaLangString::to_rust_string(jvm, &negative_suffix).await?.chars().collect();
489
490        let mut index = start_index;
491        let prefix_negative = if characters[index..].starts_with(&negative_prefix) && negative_prefix != positive_prefix {
492            index += negative_prefix.len();
493            true
494        } else if characters[index..].starts_with(&positive_prefix) {
495            index += positive_prefix.len();
496            false
497        } else {
498            let _: () = jvm
499                .invoke_virtual(&position, "java/text/ParsePosition", "setErrorIndex", "(I)V", (start,))
500                .await?;
501            return Ok(ClassInstanceRef::new(None));
502        };
503
504        let parse_integer_only: bool = jvm.get_field(&this, "parseIntegerOnly", "Z").await?;
505        let mut normalized = RustString::new();
506        let mut digits = 0;
507        let mut decimal = false;
508        while index < characters.len() {
509            match characters[index] {
510                '0'..='9' => {
511                    normalized.push(characters[index]);
512                    digits += 1;
513                    index += 1;
514                }
515                ',' if !decimal => index += 1,
516                '.' if !decimal && !parse_integer_only => {
517                    normalized.push('.');
518                    decimal = true;
519                    index += 1;
520                }
521                _ => break,
522            }
523        }
524        if digits == 0 {
525            let _: () = jvm
526                .invoke_virtual(
527                    &position,
528                    "java/text/ParsePosition",
529                    "setErrorIndex",
530                    "(I)V",
531                    (utf16_indices[index] as i32,),
532                )
533                .await?;
534            return Ok(ClassInstanceRef::new(None));
535        }
536        let negative = if negative_prefix == positive_prefix {
537            let positive_matches = characters[index..].starts_with(&positive_suffix);
538            let negative_matches = characters[index..].starts_with(&negative_suffix);
539            if negative_matches && (!positive_matches || negative_suffix.len() > positive_suffix.len()) {
540                index += negative_suffix.len();
541                true
542            } else if positive_matches {
543                index += positive_suffix.len();
544                false
545            } else {
546                let _: () = jvm
547                    .invoke_virtual(
548                        &position,
549                        "java/text/ParsePosition",
550                        "setErrorIndex",
551                        "(I)V",
552                        (utf16_indices[index] as i32,),
553                    )
554                    .await?;
555                return Ok(ClassInstanceRef::new(None));
556            }
557        } else {
558            let suffix = if prefix_negative { &negative_suffix } else { &positive_suffix };
559            if !characters[index..].starts_with(suffix) {
560                let _: () = jvm
561                    .invoke_virtual(
562                        &position,
563                        "java/text/ParsePosition",
564                        "setErrorIndex",
565                        "(I)V",
566                        (utf16_indices[index] as i32,),
567                    )
568                    .await?;
569                return Ok(ClassInstanceRef::new(None));
570            }
571            index += suffix.len();
572            prefix_negative
573        };
574        if negative {
575            normalized.insert(0, '-');
576        }
577
578        let Ok(mut value) = normalized.parse::<f64>() else {
579            let _: () = jvm
580                .invoke_virtual(&position, "java/text/ParsePosition", "setErrorIndex", "(I)V", (start,))
581                .await?;
582            return Ok(ClassInstanceRef::new(None));
583        };
584        let multiplier: i32 = jvm.get_field(&this, "multiplier", "I").await?;
585        if multiplier != 0 {
586            value /= f64::from(multiplier);
587        }
588        let _: () = jvm
589            .invoke_virtual(&position, "java/text/ParsePosition", "setIndex", "(I)V", (utf16_indices[index] as i32,))
590            .await?;
591        let _: () = jvm
592            .invoke_virtual(&position, "java/text/ParsePosition", "setErrorIndex", "(I)V", (-1,))
593            .await?;
594
595        if multiplier == 1
596            && !decimal
597            && let Ok(value) = normalized.parse::<i64>()
598        {
599            let result: ClassInstanceRef<Long> = jvm.new_class("java/lang/Long", "(J)V", (value,)).await?.into();
600            return Ok(ClassInstanceRef::new(result.instance));
601        }
602        if value.is_finite() && value.fract() == 0.0 && (-9_223_372_036_854_775_808.0..9_223_372_036_854_775_808.0).contains(&value) {
603            let result: ClassInstanceRef<Long> = jvm.new_class("java/lang/Long", "(J)V", (value as i64,)).await?.into();
604            return Ok(ClassInstanceRef::new(result.instance));
605        }
606        let result: ClassInstanceRef<Double> = jvm.new_class("java/lang/Double", "(D)V", (value,)).await?.into();
607        Ok(ClassInstanceRef::new(result.instance))
608    }
609
610    async fn to_pattern(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
611        jvm.get_field(&this, "pattern", "Ljava/lang/String;").await
612    }
613
614    async fn get_multiplier(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
615        jvm.get_field(&this, "multiplier", "I").await
616    }
617
618    async fn set_multiplier(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, multiplier: i32) -> Result<()> {
619        jvm.put_field(&mut this, "multiplier", "I", multiplier).await
620    }
621}