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, "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}