Skip to main content

rustjava_runtime/classes/java/util/
calendar.rs

1use alloc::vec;
2
3use jvm::{ClassInstanceRef, Jvm, Result};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{
8    RuntimeClassProto, RuntimeContext,
9    classes::java::{
10        lang::{Object, String},
11        util::{Date, TimeZone},
12    },
13};
14
15// abstract class java.util.Calendar
16pub struct Calendar;
17
18impl Calendar {
19    pub fn as_proto() -> RuntimeClassProto {
20        RuntimeClassProto {
21            name: "java/util/Calendar",
22            parent_class: Some("java/lang/Object"),
23            interfaces: vec!["java/io/Serializable", "java/lang/Cloneable"],
24            methods: vec![
25                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PROTECTED),
26                JavaMethodProto::new(
27                    "getInstance",
28                    "()Ljava/util/Calendar;",
29                    Self::get_instance,
30                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
31                ),
32                JavaMethodProto::new(
33                    "getInstance",
34                    "(Ljava/util/TimeZone;)Ljava/util/Calendar;",
35                    Self::get_instance_with_time_zone,
36                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
37                ),
38                JavaMethodProto::new(
39                    "setTime",
40                    "(Ljava/util/Date;)V",
41                    Self::set_time,
42                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
43                ),
44                JavaMethodProto::new(
45                    "getTime",
46                    "()Ljava/util/Date;",
47                    Self::get_time,
48                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
49                ),
50                JavaMethodProto::new("setTimeInMillis", "(J)V", Self::set_time_in_millis, MethodAccessFlags::PUBLIC),
51                JavaMethodProto::new("getTimeInMillis", "()J", Self::get_time_in_millis, MethodAccessFlags::PUBLIC),
52                JavaMethodProto::new("getTimeZone", "()Ljava/util/TimeZone;", Self::get_time_zone, MethodAccessFlags::PUBLIC),
53                JavaMethodProto::new("setTimeZone", "(Ljava/util/TimeZone;)V", Self::set_time_zone, MethodAccessFlags::PUBLIC),
54                JavaMethodProto::new("isLenient", "()Z", Self::is_lenient, MethodAccessFlags::PUBLIC),
55                JavaMethodProto::new("setLenient", "(Z)V", Self::set_lenient, MethodAccessFlags::PUBLIC),
56                JavaMethodProto::new("equals", "(Ljava/lang/Object;)Z", Self::equals, MethodAccessFlags::PUBLIC),
57                JavaMethodProto::new("hashCode", "()I", Self::hash_code, MethodAccessFlags::PUBLIC),
58                JavaMethodProto::new("before", "(Ljava/lang/Object;)Z", Self::before, MethodAccessFlags::PUBLIC),
59                JavaMethodProto::new("after", "(Ljava/lang/Object;)Z", Self::after, MethodAccessFlags::PUBLIC),
60                JavaMethodProto::new("set", "(II)V", Self::set, MethodAccessFlags::PUBLIC),
61                JavaMethodProto::new("get", "(I)I", Self::get, MethodAccessFlags::PUBLIC),
62                JavaMethodProto::new_abstract("computeTime", "()V", MethodAccessFlags::PROTECTED | MethodAccessFlags::ABSTRACT),
63                JavaMethodProto::new_abstract("computeFields", "()V", MethodAccessFlags::PROTECTED | MethodAccessFlags::ABSTRACT),
64            ],
65            fields: vec![
66                JavaFieldProto::new("time", "J", FieldAccessFlags::PROTECTED),
67                JavaFieldProto::new("fields", "[I", FieldAccessFlags::PROTECTED),
68                JavaFieldProto::new("timeZone", "Ljava/util/TimeZone;", FieldAccessFlags::PRIVATE),
69                JavaFieldProto::new("lenient", "Z", FieldAccessFlags::PRIVATE),
70            ],
71            access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::ABSTRACT,
72        }
73    }
74
75    async fn get_instance(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Calendar>> {
76        tracing::debug!("java.util.Calendar::getInstance()");
77
78        let instance = jvm.new_class("java/util/GregorianCalendar", "()V", []).await?;
79
80        Ok(instance.into())
81    }
82
83    async fn get_instance_with_time_zone(
84        jvm: &Jvm,
85        _: &mut RuntimeContext,
86        time_zone: ClassInstanceRef<TimeZone>,
87    ) -> Result<ClassInstanceRef<Calendar>> {
88        tracing::debug!("java.util.Calendar::getInstance({time_zone:?})");
89
90        if time_zone.is_null() {
91            return Err(jvm.exception("java/lang/NullPointerException", "timeZone").await);
92        }
93
94        let instance = jvm
95            .new_class("java/util/GregorianCalendar", "(Ljava/util/TimeZone;)V", (time_zone,))
96            .await?;
97
98        Ok(instance.into())
99    }
100
101    async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
102        tracing::debug!("java.util.Calendar::<init>({this:?})");
103
104        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
105
106        // TODO constant
107        let fields = jvm.instantiate_array("I", 17).await?;
108        jvm.put_field(&mut this, "java/util/Calendar", "fields", "[I", fields).await?;
109        let time_zone: ClassInstanceRef<TimeZone> = jvm
110            .invoke_static("java/util/TimeZone", "getDefault", "()Ljava/util/TimeZone;", ())
111            .await?;
112        jvm.put_field(&mut this, "java/util/Calendar", "timeZone", "Ljava/util/TimeZone;", time_zone)
113            .await?;
114        jvm.put_field(&mut this, "java/util/Calendar", "lenient", "Z", true).await?;
115
116        Ok(())
117    }
118
119    async fn set_time(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, date: ClassInstanceRef<Date>) -> Result<()> {
120        tracing::debug!("java.util.Calendar::setTime({this:?}, {date:?})");
121
122        if date.is_null() {
123            return Err(jvm.exception("java/lang/NullPointerException", "date").await);
124        }
125
126        let time: i64 = jvm.invoke_virtual(&date, "java/util/Date", "getTime", "()J", ()).await?;
127        jvm.put_field(&mut this, "java/util/Calendar", "time", "J", time).await?;
128
129        let _: () = jvm.invoke_virtual(&this, "java/util/Calendar", "computeFields", "()V", ()).await?;
130
131        Ok(())
132    }
133
134    async fn get_time(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Date>> {
135        tracing::debug!("java.util.Calendar::getTime({this:?})");
136
137        let time: i64 = jvm.get_field(&this, "java/util/Calendar", "time", "J").await?;
138        let date = jvm.new_class("java/util/Date", "(J)V", (time,)).await?;
139
140        Ok(date.into())
141    }
142
143    async fn set_time_in_millis(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, time: i64) -> Result<()> {
144        tracing::debug!("java.util.Calendar::setTimeInMillis({this:?}, {time:?})");
145
146        jvm.put_field(&mut this, "java/util/Calendar", "time", "J", time).await?;
147        jvm.invoke_virtual(&this, "java/util/Calendar", "computeFields", "()V", ()).await
148    }
149
150    async fn get_time_in_millis(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i64> {
151        tracing::debug!("java.util.Calendar::getTimeInMillis({this:?})");
152        jvm.get_field(&this, "java/util/Calendar", "time", "J").await
153    }
154
155    async fn get_time_zone(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<TimeZone>> {
156        tracing::debug!("java.util.Calendar::getTimeZone({this:?})");
157        jvm.get_field(&this, "java/util/Calendar", "timeZone", "Ljava/util/TimeZone;").await
158    }
159
160    async fn set_time_zone(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, time_zone: ClassInstanceRef<TimeZone>) -> Result<()> {
161        tracing::debug!("java.util.Calendar::setTimeZone({this:?}, {time_zone:?})");
162        let has_time_zone = !time_zone.is_null();
163        jvm.put_field(&mut this, "java/util/Calendar", "timeZone", "Ljava/util/TimeZone;", time_zone)
164            .await?;
165        if has_time_zone {
166            let _: () = jvm.invoke_virtual(&this, "java/util/Calendar", "computeFields", "()V", ()).await?;
167        }
168        Ok(())
169    }
170
171    async fn is_lenient(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
172        tracing::debug!("java.util.Calendar::isLenient({this:?})");
173        jvm.get_field(&this, "java/util/Calendar", "lenient", "Z").await
174    }
175
176    async fn set_lenient(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, lenient: bool) -> Result<()> {
177        tracing::debug!("java.util.Calendar::setLenient({this:?}, {lenient:?})");
178        jvm.put_field(&mut this, "java/util/Calendar", "lenient", "Z", lenient).await
179    }
180
181    async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<bool> {
182        tracing::debug!("java.util.Calendar::equals({this:?}, {other:?})");
183
184        if other.is_null() || !jvm.is_instance(&**other, "java/util/Calendar") {
185            return Ok(false);
186        }
187        if this.identity() == other.identity() {
188            return Ok(true);
189        }
190
191        let other: ClassInstanceRef<Calendar> = ClassInstanceRef::new(other.instance);
192        let time: i64 = jvm.get_field(&this, "java/util/Calendar", "time", "J").await?;
193        let other_time: i64 = jvm.get_field(&other, "java/util/Calendar", "time", "J").await?;
194        if time != other_time {
195            return Ok(false);
196        }
197
198        let lenient: bool = jvm.get_field(&this, "java/util/Calendar", "lenient", "Z").await?;
199        let other_lenient: bool = jvm.get_field(&other, "java/util/Calendar", "lenient", "Z").await?;
200        if lenient != other_lenient {
201            return Ok(false);
202        }
203
204        let time_zone: ClassInstanceRef<TimeZone> = jvm.get_field(&this, "java/util/Calendar", "timeZone", "Ljava/util/TimeZone;").await?;
205        let other_time_zone: ClassInstanceRef<TimeZone> = jvm.get_field(&other, "java/util/Calendar", "timeZone", "Ljava/util/TimeZone;").await?;
206        if time_zone.is_null() || other_time_zone.is_null() {
207            return Ok(false);
208        }
209        let raw_offset: i32 = jvm.invoke_virtual(&time_zone, "java/util/TimeZone", "getRawOffset", "()I", ()).await?;
210        let other_raw_offset: i32 = jvm
211            .invoke_virtual(&other_time_zone, "java/util/TimeZone", "getRawOffset", "()I", ())
212            .await?;
213        if raw_offset != other_raw_offset {
214            return Ok(false);
215        }
216
217        let id: ClassInstanceRef<String> = jvm
218            .invoke_virtual(&time_zone, "java/util/TimeZone", "getID", "()Ljava/lang/String;", ())
219            .await?;
220        let other_id: ClassInstanceRef<String> = jvm
221            .invoke_virtual(&other_time_zone, "java/util/TimeZone", "getID", "()Ljava/lang/String;", ())
222            .await?;
223        jvm.invoke_virtual(&id, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (other_id,))
224            .await
225    }
226
227    async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
228        tracing::debug!("java.util.Calendar::hashCode({this:?})");
229
230        let time: i64 = jvm.get_field(&this, "java/util/Calendar", "time", "J").await?;
231        let time_zone: ClassInstanceRef<TimeZone> = jvm.get_field(&this, "java/util/Calendar", "timeZone", "Ljava/util/TimeZone;").await?;
232        if time_zone.is_null() {
233            return Err(jvm.exception("java/lang/NullPointerException", "timeZone").await);
234        }
235        let raw_offset: i32 = jvm.invoke_virtual(&time_zone, "java/util/TimeZone", "getRawOffset", "()I", ()).await?;
236        let id: ClassInstanceRef<String> = jvm
237            .invoke_virtual(&time_zone, "java/util/TimeZone", "getID", "()Ljava/lang/String;", ())
238            .await?;
239        let id_hash: i32 = jvm.invoke_virtual(&id, "java/lang/Object", "hashCode", "()I", ()).await?;
240        let lenient: bool = jvm.get_field(&this, "java/util/Calendar", "lenient", "Z").await?;
241        Ok((time ^ ((time as u64 >> 32) as i64)) as i32 ^ raw_offset ^ id_hash ^ if lenient { 1 } else { 0 })
242    }
243
244    async fn before(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<bool> {
245        tracing::debug!("java.util.Calendar::before({this:?}, {other:?})");
246
247        if other.is_null() || !jvm.is_instance(&**other, "java/util/Calendar") {
248            return Ok(false);
249        }
250
251        let other: ClassInstanceRef<Calendar> = ClassInstanceRef::new(other.instance);
252        let time: i64 = jvm.get_field(&this, "java/util/Calendar", "time", "J").await?;
253        let other_time: i64 = jvm.get_field(&other, "java/util/Calendar", "time", "J").await?;
254        Ok(time < other_time)
255    }
256
257    async fn after(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<bool> {
258        tracing::debug!("java.util.Calendar::after({this:?}, {other:?})");
259
260        if other.is_null() || !jvm.is_instance(&**other, "java/util/Calendar") {
261            return Ok(false);
262        }
263
264        let other: ClassInstanceRef<Calendar> = ClassInstanceRef::new(other.instance);
265        let time: i64 = jvm.get_field(&this, "java/util/Calendar", "time", "J").await?;
266        let other_time: i64 = jvm.get_field(&other, "java/util/Calendar", "time", "J").await?;
267        Ok(time > other_time)
268    }
269
270    async fn set(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, field: i32, value: i32) -> Result<()> {
271        tracing::debug!("java.util.Calendar::set({this:?}, {field:?}, {value:?})");
272
273        if !(0..17).contains(&field) {
274            return Err(jvm.exception("java/lang/ArrayIndexOutOfBoundsException", "calendar field").await);
275        }
276
277        let mut fields = jvm.get_field(&this, "java/util/Calendar", "fields", "[I").await?;
278        jvm.store_array(&mut fields, field as usize, vec![value]).await?;
279
280        let _: () = jvm.invoke_virtual(&this, "java/util/Calendar", "computeTime", "()V", ()).await?;
281        let _: () = jvm.invoke_virtual(&this, "java/util/Calendar", "computeFields", "()V", ()).await?;
282
283        Ok(())
284    }
285
286    async fn get(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, field: i32) -> Result<i32> {
287        tracing::debug!("java.util.Calendar::get({this:?}, {field:?})");
288
289        let time_zone: ClassInstanceRef<TimeZone> = jvm.get_field(&this, "java/util/Calendar", "timeZone", "Ljava/util/TimeZone;").await?;
290        if time_zone.is_null() {
291            return Err(jvm.exception("java/lang/NullPointerException", "timeZone").await);
292        }
293
294        if !(0..17).contains(&field) {
295            return Err(jvm.exception("java/lang/ArrayIndexOutOfBoundsException", "calendar field").await);
296        }
297
298        let fields = jvm.get_field(&this, "java/util/Calendar", "fields", "[I").await?;
299        let value = jvm.load_array(&fields, field as usize, 1).await?[0];
300
301        Ok(value)
302    }
303}