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