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
33pub 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, "java/text/DecimalFormat", "pattern", "Ljava/lang/String;", pattern)
267 .await?;
268 jvm.put_field(
269 &mut this,
270 "java/text/DecimalFormat",
271 "positivePrefix",
272 "Ljava/lang/String;",
273 positive_prefix,
274 )
275 .await?;
276 jvm.put_field(
277 &mut this,
278 "java/text/DecimalFormat",
279 "positiveSuffix",
280 "Ljava/lang/String;",
281 positive_suffix,
282 )
283 .await?;
284 jvm.put_field(
285 &mut this,
286 "java/text/DecimalFormat",
287 "negativePrefix",
288 "Ljava/lang/String;",
289 negative_prefix,
290 )
291 .await?;
292 jvm.put_field(
293 &mut this,
294 "java/text/DecimalFormat",
295 "negativeSuffix",
296 "Ljava/lang/String;",
297 negative_suffix,
298 )
299 .await?;
300 jvm.put_field(&mut this, "java/text/DecimalFormat", "multiplier", "I", parsed.multiplier)
301 .await?;
302 jvm.put_field(&mut this, "java/text/DecimalFormat", "groupingSize", "I", parsed.grouping_size)
303 .await?;
304 jvm.put_field(&mut this, "java/text/DecimalFormat", "groupingUsed", "Z", parsed.grouping_used)
305 .await?;
306 jvm.put_field(&mut this, "java/text/DecimalFormat", "maximumIntegerDigits", "I", 309)
307 .await?;
308 jvm.put_field(
309 &mut this,
310 "java/text/DecimalFormat",
311 "minimumIntegerDigits",
312 "I",
313 parsed.minimum_integer_digits,
314 )
315 .await?;
316 jvm.put_field(
317 &mut this,
318 "java/text/DecimalFormat",
319 "maximumFractionDigits",
320 "I",
321 parsed.maximum_fraction_digits,
322 )
323 .await?;
324 jvm.put_field(
325 &mut this,
326 "java/text/DecimalFormat",
327 "minimumFractionDigits",
328 "I",
329 parsed.minimum_fraction_digits,
330 )
331 .await
332 }
333
334 async fn append_formatted(
335 jvm: &Jvm,
336 this: &ClassInstanceRef<Self>,
337 negative: bool,
338 mut integer: RustString,
339 mut fraction: RustString,
340 buffer: ClassInstanceRef<StringBuffer>,
341 position: ClassInstanceRef<FieldPosition>,
342 ) -> Result<ClassInstanceRef<StringBuffer>> {
343 if buffer.is_null() || position.is_null() {
344 return Err(jvm.exception("java/lang/NullPointerException", "buffer or position").await);
345 }
346 let minimum_integer_digits: i32 = jvm.get_field(this, "java/text/DecimalFormat", "minimumIntegerDigits", "I").await?;
347 let maximum_integer_digits: i32 = jvm.get_field(this, "java/text/DecimalFormat", "maximumIntegerDigits", "I").await?;
348 let minimum_fraction_digits: i32 = jvm.get_field(this, "java/text/DecimalFormat", "minimumFractionDigits", "I").await?;
349 let grouping_used: bool = jvm.get_field(this, "java/text/DecimalFormat", "groupingUsed", "Z").await?;
350 let grouping_size: i32 = jvm.get_field(this, "java/text/DecimalFormat", "groupingSize", "I").await?;
351
352 if integer.len() > maximum_integer_digits.max(0) as usize {
353 integer = integer[integer.len() - maximum_integer_digits.max(0) as usize..].to_string();
354 }
355 while integer.len() < minimum_integer_digits.max(0) as usize {
356 integer.insert(0, '0');
357 }
358 if integer.is_empty() {
359 integer.push('0');
360 }
361 if grouping_used && grouping_size > 0 {
362 let mut grouped = RustString::new();
363 for (index, character) in integer.chars().rev().enumerate() {
364 if index > 0 && index % grouping_size as usize == 0 {
365 grouped.push(',');
366 }
367 grouped.push(character);
368 }
369 integer = grouped.chars().rev().collect();
370 }
371 while fraction.ends_with('0') && fraction.len() > minimum_fraction_digits.max(0) as usize {
372 fraction.pop();
373 }
374 while fraction.len() < minimum_fraction_digits.max(0) as usize {
375 fraction.push('0');
376 }
377
378 let prefix: ClassInstanceRef<String> = jvm
379 .get_field(
380 this,
381 "java/text/DecimalFormat",
382 if negative { "negativePrefix" } else { "positivePrefix" },
383 "Ljava/lang/String;",
384 )
385 .await?;
386 let suffix: ClassInstanceRef<String> = jvm
387 .get_field(
388 this,
389 "java/text/DecimalFormat",
390 if negative { "negativeSuffix" } else { "positiveSuffix" },
391 "Ljava/lang/String;",
392 )
393 .await?;
394 let prefix = JavaLangString::to_rust_string(jvm, &prefix).await?;
395 let suffix = JavaLangString::to_rust_string(jvm, &suffix).await?;
396 let mut formatted = format!("{prefix}{integer}");
397 if !fraction.is_empty() {
398 formatted.push('.');
399 formatted.push_str(&fraction);
400 }
401 formatted.push_str(&suffix);
402
403 let base: i32 = jvm.invoke_virtual(&buffer, "java/lang/StringBuffer", "length", "()I", ()).await?;
404 let field: i32 = jvm.invoke_virtual(&position, "java/text/FieldPosition", "getField", "()I", ()).await?;
405 if field == 0 {
406 let begin = base + prefix.encode_utf16().count() as i32;
407 let _: () = jvm
408 .invoke_virtual(&position, "java/text/FieldPosition", "setBeginIndex", "(I)V", (begin,))
409 .await?;
410 let _: () = jvm
411 .invoke_virtual(
412 &position,
413 "java/text/FieldPosition",
414 "setEndIndex",
415 "(I)V",
416 (begin + integer.encode_utf16().count() as i32,),
417 )
418 .await?;
419 } else if field == 1 && !fraction.is_empty() {
420 let begin = base + prefix.encode_utf16().count() as i32 + integer.encode_utf16().count() as i32 + 1;
421 let _: () = jvm
422 .invoke_virtual(&position, "java/text/FieldPosition", "setBeginIndex", "(I)V", (begin,))
423 .await?;
424 let _: () = jvm
425 .invoke_virtual(
426 &position,
427 "java/text/FieldPosition",
428 "setEndIndex",
429 "(I)V",
430 (begin + fraction.encode_utf16().count() as i32,),
431 )
432 .await?;
433 }
434
435 let text = JavaLangString::from_rust_string(jvm, &formatted).await?;
436 jvm.invoke_virtual(
437 &buffer,
438 "java/lang/StringBuffer",
439 "append",
440 "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
441 (text,),
442 )
443 .await
444 }
445
446 async fn format_double(
447 jvm: &Jvm,
448 _: &mut RuntimeContext,
449 this: ClassInstanceRef<Self>,
450 value: f64,
451 buffer: ClassInstanceRef<StringBuffer>,
452 position: ClassInstanceRef<FieldPosition>,
453 ) -> Result<ClassInstanceRef<StringBuffer>> {
454 if buffer.is_null() || position.is_null() {
455 return Err(jvm.exception("java/lang/NullPointerException", "buffer or position").await);
456 }
457 if value.is_nan() {
458 let text = JavaLangString::from_rust_string(jvm, "NaN").await?;
459 return jvm
460 .invoke_virtual(
461 &buffer,
462 "java/lang/StringBuffer",
463 "append",
464 "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
465 (text,),
466 )
467 .await;
468 }
469
470 let negative = value.is_sign_negative();
471 let multiplier: i32 = jvm.get_field(&this, "java/text/DecimalFormat", "multiplier", "I").await?;
472 let scaled = value.abs() * f64::from(multiplier);
473 if scaled.is_infinite() {
474 return Self::append_formatted(jvm, &this, negative, "\u{221e}".to_string(), RustString::new(), buffer, position).await;
475 }
476 let maximum_fraction_digits: i32 = jvm.get_field(&this, "java/text/DecimalFormat", "maximumFractionDigits", "I").await?;
477 let precision = maximum_fraction_digits.clamp(0, 340) as usize;
478 let numeric = format!("{scaled:.precision$}");
479 let (integer, fraction) = numeric
480 .split_once('.')
481 .map(|(integer, fraction)| (integer.to_string(), fraction.to_string()))
482 .unwrap_or((numeric, RustString::new()));
483 Self::append_formatted(jvm, &this, negative, integer, fraction, buffer, position).await
484 }
485
486 async fn format_long(
487 jvm: &Jvm,
488 _: &mut RuntimeContext,
489 this: ClassInstanceRef<Self>,
490 value: i64,
491 buffer: ClassInstanceRef<StringBuffer>,
492 position: ClassInstanceRef<FieldPosition>,
493 ) -> Result<ClassInstanceRef<StringBuffer>> {
494 let multiplier: i32 = jvm.get_field(&this, "java/text/DecimalFormat", "multiplier", "I").await?;
495 let scaled = i128::from(value) * i128::from(multiplier);
496 let negative = scaled < 0;
497 Self::append_formatted(
498 jvm,
499 &this,
500 negative,
501 scaled.unsigned_abs().to_string(),
502 RustString::new(),
503 buffer,
504 position,
505 )
506 .await
507 }
508
509 async fn parse(
510 jvm: &Jvm,
511 _: &mut RuntimeContext,
512 this: ClassInstanceRef<Self>,
513 source: ClassInstanceRef<String>,
514 position: ClassInstanceRef<ParsePosition>,
515 ) -> Result<ClassInstanceRef<Number>> {
516 if source.is_null() || position.is_null() {
517 return Err(jvm.exception("java/lang/NullPointerException", "source or position").await);
518 }
519 let source = JavaLangString::to_rust_string(jvm, &source).await?;
520 let characters: Vec<char> = source.chars().collect();
521 let mut utf16_indices = Vec::with_capacity(characters.len() + 1);
522 let mut utf16_index = 0;
523 for character in &characters {
524 utf16_indices.push(utf16_index);
525 utf16_index += character.len_utf16();
526 }
527 utf16_indices.push(utf16_index);
528 let start: i32 = jvm.invoke_virtual(&position, "java/text/ParsePosition", "getIndex", "()I", ()).await?;
529 if start < 0 {
530 let _: () = jvm
531 .invoke_virtual(&position, "java/text/ParsePosition", "setErrorIndex", "(I)V", (start,))
532 .await?;
533 return Ok(ClassInstanceRef::new(None));
534 }
535 let Some(start_index) = utf16_indices.iter().position(|index| *index == start as usize) else {
536 let _: () = jvm
537 .invoke_virtual(&position, "java/text/ParsePosition", "setErrorIndex", "(I)V", (start,))
538 .await?;
539 return Ok(ClassInstanceRef::new(None));
540 };
541
542 let positive_prefix: ClassInstanceRef<String> = jvm
543 .get_field(&this, "java/text/DecimalFormat", "positivePrefix", "Ljava/lang/String;")
544 .await?;
545 let positive_suffix: ClassInstanceRef<String> = jvm
546 .get_field(&this, "java/text/DecimalFormat", "positiveSuffix", "Ljava/lang/String;")
547 .await?;
548 let negative_prefix: ClassInstanceRef<String> = jvm
549 .get_field(&this, "java/text/DecimalFormat", "negativePrefix", "Ljava/lang/String;")
550 .await?;
551 let negative_suffix: ClassInstanceRef<String> = jvm
552 .get_field(&this, "java/text/DecimalFormat", "negativeSuffix", "Ljava/lang/String;")
553 .await?;
554 let positive_prefix: Vec<char> = JavaLangString::to_rust_string(jvm, &positive_prefix).await?.chars().collect();
555 let positive_suffix: Vec<char> = JavaLangString::to_rust_string(jvm, &positive_suffix).await?.chars().collect();
556 let negative_prefix: Vec<char> = JavaLangString::to_rust_string(jvm, &negative_prefix).await?.chars().collect();
557 let negative_suffix: Vec<char> = JavaLangString::to_rust_string(jvm, &negative_suffix).await?.chars().collect();
558
559 let mut index = start_index;
560 let prefix_negative = if characters[index..].starts_with(&negative_prefix) && negative_prefix != positive_prefix {
561 index += negative_prefix.len();
562 true
563 } else if characters[index..].starts_with(&positive_prefix) {
564 index += positive_prefix.len();
565 false
566 } else {
567 let _: () = jvm
568 .invoke_virtual(&position, "java/text/ParsePosition", "setErrorIndex", "(I)V", (start,))
569 .await?;
570 return Ok(ClassInstanceRef::new(None));
571 };
572
573 let parse_integer_only: bool = jvm.get_field(&this, "java/text/DecimalFormat", "parseIntegerOnly", "Z").await?;
574 let mut normalized = RustString::new();
575 let mut digits = 0;
576 let mut decimal = false;
577 while index < characters.len() {
578 match characters[index] {
579 '0'..='9' => {
580 normalized.push(characters[index]);
581 digits += 1;
582 index += 1;
583 }
584 ',' if !decimal => index += 1,
585 '.' if !decimal && !parse_integer_only => {
586 normalized.push('.');
587 decimal = true;
588 index += 1;
589 }
590 _ => break,
591 }
592 }
593 if digits == 0 {
594 let _: () = jvm
595 .invoke_virtual(
596 &position,
597 "java/text/ParsePosition",
598 "setErrorIndex",
599 "(I)V",
600 (utf16_indices[index] as i32,),
601 )
602 .await?;
603 return Ok(ClassInstanceRef::new(None));
604 }
605 let negative = if negative_prefix == positive_prefix {
606 let positive_matches = characters[index..].starts_with(&positive_suffix);
607 let negative_matches = characters[index..].starts_with(&negative_suffix);
608 if negative_matches && (!positive_matches || negative_suffix.len() > positive_suffix.len()) {
609 index += negative_suffix.len();
610 true
611 } else if positive_matches {
612 index += positive_suffix.len();
613 false
614 } else {
615 let _: () = jvm
616 .invoke_virtual(
617 &position,
618 "java/text/ParsePosition",
619 "setErrorIndex",
620 "(I)V",
621 (utf16_indices[index] as i32,),
622 )
623 .await?;
624 return Ok(ClassInstanceRef::new(None));
625 }
626 } else {
627 let suffix = if prefix_negative { &negative_suffix } else { &positive_suffix };
628 if !characters[index..].starts_with(suffix) {
629 let _: () = jvm
630 .invoke_virtual(
631 &position,
632 "java/text/ParsePosition",
633 "setErrorIndex",
634 "(I)V",
635 (utf16_indices[index] as i32,),
636 )
637 .await?;
638 return Ok(ClassInstanceRef::new(None));
639 }
640 index += suffix.len();
641 prefix_negative
642 };
643 if negative {
644 normalized.insert(0, '-');
645 }
646
647 let Ok(mut value) = normalized.parse::<f64>() else {
648 let _: () = jvm
649 .invoke_virtual(&position, "java/text/ParsePosition", "setErrorIndex", "(I)V", (start,))
650 .await?;
651 return Ok(ClassInstanceRef::new(None));
652 };
653 let multiplier: i32 = jvm.get_field(&this, "java/text/DecimalFormat", "multiplier", "I").await?;
654 if multiplier != 0 {
655 value /= f64::from(multiplier);
656 }
657 let _: () = jvm
658 .invoke_virtual(&position, "java/text/ParsePosition", "setIndex", "(I)V", (utf16_indices[index] as i32,))
659 .await?;
660 let _: () = jvm
661 .invoke_virtual(&position, "java/text/ParsePosition", "setErrorIndex", "(I)V", (-1,))
662 .await?;
663
664 if multiplier == 1
665 && !decimal
666 && let Ok(value) = normalized.parse::<i64>()
667 {
668 let result: ClassInstanceRef<Long> = jvm.new_class("java/lang/Long", "(J)V", (value,)).await?.into();
669 return Ok(ClassInstanceRef::new(result.instance));
670 }
671 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) {
672 let result: ClassInstanceRef<Long> = jvm.new_class("java/lang/Long", "(J)V", (value as i64,)).await?.into();
673 return Ok(ClassInstanceRef::new(result.instance));
674 }
675 let result: ClassInstanceRef<Double> = jvm.new_class("java/lang/Double", "(D)V", (value,)).await?.into();
676 Ok(ClassInstanceRef::new(result.instance))
677 }
678
679 async fn to_pattern(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
680 jvm.get_field(&this, "java/text/DecimalFormat", "pattern", "Ljava/lang/String;").await
681 }
682
683 async fn get_multiplier(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
684 jvm.get_field(&this, "java/text/DecimalFormat", "multiplier", "I").await
685 }
686
687 async fn set_multiplier(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, multiplier: i32) -> Result<()> {
688 jvm.put_field(&mut this, "java/text/DecimalFormat", "multiplier", "I", multiplier).await
689 }
690}