rustjava_runtime/classes/java/lang/
object.rs1use 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
15pub 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 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}