Skip to main content

rustjava_runtime/classes/java/text/
simple_date_format.rs

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, 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
34// public class java.text.SimpleDateFormat
35pub 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) = NaiveDate::from_yo_opt(year, ordinal as u32) else {
334                return Err(DateParseError::Invalid(index));
335            };
336            month = date.month() as i32;
337            day = date.day() as i32;
338        }
339        if !(1..=12).contains(&month)
340            || !(1..=31).contains(&day)
341            || !(0..=23).contains(&hour)
342            || !(0..=59).contains(&minute)
343            || !(0..=59).contains(&second)
344            || !(0..=999).contains(&millisecond)
345        {
346            return Err(DateParseError::Invalid(index));
347        }
348        let Some(date_time) = Utc
349            .with_ymd_and_hms(year, month as u32, day as u32, hour as u32, minute as u32, second as u32)
350            .single()
351        else {
352            return Err(DateParseError::Invalid(index));
353        };
354        let Some(timestamp) = date_time
355            .timestamp_millis()
356            .checked_add(i64::from(millisecond))
357            .and_then(|value| value.checked_sub(i64::from(offset)))
358        else {
359            return Err(DateParseError::Invalid(index));
360        };
361        Ok((timestamp, index))
362    }
363
364    fn date_field(character: char) -> Option<i32> {
365        match character {
366            'G' => Some(0),
367            'y' => Some(1),
368            'M' => Some(2),
369            'd' => Some(3),
370            'k' => Some(4),
371            'H' => Some(5),
372            'm' => Some(6),
373            's' => Some(7),
374            'S' => Some(8),
375            'E' => Some(9),
376            'D' => Some(10),
377            'F' => Some(11),
378            'w' => Some(12),
379            'W' => Some(13),
380            'a' => Some(14),
381            'h' => Some(15),
382            'K' => Some(16),
383            'z' => Some(17),
384            _ => None,
385        }
386    }
387
388    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
389        let pattern = JavaLangString::from_rust_string(jvm, "M/d/yy h:mm a").await?;
390        jvm.invoke_special(&this, "java/text/SimpleDateFormat", "<init>", "(Ljava/lang/String;)V", (pattern,))
391            .await
392    }
393
394    async fn init_with_pattern(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, pattern: ClassInstanceRef<String>) -> Result<()> {
395        let locale: ClassInstanceRef<Locale> = jvm.invoke_static("java/util/Locale", "getDefault", "()Ljava/util/Locale;", ()).await?;
396        jvm.invoke_special(
397            &this,
398            "java/text/SimpleDateFormat",
399            "<init>",
400            "(Ljava/lang/String;Ljava/util/Locale;)V",
401            (pattern, locale),
402        )
403        .await
404    }
405
406    async fn init_with_pattern_and_locale(
407        jvm: &Jvm,
408        _: &mut RuntimeContext,
409        mut this: ClassInstanceRef<Self>,
410        pattern: ClassInstanceRef<String>,
411        locale: ClassInstanceRef<Locale>,
412    ) -> Result<()> {
413        if pattern.is_null() || locale.is_null() {
414            return Err(jvm.exception("java/lang/NullPointerException", "pattern or locale").await);
415        }
416        let value = JavaLangString::to_rust_string(jvm, &pattern).await?;
417        if Self::tokenize_pattern(&value).is_none() {
418            return Err(jvm.exception("java/lang/IllegalArgumentException", "Illegal pattern character").await);
419        }
420        let _: () = jvm.invoke_special(&this, "java/text/DateFormat", "<init>", "()V", ()).await?;
421        jvm.put_field(&mut this, "java/text/SimpleDateFormat", "pattern", "Ljava/lang/String;", pattern)
422            .await
423    }
424
425    async fn apply_pattern(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, pattern: ClassInstanceRef<String>) -> Result<()> {
426        if pattern.is_null() {
427            return Err(jvm.exception("java/lang/NullPointerException", "pattern").await);
428        }
429        let value = JavaLangString::to_rust_string(jvm, &pattern).await?;
430        if Self::tokenize_pattern(&value).is_none() {
431            return Err(jvm.exception("java/lang/IllegalArgumentException", "Illegal pattern character").await);
432        }
433        jvm.put_field(&mut this, "java/text/SimpleDateFormat", "pattern", "Ljava/lang/String;", pattern)
434            .await
435    }
436
437    async fn to_pattern(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
438        jvm.get_field(&this, "java/text/SimpleDateFormat", "pattern", "Ljava/lang/String;").await
439    }
440
441    async fn format(
442        jvm: &Jvm,
443        _: &mut RuntimeContext,
444        this: ClassInstanceRef<Self>,
445        date: ClassInstanceRef<Date>,
446        buffer: ClassInstanceRef<StringBuffer>,
447        position: ClassInstanceRef<FieldPosition>,
448    ) -> Result<ClassInstanceRef<StringBuffer>> {
449        if date.is_null() || buffer.is_null() || position.is_null() {
450            return Err(jvm.exception("java/lang/NullPointerException", "date, buffer, or position").await);
451        }
452        let number_format: ClassInstanceRef<NumberFormat> = jvm
453            .get_field(&this, "java/text/DateFormat", "numberFormat", "Ljava/text/NumberFormat;")
454            .await?;
455        if number_format.is_null() {
456            return Err(jvm.exception("java/lang/NullPointerException", "numberFormat").await);
457        }
458        let pattern: ClassInstanceRef<String> = jvm
459            .get_field(&this, "java/text/SimpleDateFormat", "pattern", "Ljava/lang/String;")
460            .await?;
461        let pattern = JavaLangString::to_rust_string(jvm, &pattern).await?;
462        let Some(tokens) = Self::tokenize_pattern(&pattern) else {
463            return Err(jvm.exception("java/lang/IllegalArgumentException", "Illegal pattern").await);
464        };
465        let time: i64 = jvm.invoke_virtual(&date, "java/util/Date", "getTime", "()J", ()).await?;
466        let calendar: ClassInstanceRef<Calendar> = jvm
467            .get_field(&this, "java/text/SimpleDateFormat", "calendar", "Ljava/util/Calendar;")
468            .await?;
469        if calendar.is_null() {
470            return Err(jvm.exception("java/lang/NullPointerException", "calendar").await);
471        }
472        let time_zone: ClassInstanceRef<TimeZone> = jvm
473            .invoke_virtual(&calendar, "java/util/Calendar", "getTimeZone", "()Ljava/util/TimeZone;", ())
474            .await?;
475        if time_zone.is_null() {
476            return Err(jvm.exception("java/lang/NullPointerException", "timeZone").await);
477        }
478        let offset: i32 = jvm.invoke_virtual(&time_zone, "java/util/TimeZone", "getRawOffset", "()I", ()).await?;
479        let Some(adjusted) = time.checked_add(i64::from(offset)) else {
480            return Err(jvm.exception("java/lang/IllegalArgumentException", "date out of range").await);
481        };
482        let Some(date_time) = DateTime::<Utc>::from_timestamp_millis(adjusted) else {
483            return Err(jvm.exception("java/lang/IllegalArgumentException", "date out of range").await);
484        };
485
486        let months = [
487            "January",
488            "February",
489            "March",
490            "April",
491            "May",
492            "June",
493            "July",
494            "August",
495            "September",
496            "October",
497            "November",
498            "December",
499        ];
500        let short_months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
501        let weekdays = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
502        let short_weekdays = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
503        let requested_field: i32 = jvm.invoke_virtual(&position, "java/text/FieldPosition", "getField", "()I", ()).await?;
504        let base: i32 = jvm.invoke_virtual(&buffer, "java/lang/StringBuffer", "length", "()I", ()).await?;
505        let mut field_position_set = false;
506        let mut formatted = RustString::new();
507        for token in tokens {
508            match token {
509                DateToken::Literal(value) => formatted.push_str(&value),
510                DateToken::Field(character, count) => {
511                    let begin = formatted.encode_utf16().count() as i32;
512                    match character {
513                        'G' => formatted.push_str(if date_time.year() <= 0 { "BC" } else { "AD" }),
514                        'y' => {
515                            let year = if date_time.year() <= 0 { 1 - date_time.year() } else { date_time.year() };
516                            if count == 2 {
517                                formatted.push_str(&format!("{:02}", year.rem_euclid(100)));
518                            } else {
519                                formatted.push_str(&format!("{year:0count$}"));
520                            }
521                        }
522                        'M' if count >= 4 => formatted.push_str(months[date_time.month0() as usize]),
523                        'M' if count == 3 => formatted.push_str(short_months[date_time.month0() as usize]),
524                        'M' => formatted.push_str(&format!("{:0count$}", date_time.month())),
525                        'd' => formatted.push_str(&format!("{:0count$}", date_time.day())),
526                        'h' => {
527                            let hour = date_time.hour() % 12;
528                            formatted.push_str(&format!("{:0count$}", if hour == 0 { 12 } else { hour }));
529                        }
530                        'H' => formatted.push_str(&format!("{:0count$}", date_time.hour())),
531                        'm' => formatted.push_str(&format!("{:0count$}", date_time.minute())),
532                        's' => formatted.push_str(&format!("{:0count$}", date_time.second())),
533                        'S' => formatted.push_str(&format!("{:0count$}", date_time.timestamp_subsec_millis())),
534                        'E' if count >= 4 => formatted.push_str(weekdays[date_time.weekday().num_days_from_sunday() as usize]),
535                        'E' => formatted.push_str(short_weekdays[date_time.weekday().num_days_from_sunday() as usize]),
536                        'D' => formatted.push_str(&format!("{:0count$}", date_time.ordinal())),
537                        'F' | 'W' => formatted.push_str(&format!("{:0count$}", (date_time.day() - 1) / 7 + 1)),
538                        'w' => formatted.push_str(&format!("{:0count$}", date_time.iso_week().week())),
539                        'a' => formatted.push_str(if date_time.hour() < 12 { "AM" } else { "PM" }),
540                        'k' => formatted.push_str(&format!("{:0count$}", if date_time.hour() == 0 { 24 } else { date_time.hour() })),
541                        'K' => formatted.push_str(&format!("{:0count$}", date_time.hour() % 12)),
542                        'z' => {
543                            if offset == 0 {
544                                formatted.push_str("GMT");
545                            } else {
546                                let absolute = offset.unsigned_abs() / 60_000;
547                                formatted.push_str(&format!(
548                                    "GMT{}{:02}:{:02}",
549                                    if offset < 0 { '-' } else { '+' },
550                                    absolute / 60,
551                                    absolute % 60
552                                ));
553                            }
554                        }
555                        _ => return Err(jvm.exception("java/lang/IllegalArgumentException", "Illegal pattern").await),
556                    }
557                    if !field_position_set && Self::date_field(character) == Some(requested_field) {
558                        let _: () = jvm
559                            .invoke_virtual(&position, "java/text/FieldPosition", "setBeginIndex", "(I)V", (base + begin,))
560                            .await?;
561                        let _: () = jvm
562                            .invoke_virtual(
563                                &position,
564                                "java/text/FieldPosition",
565                                "setEndIndex",
566                                "(I)V",
567                                (base + formatted.encode_utf16().count() as i32,),
568                            )
569                            .await?;
570                        field_position_set = true;
571                    }
572                }
573            }
574        }
575        let text = JavaLangString::from_rust_string(jvm, &formatted).await?;
576        jvm.invoke_virtual(
577            &buffer,
578            "java/lang/StringBuffer",
579            "append",
580            "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
581            (text,),
582        )
583        .await
584    }
585
586    async fn parse(
587        jvm: &Jvm,
588        _: &mut RuntimeContext,
589        this: ClassInstanceRef<Self>,
590        source: ClassInstanceRef<String>,
591        position: ClassInstanceRef<ParsePosition>,
592    ) -> Result<ClassInstanceRef<Date>> {
593        if source.is_null() || position.is_null() {
594            return Err(jvm.exception("java/lang/NullPointerException", "source or position").await);
595        }
596        let pattern: ClassInstanceRef<String> = jvm
597            .get_field(&this, "java/text/SimpleDateFormat", "pattern", "Ljava/lang/String;")
598            .await?;
599        let pattern = JavaLangString::to_rust_string(jvm, &pattern).await?;
600        let Some(tokens) = Self::tokenize_pattern(&pattern) else {
601            return Err(jvm.exception("java/lang/IllegalArgumentException", "Illegal pattern").await);
602        };
603        let source = JavaLangString::to_rust_string(jvm, &source).await?;
604        let characters: Vec<char> = source.chars().collect();
605        let mut utf16_indices = Vec::with_capacity(characters.len() + 1);
606        let mut utf16_index = 0;
607        for character in &characters {
608            utf16_indices.push(utf16_index);
609            utf16_index += character.len_utf16();
610        }
611        utf16_indices.push(utf16_index);
612        let start: i32 = jvm.invoke_virtual(&position, "java/text/ParsePosition", "getIndex", "()I", ()).await?;
613        if start < 0 {
614            let _: () = jvm
615                .invoke_virtual(&position, "java/text/ParsePosition", "setErrorIndex", "(I)V", (start,))
616                .await?;
617            return Ok(ClassInstanceRef::new(None));
618        }
619        let Some(start_index) = utf16_indices.iter().position(|index| *index == start as usize) else {
620            let _: () = jvm
621                .invoke_virtual(&position, "java/text/ParsePosition", "setErrorIndex", "(I)V", (start,))
622                .await?;
623            return Ok(ClassInstanceRef::new(None));
624        };
625        let calendar: ClassInstanceRef<Calendar> = jvm
626            .get_field(&this, "java/text/SimpleDateFormat", "calendar", "Ljava/util/Calendar;")
627            .await?;
628        if calendar.is_null() {
629            return Err(jvm.exception("java/lang/NullPointerException", "calendar").await);
630        }
631        let time_zone: ClassInstanceRef<TimeZone> = jvm
632            .invoke_virtual(&calendar, "java/util/Calendar", "getTimeZone", "()Ljava/util/TimeZone;", ())
633            .await?;
634        if time_zone.is_null() {
635            return Err(jvm.exception("java/lang/NullPointerException", "timeZone").await);
636        }
637        let offset: i32 = jvm.invoke_virtual(&time_zone, "java/util/TimeZone", "getRawOffset", "()I", ()).await?;
638        let number_format: ClassInstanceRef<NumberFormat> = jvm
639            .get_field(&this, "java/text/DateFormat", "numberFormat", "Ljava/text/NumberFormat;")
640            .await?;
641        match Self::parse_timestamp(&tokens, &characters, start_index, offset, number_format.is_null()) {
642            Ok((timestamp, index)) => {
643                let _: () = jvm
644                    .invoke_virtual(&position, "java/text/ParsePosition", "setIndex", "(I)V", (utf16_indices[index] as i32,))
645                    .await?;
646                let _: () = jvm
647                    .invoke_virtual(&position, "java/text/ParsePosition", "setErrorIndex", "(I)V", (-1,))
648                    .await?;
649                Ok(jvm.new_class("java/util/Date", "(J)V", (timestamp,)).await?.into())
650            }
651            Err(DateParseError::NullNumberFormat) => Err(jvm.exception("java/lang/NullPointerException", "numberFormat").await),
652            Err(DateParseError::Invalid(error_index)) => {
653                let _: () = jvm
654                    .invoke_virtual(
655                        &position,
656                        "java/text/ParsePosition",
657                        "setErrorIndex",
658                        "(I)V",
659                        (utf16_indices[error_index] as i32,),
660                    )
661                    .await?;
662                Ok(ClassInstanceRef::new(None))
663            }
664        }
665    }
666}