Skip to main content

rustjava_runtime/classes/java/lang/
object.rs

1use core::{
2    hash::{Hash, Hasher},
3    time::Duration,
4};
5
6use alloc::{boxed::Box, format, vec};
7
8use dyn_clone::clone_box;
9use jvm::{ClassInstance, ClassInstanceRef, Jvm, MonitorWaitTimeout, Result, runtime::JavaLangString};
10use jvm_class_proto::JavaMethodProto;
11use jvm_types::{ClassAccessFlags, MethodAccessFlags};
12
13use crate::{Runtime, RuntimeClassProto, RuntimeContext, SpawnCallback, classes::java::lang::String};
14
15// class java.lang.Object
16pub struct Object;
17
18const FNV_OFFSET_BASIS_64: u64 = 0xcbf29ce484222325;
19const FNV_PRIME_64: u64 = 0x100000001b3;
20
21#[derive(Default)]
22struct IdentityHasher(u64);
23
24impl Hasher for IdentityHasher {
25    fn finish(&self) -> u64 {
26        self.0
27    }
28
29    fn write(&mut self, bytes: &[u8]) {
30        let mut hash = if self.0 == 0 { FNV_OFFSET_BASIS_64 } else { self.0 };
31        for byte in bytes {
32            hash ^= u64::from(*byte);
33            hash = hash.wrapping_mul(FNV_PRIME_64);
34        }
35        self.0 = hash;
36    }
37}
38
39impl Object {
40    pub(crate) fn identity_hash_code<T>(object: &ClassInstanceRef<T>) -> i32 {
41        let mut hasher = IdentityHasher::default();
42        object.hash(&mut hasher);
43        hasher.finish() as i32
44    }
45
46    pub fn as_proto() -> RuntimeClassProto {
47        RuntimeClassProto {
48            name: "java/lang/Object",
49            parent_class: None,
50            interfaces: vec![],
51            methods: vec![
52                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
53                JavaMethodProto::new(
54                    "getClass",
55                    "()Ljava/lang/Class;",
56                    Self::get_class,
57                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
58                ),
59                JavaMethodProto::new("hashCode", "()I", Self::hash_code, MethodAccessFlags::PUBLIC),
60                JavaMethodProto::new("equals", "(Ljava/lang/Object;)Z", Self::equals, MethodAccessFlags::PUBLIC),
61                JavaMethodProto::new(
62                    "clone",
63                    "()Ljava/lang/Object;",
64                    Self::clone,
65                    MethodAccessFlags::PROTECTED | MethodAccessFlags::NATIVE,
66                ),
67                JavaMethodProto::new("toString", "()Ljava/lang/String;", Self::to_string, MethodAccessFlags::PUBLIC),
68                JavaMethodProto::new("notify", "()V", Self::notify, MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL),
69                JavaMethodProto::new("notifyAll", "()V", Self::notify_all, MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL),
70                JavaMethodProto::new("wait", "(J)V", Self::wait_long, MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL),
71                JavaMethodProto::new("wait", "(JI)V", Self::wait_long_int, MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL),
72                JavaMethodProto::new("wait", "()V", Self::wait, MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL),
73                JavaMethodProto::new("finalize", "()V", Self::finalize, MethodAccessFlags::PROTECTED),
74            ],
75            fields: vec![],
76            access_flags: ClassAccessFlags::PUBLIC,
77        }
78    }
79
80    async fn init(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
81        tracing::debug!("java.lang.Object::<init>({this:?})");
82
83        Ok(())
84    }
85
86    async fn get_class(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Self>> {
87        tracing::debug!("java.lang.Object::getClass({this:?})");
88
89        // TODO can we get class directly?
90        let this: Box<dyn ClassInstance> = this.into();
91        let class_name = this.class_definition().name();
92
93        let class = jvm.resolve_class(&class_name).await?.java_class();
94
95        Ok(class.into())
96    }
97
98    async fn hash_code(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
99        tracing::debug!("java.lang.Object::hashCode({this:?})");
100
101        Ok(Self::identity_hash_code(&this))
102    }
103
104    async fn equals(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Self>) -> Result<bool> {
105        tracing::debug!("java.lang.Object::equals({this:?}, {other:?})");
106
107        if other.is_null() {
108            return Ok(false);
109        }
110
111        let rust_this: Box<dyn ClassInstance> = this.into();
112        let rust_other: Box<dyn ClassInstance> = other.into();
113
114        rust_this.equals(&*rust_other)
115    }
116
117    async fn clone(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Self>> {
118        tracing::debug!("java.lang.Object::clone({this:?})");
119
120        if !jvm.is_instance(&**this, "java/lang/Cloneable") {
121            return Err(jvm.exception("java/lang/CloneNotSupportedException", "Cannot clone this object").await);
122        }
123
124        Ok(jvm.shallow_clone(&this)?.into())
125    }
126
127    async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
128        tracing::debug!("java.lang.Object::toString({this:?})");
129
130        let class = jvm
131            .invoke_virtual(&this, "java/lang/Object", "getClass", "()Ljava/lang/Class;", ())
132            .await?;
133        let class_name = jvm
134            .invoke_virtual(&class, "java/lang/Class", "getName", "()Ljava/lang/String;", ())
135            .await?;
136        let class_name_rust = JavaLangString::to_rust_string(jvm, &class_name).await?;
137
138        let hash_code: i32 = jvm.invoke_virtual(&this, "java/lang/Object", "hashCode", "()I", ()).await?;
139
140        let result = format!("{class_name_rust}@{hash_code:x}");
141
142        Ok(JavaLangString::from_rust_string(jvm, &result).await?.into())
143    }
144
145    async fn notify(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
146        tracing::debug!("java.lang.Object::notify({this:?})");
147
148        jvm.object_notify(&this, 1).await?;
149
150        Ok(())
151    }
152
153    async fn notify_all(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
154        tracing::debug!("java.lang.Object::notifyAll({this:?})");
155
156        jvm.object_notify(&this, usize::MAX).await?;
157
158        Ok(())
159    }
160
161    async fn wait_long(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, millis: i64) -> Result<()> {
162        tracing::debug!("java.lang.Object::wait({this:?}, {millis:?})");
163
164        let _: () = jvm.invoke_virtual(&this, "java/lang/Object", "wait", "(JI)V", (millis, 0)).await?;
165
166        Ok(())
167    }
168
169    async fn wait_long_int(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>, millis: i64, nanos: i32) -> Result<()> {
170        tracing::debug!("java.lang.Object::wait({this:?}, {millis:?}, {nanos:?})");
171
172        if millis < 0 || !(0..=999_999).contains(&nanos) {
173            return Err(jvm.exception("java/lang/IllegalArgumentException", "invalid wait timeout").await);
174        }
175
176        struct TimeoutNotifier {
177            timeout: u64,
178            waiter: MonitorWaitTimeout,
179            context: Box<dyn Runtime>,
180        }
181
182        #[async_trait::async_trait]
183        impl SpawnCallback for TimeoutNotifier {
184            async fn call(&self) -> Result<()> {
185                self.context.sleep(Duration::from_millis(self.timeout)).await;
186                self.waiter.clone().notify();
187                Ok(())
188            }
189        }
190
191        let (waiter, timeout_notifier) = jvm.object_wait_prepare(&this).await?;
192        let timeout = millis as u64 + u64::from(nanos > 0);
193        if timeout != 0 {
194            context.spawn(
195                jvm,
196                Box::new(TimeoutNotifier {
197                    timeout,
198                    waiter: timeout_notifier,
199                    context: clone_box(context),
200                }),
201            );
202        }
203
204        jvm.object_wait(waiter).await?;
205
206        Ok(())
207    }
208
209    async fn wait(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
210        tracing::debug!("java.lang.Object::wait({this:?})");
211
212        let _: () = jvm.invoke_virtual(&this, "java/lang/Object", "wait", "(JI)V", (0i64, 0)).await?;
213
214        Ok(())
215    }
216
217    async fn finalize(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
218        tracing::warn!("stub java.lang.Object::finalize({this:?})");
219
220        Ok(())
221    }
222}