1use alloc::{format, string::String as RustString, vec, vec::Vec};
2
3use chrono::{DateTime, Datelike, NaiveDate, TimeZone as ChronoTimeZone, Timelike, Utc};
4use jvm::{ClassInstanceRef, Jvm, Result, runtime::JavaLangString};
5use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
6use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
7
8use crate::{
9 RuntimeClassProto, RuntimeContext,
10 classes::java::{
11 lang::{String, StringBuffer},
12 text::{FieldPosition, ParsePosition},
13 util::{Calendar, Date, Locale, TimeZone},
14 },
15};
16
17#[derive(Clone)]
18enum DateToken {
19 Literal(RustString),
20 Field(char, usize),
21}
22
23pub struct SimpleDateFormat;
25
26impl SimpleDateFormat {
27 pub fn as_proto() -> RuntimeClassProto {
28 RuntimeClassProto {
29 name: "java/text/SimpleDateFormat",
30 parent_class: Some("java/text/DateFormat"),
31 interfaces: vec![],
32 methods: vec![
33 JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
34 JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init_with_pattern, MethodAccessFlags::PUBLIC),
35 JavaMethodProto::new(
36 "<init>",
37 "(Ljava/lang/String;Ljava/util/Locale;)V",
38 Self::init_with_pattern_and_locale,
39 MethodAccessFlags::PUBLIC,
40 ),
41 JavaMethodProto::new(
42 "format",
43 "(Ljava/util/Date;Ljava/lang/StringBuffer;Ljava/text/FieldPosition;)Ljava/lang/StringBuffer;",
44 Self::format,
45 MethodAccessFlags::PUBLIC,
46 ),
47 JavaMethodProto::new(
48 "parse",
49 "(Ljava/lang/String;Ljava/text/ParsePosition;)Ljava/util/Date;",
50 Self::parse,
51 MethodAccessFlags::PUBLIC,
52 ),
53 JavaMethodProto::new("applyPattern", "(Ljava/lang/String;)V", Self::apply_pattern, MethodAccessFlags::PUBLIC),
54 JavaMethodProto::new("toPattern", "()Ljava/lang/String;", Self::to_pattern, MethodAccessFlags::PUBLIC),
55 ],
56 fields: vec![JavaFieldProto::new("pattern", "Ljava/lang/String;", FieldAccessFlags::PRIVATE)],
57 access_flags: ClassAccessFlags::PUBLIC,
58 }
59 }
60
61 fn tokenize_pattern(pattern: &str) -> Option<Vec<DateToken>> {
62 let characters: Vec<char> = pattern.chars().collect();
63 let mut tokens = Vec::new();
64 let mut literal = RustString::new();
65 let mut quoted = false;
66 let mut index = 0;
67 while index < characters.len() {
68 let character = characters[index];
69 if character == '\'' {
70 if index + 1 < characters.len() && characters[index + 1] == '\'' {
71 literal.push('\'');
72 index += 2;
73 continue;
74 }
75 quoted = !quoted;
76 index += 1;
77 continue;
78 }
79 if !quoted && character.is_ascii_alphabetic() {
80 if !matches!(
81 character,
82 'G' | 'y' | 'M' | 'd' | 'h' | 'H' | 'm' | 's' | 'S' | 'E' | 'D' | 'F' | 'w' | 'W' | 'a' | 'k' | 'K' | 'z'
83 ) {
84 return None;
85 }
86 if !literal.is_empty() {
87 tokens.push(DateToken::Literal(core::mem::take(&mut literal)));
88 }
89 let mut count = 1;
90 while index + count < characters.len() && characters[index + count] == character {
91 count += 1;
92 }
93 tokens.push(DateToken::Field(character, count));
94 index += count;
95 continue;
96 }
97 literal.push(character);
98 index += 1;
99 }
100 if quoted {
101 return None;
102 }
103 if !literal.is_empty() {
104 tokens.push(DateToken::Literal(literal));
105 }
106 Some(tokens)
107 }
108
109 fn parse_number(characters: &[char], index: &mut usize, maximum_digits: Option<usize>) -> Option<i32> {
110 let start = *index;
111 let mut value = 0i32;
112 while *index < characters.len() && characters[*index].is_ascii_digit() && maximum_digits.is_none_or(|maximum| *index - start < maximum) {
113 value = value.checked_mul(10)?.checked_add(characters[*index].to_digit(10)? as i32)?;
114 *index += 1;
115 }
116 if *index == start { None } else { Some(value) }
117 }
118
119 fn starts_with_ignore_ascii_case(characters: &[char], index: usize, value: &str) -> bool {
120 let value: Vec<char> = value.chars().collect();
121 characters
122 .get(index..index + value.len())
123 .is_some_and(|candidate| candidate.iter().zip(value).all(|(left, right)| left.eq_ignore_ascii_case(&right)))
124 }
125
126 fn parse_timestamp(tokens: &[DateToken], characters: &[char], start: usize, default_offset: i32) -> core::result::Result<(i64, usize), usize> {
127 let months = [
128 ("January", "Jan"),
129 ("February", "Feb"),
130 ("March", "Mar"),
131 ("April", "Apr"),
132 ("May", "May"),
133 ("June", "Jun"),
134 ("July", "Jul"),
135 ("August", "Aug"),
136 ("September", "Sep"),
137 ("October", "Oct"),
138 ("November", "Nov"),
139 ("December", "Dec"),
140 ];
141 let weekdays = [
142 ("Sunday", "Sun"),
143 ("Monday", "Mon"),
144 ("Tuesday", "Tue"),
145 ("Wednesday", "Wed"),
146 ("Thursday", "Thu"),
147 ("Friday", "Fri"),
148 ("Saturday", "Sat"),
149 ];
150
151 let mut index = start;
152 let mut era = 1;
153 let mut year = 1970;
154 let mut month = 1;
155 let mut day = 1;
156 let mut ordinal = None;
157 let mut month_set = false;
158 let mut day_set = false;
159 let mut hour = 0;
160 let mut twelve_hour = None;
161 let mut am_pm = 0;
162 let mut minute = 0;
163 let mut second = 0;
164 let mut millisecond = 0;
165 let mut offset = default_offset;
166
167 for token in tokens {
168 match token {
169 DateToken::Literal(literal) => {
170 let value: Vec<char> = literal.chars().collect();
171 if !characters[index..].starts_with(&value) {
172 return Err(index);
173 }
174 index += value.len();
175 }
176 DateToken::Field(character, count) => match character {
177 'G' => {
178 if Self::starts_with_ignore_ascii_case(characters, index, "AD") {
179 era = 1;
180 index += 2;
181 } else if Self::starts_with_ignore_ascii_case(characters, index, "BC") {
182 era = 0;
183 index += 2;
184 } else {
185 return Err(index);
186 }
187 }
188 'y' => {
189 let value = Self::parse_number(characters, &mut index, if *count > 1 { Some(*count) } else { None }).ok_or(index)?;
190 year = if *count == 2 {
191 if value <= 69 { 2000 + value } else { 1900 + value }
192 } else {
193 value
194 };
195 }
196 'M' if *count >= 3 => {
197 let mut parsed = None;
198 for (position, (full, short)) in months.iter().enumerate() {
199 let candidate = if *count >= 4 { *full } else { *short };
200 if Self::starts_with_ignore_ascii_case(characters, index, candidate) {
201 parsed = Some((position as i32 + 1, candidate.len()));
202 break;
203 }
204 }
205 let Some((value, length)) = parsed else {
206 return Err(index);
207 };
208 month = value;
209 month_set = true;
210 index += length;
211 }
212 'M' => {
213 month = Self::parse_number(characters, &mut index, if *count > 1 { Some(*count) } else { None }).ok_or(index)?;
214 month_set = true;
215 }
216 'd' => {
217 day = Self::parse_number(characters, &mut index, if *count > 1 { Some(*count) } else { None }).ok_or(index)?;
218 day_set = true;
219 }
220 'H' => hour = Self::parse_number(characters, &mut index, if *count > 1 { Some(*count) } else { None }).ok_or(index)?,
221 'k' => {
222 let value = Self::parse_number(characters, &mut index, if *count > 1 { Some(*count) } else { None }).ok_or(index)?;
223 if !(1..=24).contains(&value) {
224 return Err(index);
225 }
226 hour = value % 24;
227 }
228 'h' | 'K' => {
229 let value = Self::parse_number(characters, &mut index, if *count > 1 { Some(*count) } else { None }).ok_or(index)?;
230 twelve_hour = Some((*character, value));
231 }
232 'm' => minute = Self::parse_number(characters, &mut index, if *count > 1 { Some(*count) } else { None }).ok_or(index)?,
233 's' => second = Self::parse_number(characters, &mut index, if *count > 1 { Some(*count) } else { None }).ok_or(index)?,
234 'S' => millisecond = Self::parse_number(characters, &mut index, Some((*count).max(1))).ok_or(index)?,
235 'E' => {
236 let mut consumed = None;
237 for (full, short) in weekdays {
238 for candidate in [full, short] {
239 if Self::starts_with_ignore_ascii_case(characters, index, candidate) {
240 consumed = Some(candidate.len());
241 break;
242 }
243 }
244 if consumed.is_some() {
245 break;
246 }
247 }
248 let Some(length) = consumed else {
249 return Err(index);
250 };
251 index += length;
252 }
253 'D' => ordinal = Some(Self::parse_number(characters, &mut index, if *count > 1 { Some(*count) } else { None }).ok_or(index)?),
254 'F' | 'w' | 'W' => {
255 let _ = Self::parse_number(characters, &mut index, if *count > 1 { Some(*count) } else { None }).ok_or(index)?;
256 }
257 'a' => {
258 if Self::starts_with_ignore_ascii_case(characters, index, "AM") {
259 am_pm = 0;
260 index += 2;
261 } else if Self::starts_with_ignore_ascii_case(characters, index, "PM") {
262 am_pm = 1;
263 index += 2;
264 } else {
265 return Err(index);
266 }
267 }
268 'z' => {
269 if Self::starts_with_ignore_ascii_case(characters, index, "GMT")
270 || Self::starts_with_ignore_ascii_case(characters, index, "UTC")
271 {
272 index += 3;
273 } else {
274 return Err(index);
275 }
276 offset = 0;
277 if index < characters.len() && matches!(characters[index], '+' | '-') {
278 let sign = if characters[index] == '-' { -1 } else { 1 };
279 index += 1;
280 let hours = Self::parse_number(characters, &mut index, Some(2)).ok_or(index)?;
281 if index >= characters.len() || characters[index] != ':' {
282 return Err(index);
283 }
284 index += 1;
285 let minutes = Self::parse_number(characters, &mut index, Some(2)).ok_or(index)?;
286 if hours > 23 || minutes > 59 {
287 return Err(index);
288 }
289 offset = sign * (hours * 60 + minutes) * 60 * 1000;
290 }
291 }
292 _ => return Err(index),
293 },
294 }
295 }
296
297 if let Some((kind, value)) = twelve_hour {
298 hour = match kind {
299 'h' if (1..=12).contains(&value) => value % 12 + am_pm * 12,
300 'K' if (0..=11).contains(&value) => value + am_pm * 12,
301 _ => return Err(index),
302 };
303 }
304 if era == 0 {
305 year = 1 - year;
306 }
307 if let Some(ordinal) = ordinal.filter(|_| !month_set && !day_set) {
308 let Some(date) = NaiveDate::from_yo_opt(year, ordinal as u32) else {
309 return Err(index);
310 };
311 month = date.month() as i32;
312 day = date.day() as i32;
313 }
314 if !(1..=12).contains(&month)
315 || !(1..=31).contains(&day)
316 || !(0..=23).contains(&hour)
317 || !(0..=59).contains(&minute)
318 || !(0..=59).contains(&second)
319 || !(0..=999).contains(&millisecond)
320 {
321 return Err(index);
322 }
323 let Some(date_time) = Utc
324 .with_ymd_and_hms(year, month as u32, day as u32, hour as u32, minute as u32, second as u32)
325 .single()
326 else {
327 return Err(index);
328 };
329 let Some(timestamp) = date_time
330 .timestamp_millis()
331 .checked_add(i64::from(millisecond))
332 .and_then(|value| value.checked_sub(i64::from(offset)))
333 else {
334 return Err(index);
335 };
336 Ok((timestamp, index))
337 }
338
339 fn date_field(character: char) -> Option<i32> {
340 match character {
341 'G' => Some(0),
342 'y' => Some(1),
343 'M' => Some(2),
344 'd' => Some(3),
345 'k' => Some(4),
346 'H' => Some(5),
347 'm' => Some(6),
348 's' => Some(7),
349 'S' => Some(8),
350 'E' => Some(9),
351 'D' => Some(10),
352 'F' => Some(11),
353 'w' => Some(12),
354 'W' => Some(13),
355 'a' => Some(14),
356 'h' => Some(15),
357 'K' => Some(16),
358 'z' => Some(17),
359 _ => None,
360 }
361 }
362
363 async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
364 let pattern = JavaLangString::from_rust_string(jvm, "M/d/yy h:mm a").await?;
365 jvm.invoke_special(&this, "java/text/SimpleDateFormat", "<init>", "(Ljava/lang/String;)V", (pattern,))
366 .await
367 }
368
369 async fn init_with_pattern(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, pattern: ClassInstanceRef<String>) -> Result<()> {
370 let locale: ClassInstanceRef<Locale> = jvm.invoke_static("java/util/Locale", "getDefault", "()Ljava/util/Locale;", ()).await?;
371 jvm.invoke_special(
372 &this,
373 "java/text/SimpleDateFormat",
374 "<init>",
375 "(Ljava/lang/String;Ljava/util/Locale;)V",
376 (pattern, locale),
377 )
378 .await
379 }
380
381 async fn init_with_pattern_and_locale(
382 jvm: &Jvm,
383 _: &mut RuntimeContext,
384 mut this: ClassInstanceRef<Self>,
385 pattern: ClassInstanceRef<String>,
386 locale: ClassInstanceRef<Locale>,
387 ) -> Result<()> {
388 if pattern.is_null() || locale.is_null() {
389 return Err(jvm.exception("java/lang/NullPointerException", "pattern or locale").await);
390 }
391 let value = JavaLangString::to_rust_string(jvm, &pattern).await?;
392 if Self::tokenize_pattern(&value).is_none() {
393 return Err(jvm.exception("java/lang/IllegalArgumentException", "Illegal pattern character").await);
394 }
395 let _: () = jvm.invoke_special(&this, "java/text/DateFormat", "<init>", "()V", ()).await?;
396 jvm.put_field(&mut this, "pattern", "Ljava/lang/String;", pattern).await
397 }
398
399 async fn apply_pattern(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, pattern: ClassInstanceRef<String>) -> Result<()> {
400 if pattern.is_null() {
401 return Err(jvm.exception("java/lang/NullPointerException", "pattern").await);
402 }
403 let value = JavaLangString::to_rust_string(jvm, &pattern).await?;
404 if Self::tokenize_pattern(&value).is_none() {
405 return Err(jvm.exception("java/lang/IllegalArgumentException", "Illegal pattern character").await);
406 }
407 jvm.put_field(&mut this, "pattern", "Ljava/lang/String;", pattern).await
408 }
409
410 async fn to_pattern(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
411 jvm.get_field(&this, "pattern", "Ljava/lang/String;").await
412 }
413
414 async fn format(
415 jvm: &Jvm,
416 _: &mut RuntimeContext,
417 this: ClassInstanceRef<Self>,
418 date: ClassInstanceRef<Date>,
419 buffer: ClassInstanceRef<StringBuffer>,
420 position: ClassInstanceRef<FieldPosition>,
421 ) -> Result<ClassInstanceRef<StringBuffer>> {
422 if date.is_null() || buffer.is_null() || position.is_null() {
423 return Err(jvm.exception("java/lang/NullPointerException", "date, buffer, or position").await);
424 }
425 let pattern: ClassInstanceRef<String> = jvm.get_field(&this, "pattern", "Ljava/lang/String;").await?;
426 let pattern = JavaLangString::to_rust_string(jvm, &pattern).await?;
427 let Some(tokens) = Self::tokenize_pattern(&pattern) else {
428 return Err(jvm.exception("java/lang/IllegalArgumentException", "Illegal pattern").await);
429 };
430 let time: i64 = jvm.invoke_virtual(&date, "java/util/Date", "getTime", "()J", ()).await?;
431 let calendar: ClassInstanceRef<Calendar> = jvm.get_field(&this, "calendar", "Ljava/util/Calendar;").await?;
432 let time_zone: ClassInstanceRef<TimeZone> = jvm
433 .invoke_virtual(&calendar, "java/util/Calendar", "getTimeZone", "()Ljava/util/TimeZone;", ())
434 .await?;
435 let offset: i32 = jvm.invoke_virtual(&time_zone, "java/util/TimeZone", "getRawOffset", "()I", ()).await?;
436 let Some(adjusted) = time.checked_add(i64::from(offset)) else {
437 return Err(jvm.exception("java/lang/IllegalArgumentException", "date out of range").await);
438 };
439 let Some(date_time) = DateTime::<Utc>::from_timestamp_millis(adjusted) else {
440 return Err(jvm.exception("java/lang/IllegalArgumentException", "date out of range").await);
441 };
442
443 let months = [
444 "January",
445 "February",
446 "March",
447 "April",
448 "May",
449 "June",
450 "July",
451 "August",
452 "September",
453 "October",
454 "November",
455 "December",
456 ];
457 let short_months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
458 let weekdays = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
459 let short_weekdays = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
460 let requested_field: i32 = jvm.invoke_virtual(&position, "java/text/FieldPosition", "getField", "()I", ()).await?;
461 let base: i32 = jvm.invoke_virtual(&buffer, "java/lang/StringBuffer", "length", "()I", ()).await?;
462 let mut field_position_set = false;
463 let mut formatted = RustString::new();
464 for token in tokens {
465 match token {
466 DateToken::Literal(value) => formatted.push_str(&value),
467 DateToken::Field(character, count) => {
468 let begin = formatted.encode_utf16().count() as i32;
469 match character {
470 'G' => formatted.push_str(if date_time.year() <= 0 { "BC" } else { "AD" }),
471 'y' => {
472 let year = if date_time.year() <= 0 { 1 - date_time.year() } else { date_time.year() };
473 if count == 2 {
474 formatted.push_str(&format!("{:02}", year.rem_euclid(100)));
475 } else {
476 formatted.push_str(&format!("{year:0count$}"));
477 }
478 }
479 'M' if count >= 4 => formatted.push_str(months[date_time.month0() as usize]),
480 'M' if count == 3 => formatted.push_str(short_months[date_time.month0() as usize]),
481 'M' => formatted.push_str(&format!("{:0count$}", date_time.month())),
482 'd' => formatted.push_str(&format!("{:0count$}", date_time.day())),
483 'h' => {
484 let hour = date_time.hour() % 12;
485 formatted.push_str(&format!("{:0count$}", if hour == 0 { 12 } else { hour }));
486 }
487 'H' => formatted.push_str(&format!("{:0count$}", date_time.hour())),
488 'm' => formatted.push_str(&format!("{:0count$}", date_time.minute())),
489 's' => formatted.push_str(&format!("{:0count$}", date_time.second())),
490 'S' => formatted.push_str(&format!("{:0count$}", date_time.timestamp_subsec_millis())),
491 'E' if count >= 4 => formatted.push_str(weekdays[date_time.weekday().num_days_from_sunday() as usize]),
492 'E' => formatted.push_str(short_weekdays[date_time.weekday().num_days_from_sunday() as usize]),
493 'D' => formatted.push_str(&format!("{:0count$}", date_time.ordinal())),
494 'F' | 'W' => formatted.push_str(&format!("{:0count$}", (date_time.day() - 1) / 7 + 1)),
495 'w' => formatted.push_str(&format!("{:0count$}", date_time.iso_week().week())),
496 'a' => formatted.push_str(if date_time.hour() < 12 { "AM" } else { "PM" }),
497 'k' => formatted.push_str(&format!("{:0count$}", if date_time.hour() == 0 { 24 } else { date_time.hour() })),
498 'K' => formatted.push_str(&format!("{:0count$}", date_time.hour() % 12)),
499 'z' => {
500 if offset == 0 {
501 formatted.push_str("GMT");
502 } else {
503 let absolute = offset.unsigned_abs() / 60_000;
504 formatted.push_str(&format!(
505 "GMT{}{:02}:{:02}",
506 if offset < 0 { '-' } else { '+' },
507 absolute / 60,
508 absolute % 60
509 ));
510 }
511 }
512 _ => return Err(jvm.exception("java/lang/IllegalArgumentException", "Illegal pattern").await),
513 }
514 if !field_position_set && Self::date_field(character) == Some(requested_field) {
515 let _: () = jvm
516 .invoke_virtual(&position, "java/text/FieldPosition", "setBeginIndex", "(I)V", (base + begin,))
517 .await?;
518 let _: () = jvm
519 .invoke_virtual(
520 &position,
521 "java/text/FieldPosition",
522 "setEndIndex",
523 "(I)V",
524 (base + formatted.encode_utf16().count() as i32,),
525 )
526 .await?;
527 field_position_set = true;
528 }
529 }
530 }
531 }
532 let text = JavaLangString::from_rust_string(jvm, &formatted).await?;
533 jvm.invoke_virtual(
534 &buffer,
535 "java/lang/StringBuffer",
536 "append",
537 "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
538 (text,),
539 )
540 .await
541 }
542
543 async fn parse(
544 jvm: &Jvm,
545 _: &mut RuntimeContext,
546 this: ClassInstanceRef<Self>,
547 source: ClassInstanceRef<String>,
548 position: ClassInstanceRef<ParsePosition>,
549 ) -> Result<ClassInstanceRef<Date>> {
550 if source.is_null() || position.is_null() {
551 return Err(jvm.exception("java/lang/NullPointerException", "source or position").await);
552 }
553 let pattern: ClassInstanceRef<String> = jvm.get_field(&this, "pattern", "Ljava/lang/String;").await?;
554 let pattern = JavaLangString::to_rust_string(jvm, &pattern).await?;
555 let Some(tokens) = Self::tokenize_pattern(&pattern) else {
556 return Err(jvm.exception("java/lang/IllegalArgumentException", "Illegal pattern").await);
557 };
558 let source = JavaLangString::to_rust_string(jvm, &source).await?;
559 let characters: Vec<char> = source.chars().collect();
560 let mut utf16_indices = Vec::with_capacity(characters.len() + 1);
561 let mut utf16_index = 0;
562 for character in &characters {
563 utf16_indices.push(utf16_index);
564 utf16_index += character.len_utf16();
565 }
566 utf16_indices.push(utf16_index);
567 let start: i32 = jvm.invoke_virtual(&position, "java/text/ParsePosition", "getIndex", "()I", ()).await?;
568 if start < 0 {
569 let _: () = jvm
570 .invoke_virtual(&position, "java/text/ParsePosition", "setErrorIndex", "(I)V", (start,))
571 .await?;
572 return Ok(ClassInstanceRef::new(None));
573 }
574 let Some(start_index) = utf16_indices.iter().position(|index| *index == start as usize) else {
575 let _: () = jvm
576 .invoke_virtual(&position, "java/text/ParsePosition", "setErrorIndex", "(I)V", (start,))
577 .await?;
578 return Ok(ClassInstanceRef::new(None));
579 };
580 let calendar: ClassInstanceRef<Calendar> = jvm.get_field(&this, "calendar", "Ljava/util/Calendar;").await?;
581 let time_zone: ClassInstanceRef<TimeZone> = jvm
582 .invoke_virtual(&calendar, "java/util/Calendar", "getTimeZone", "()Ljava/util/TimeZone;", ())
583 .await?;
584 let offset: i32 = jvm.invoke_virtual(&time_zone, "java/util/TimeZone", "getRawOffset", "()I", ()).await?;
585 match Self::parse_timestamp(&tokens, &characters, start_index, offset) {
586 Ok((timestamp, index)) => {
587 let _: () = jvm
588 .invoke_virtual(&position, "java/text/ParsePosition", "setIndex", "(I)V", (utf16_indices[index] as i32,))
589 .await?;
590 let _: () = jvm
591 .invoke_virtual(&position, "java/text/ParsePosition", "setErrorIndex", "(I)V", (-1,))
592 .await?;
593 Ok(jvm.new_class("java/util/Date", "(J)V", (timestamp,)).await?.into())
594 }
595 Err(error_index) => {
596 let _: () = jvm
597 .invoke_virtual(
598 &position,
599 "java/text/ParsePosition",
600 "setErrorIndex",
601 "(I)V",
602 (utf16_indices[error_index] as i32,),
603 )
604 .await?;
605 Ok(ClassInstanceRef::new(None))
606 }
607 }
608 }
609}