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 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
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) = 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        // month through second were range-checked above, so only the year can fall outside its target type
353        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}