Skip to main content

rustjava_runtime/classes/java/util/
gregorian_calendar.rs

1use alloc::{vec, vec::Vec};
2
3use chrono::{DateTime, Datelike, TimeZone as ChronoTimeZone, Timelike, Utc};
4
5use jvm::{ClassInstanceRef, Jvm, Result};
6use jvm_class_proto::JavaMethodProto;
7use jvm_types::{ClassAccessFlags, MethodAccessFlags};
8
9use crate::{RuntimeClassProto, RuntimeContext, classes::java::util::TimeZone};
10
11// class java.util.GregorianCalendar
12pub struct GregorianCalendar;
13
14impl GregorianCalendar {
15    pub fn as_proto() -> RuntimeClassProto {
16        RuntimeClassProto {
17            name: "java/util/GregorianCalendar",
18            parent_class: Some("java/util/Calendar"),
19            interfaces: vec![],
20            methods: vec![
21                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
22                JavaMethodProto::new("<init>", "(Ljava/util/TimeZone;)V", Self::init_with_time_zone, MethodAccessFlags::PUBLIC),
23                JavaMethodProto::new("computeTime", "()V", Self::compute_time, MethodAccessFlags::PROTECTED),
24                JavaMethodProto::new("computeFields", "()V", Self::compute_fields, MethodAccessFlags::PROTECTED),
25            ],
26            fields: vec![],
27            access_flags: ClassAccessFlags::PUBLIC,
28        }
29    }
30
31    async fn init(jvm: &Jvm, context: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
32        tracing::debug!("java.util.GregorianCalendar::<init>({this:?})");
33
34        let _: () = jvm.invoke_special(&this, "java/util/Calendar", "<init>", "()V", ()).await?;
35        jvm.put_field(&mut this, "time", "J", context.now() as i64).await?;
36        jvm.invoke_virtual(&this, "java/util/GregorianCalendar", "computeFields", "()V", ()).await
37    }
38
39    async fn init_with_time_zone(
40        jvm: &Jvm,
41        context: &mut RuntimeContext,
42        mut this: ClassInstanceRef<Self>,
43        time_zone: ClassInstanceRef<TimeZone>,
44    ) -> Result<()> {
45        tracing::debug!("java.util.GregorianCalendar::<init>({this:?}, {time_zone:?})");
46
47        if time_zone.is_null() {
48            return Err(jvm.exception("java/lang/NullPointerException", "timeZone").await);
49        }
50
51        let _: () = jvm.invoke_special(&this, "java/util/Calendar", "<init>", "()V", ()).await?;
52        jvm.put_field(&mut this, "timeZone", "Ljava/util/TimeZone;", time_zone).await?;
53        jvm.put_field(&mut this, "time", "J", context.now() as i64).await?;
54        jvm.invoke_virtual(&this, "java/util/GregorianCalendar", "computeFields", "()V", ()).await
55    }
56
57    async fn compute_time(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
58        tracing::debug!("java.util.GregorianCalendar::computeTime({this:?})");
59
60        // fields -> time
61
62        let fields = jvm.get_field(&this, "fields", "[I").await?;
63
64        // TODO constant
65        let fields: Vec<i32> = jvm.load_array(&fields, 0, 17).await?;
66        let _era = fields[0];
67        let year = fields[1];
68        let month = fields[2];
69        let _week_of_year = fields[3];
70        let _week_of_month = fields[4];
71        let date = fields[5];
72        let _day_of_year = fields[6];
73        let _day_of_week = fields[7];
74        let _day_of_week_in_month = fields[8];
75        let _am_pm = fields[9];
76        let _hour = fields[10];
77        let hour_of_day = fields[11];
78        let minute = fields[12];
79        let second = fields[13];
80        let millisecond = fields[14];
81        let zone_offset = fields[15]; // raw offset from GMT in milliseconds
82        let _dst_offset = fields[16];
83
84        // TODO handle more complex cases
85        let Some(date_time) = Utc
86            .with_ymd_and_hms(year, (month + 1) as _, date as _, hour_of_day as _, minute as _, second as _)
87            .single()
88        else {
89            return Err(jvm.exception("java/lang/IllegalArgumentException", "invalid calendar fields").await);
90        };
91        let Some(calculated_time) = date_time
92            .timestamp_millis()
93            .checked_sub(zone_offset as i64)
94            .and_then(|timestamp| timestamp.checked_add(millisecond as i64))
95        else {
96            return Err(jvm.exception("java/lang/IllegalArgumentException", "calendar time out of range").await);
97        };
98
99        jvm.put_field(&mut this, "time", "J", calculated_time).await?;
100
101        Ok(())
102    }
103
104    async fn compute_fields(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
105        tracing::debug!("java.util.GregorianCalendar::computeFields({this:?})");
106
107        // time -> fields
108
109        let time: i64 = jvm.get_field(&this, "time", "J").await?;
110        let time_zone: ClassInstanceRef<TimeZone> = jvm.get_field(&this, "timeZone", "Ljava/util/TimeZone;").await?;
111        let zone_offset: i32 = jvm.invoke_virtual(&time_zone, "java/util/TimeZone", "getRawOffset", "()I", ()).await?;
112        let Some(adjusted_time) = time.checked_add(zone_offset as i64) else {
113            return Err(jvm.exception("java/lang/IllegalArgumentException", "calendar time out of range").await);
114        };
115        let Some(date_time) = DateTime::<Utc>::from_timestamp_millis(adjusted_time) else {
116            return Err(jvm.exception("java/lang/IllegalArgumentException", "calendar time out of range").await);
117        };
118
119        let calculated_fields = vec![
120            1, // CE
121            date_time.year(),
122            date_time.month() as i32 - 1,
123            date_time.iso_week().week() as _,
124            (date_time.day() / 7) as _, // TODO correctly get
125            date_time.day() as _,
126            date_time.ordinal() as _,
127            date_time.weekday().number_from_sunday() as _,
128            (date_time.day() % 7) as _, // TODO correctly get
129            (date_time.hour() / 12) as _,
130            (date_time.hour() % 12) as _,
131            date_time.hour() as _,
132            date_time.minute() as _,
133            date_time.second() as _,
134            (date_time.nanosecond() / 1_000_000) as _,
135            zone_offset,
136            0,
137        ];
138
139        let mut fields = jvm.get_field(&this, "fields", "[I").await?;
140        jvm.store_array(&mut fields, 0, calculated_fields).await?;
141
142        Ok(())
143    }
144}