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 = jvm.resolve_class(&this.class_definition().name()).await?.java_class();
92
93 Ok(class.into())
94 }
95
96 async fn hash_code(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
97 tracing::debug!("java.lang.Object::hashCode({this:?})");
98
99 Ok(Self::identity_hash_code(&this))
100 }
101
102 async fn equals(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Self>) -> Result<bool> {
103 tracing::debug!("java.lang.Object::equals({this:?}, {other:?})");
104
105 if other.is_null() {
106 return Ok(false);
107 }
108
109 let rust_this: Box<dyn ClassInstance> = this.into();
110 let rust_other: Box<dyn ClassInstance> = other.into();
111
112 rust_this.equals(&*rust_other)
113 }
114
115 async fn clone(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Self>> {
116 tracing::debug!("java.lang.Object::clone({this:?})");
117
118 if !jvm.is_instance(&**this, "java/lang/Cloneable") {
119 return Err(jvm.exception("java/lang/CloneNotSupportedException", "Cannot clone this object").await);
120 }
121
122 Ok(jvm.shallow_clone(&this)?.into())
123 }
124
125 async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
126 tracing::debug!("java.lang.Object::toString({this:?})");
127
128 let class = jvm
129 .invoke_virtual(&this, "java/lang/Object", "getClass", "()Ljava/lang/Class;", ())
130 .await?;
131 let class_name = jvm
132 .invoke_virtual(&class, "java/lang/Class", "getName", "()Ljava/lang/String;", ())
133 .await?;
134 let class_name_rust = JavaLangString::to_rust_string(jvm, &class_name).await?;
135
136 let hash_code: i32 = jvm.invoke_virtual(&this, "java/lang/Object", "hashCode", "()I", ()).await?;
137
138 let result = format!("{class_name_rust}@{hash_code:x}");
139
140 Ok(JavaLangString::from_rust_string(jvm, &result).await?.into())
141 }
142
143 async fn notify(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
144 tracing::debug!("java.lang.Object::notify({this:?})");
145
146 jvm.object_notify(&this, 1).await?;
147
148 Ok(())
149 }
150
151 async fn notify_all(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
152 tracing::debug!("java.lang.Object::notifyAll({this:?})");
153
154 jvm.object_notify(&this, usize::MAX).await?;
155
156 Ok(())
157 }
158
159 async fn wait_long(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, millis: i64) -> Result<()> {
160 tracing::debug!("java.lang.Object::wait({this:?}, {millis:?})");
161
162 let _: () = jvm.invoke_virtual(&this, "java/lang/Object", "wait", "(JI)V", (millis, 0)).await?;
163
164 Ok(())
165 }
166
167 async fn wait_long_int(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>, millis: i64, nanos: i32) -> Result<()> {
168 tracing::debug!("java.lang.Object::wait({this:?}, {millis:?}, {nanos:?})");
169
170 if millis < 0 || !(0..=999_999).contains(&nanos) {
171 return Err(jvm.exception("java/lang/IllegalArgumentException", "invalid wait timeout").await);
172 }
173
174 struct TimeoutNotifier {
175 timeout: u64,
176 waiter: MonitorWaitTimeout,
177 context: Box<dyn Runtime>,
178 }
179
180 #[async_trait::async_trait]
181 impl SpawnCallback for TimeoutNotifier {
182 async fn call(&self) -> Result<()> {
183 self.context.sleep(Duration::from_millis(self.timeout)).await;
184 self.waiter.clone().notify();
185 Ok(())
186 }
187 }
188
189 let (waiter, timeout_notifier) = jvm.object_wait_prepare(&this).await?;
190 let timeout = millis as u64 + u64::from(nanos > 0);
191 if timeout != 0 {
192 context.spawn(
193 jvm,
194 Box::new(TimeoutNotifier {
195 timeout,
196 waiter: timeout_notifier,
197 context: clone_box(context),
198 }),
199 );
200 }
201
202 jvm.object_wait(waiter).await?;
203
204 Ok(())
205 }
206
207 async fn wait(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
208 tracing::debug!("java.lang.Object::wait({this:?})");
209
210 let _: () = jvm.invoke_virtual(&this, "java/lang/Object", "wait", "(JI)V", (0i64, 0)).await?;
211
212 Ok(())
213 }
214
215 async fn finalize(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
216 tracing::warn!("stub java.lang.Object::finalize({this:?})");
217
218 Ok(())
219 }
220}