1use alloc::{string::String as RustString, vec, vec::Vec};
2
3use jvm::{Array, ClassInstanceRef, JavaError, Jvm, Result, runtime::JavaLangString};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{
8 RuntimeClassProto, RuntimeContext,
9 classes::java::lang::{Object, String},
10};
11
12use super::HashtableEntry;
13
14const DEFAULT_INITIAL_CAPACITY: i32 = 11;
15const DEFAULT_LOAD_FACTOR: f32 = 0.75;
16
17pub struct Hashtable;
19
20impl Hashtable {
21 pub fn as_proto() -> RuntimeClassProto {
22 RuntimeClassProto {
23 name: "java/util/Hashtable",
24 parent_class: Some("java/util/Dictionary"),
25 interfaces: vec!["java/util/Map", "java/lang/Cloneable", "java/io/Serializable"],
26 methods: vec![
27 JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
28 JavaMethodProto::new("<init>", "(I)V", Self::init_with_capacity, MethodAccessFlags::PUBLIC),
29 JavaMethodProto::new("<init>", "(Ljava/util/Map;)V", Self::init_from_map, MethodAccessFlags::PUBLIC),
30 JavaMethodProto::new("size", "()I", Self::size, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
31 JavaMethodProto::new(
32 "isEmpty",
33 "()Z",
34 Self::is_empty,
35 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
36 ),
37 JavaMethodProto::new(
38 "contains",
39 "(Ljava/lang/Object;)Z",
40 Self::contains,
41 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
42 ),
43 JavaMethodProto::new(
44 "containsKey",
45 "(Ljava/lang/Object;)Z",
46 Self::contains_key,
47 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
48 ),
49 JavaMethodProto::new("containsValue", "(Ljava/lang/Object;)Z", Self::contains_value, MethodAccessFlags::PUBLIC),
50 JavaMethodProto::new(
51 "keys",
52 "()Ljava/util/Enumeration;",
53 Self::keys,
54 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
55 ),
56 JavaMethodProto::new(
57 "elements",
58 "()Ljava/util/Enumeration;",
59 Self::elements,
60 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
61 ),
62 JavaMethodProto::new(
63 "put",
64 "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
65 Self::put,
66 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
67 ),
68 JavaMethodProto::new(
69 "putAll",
70 "(Ljava/util/Map;)V",
71 Self::put_all,
72 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
73 ),
74 JavaMethodProto::new(
75 "get",
76 "(Ljava/lang/Object;)Ljava/lang/Object;",
77 Self::get,
78 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
79 ),
80 JavaMethodProto::new(
81 "remove",
82 "(Ljava/lang/Object;)Ljava/lang/Object;",
83 Self::remove,
84 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
85 ),
86 JavaMethodProto::new("clear", "()V", Self::clear, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
87 JavaMethodProto::new("keySet", "()Ljava/util/Set;", Self::key_set, MethodAccessFlags::PUBLIC),
88 JavaMethodProto::new("values", "()Ljava/util/Collection;", Self::values, MethodAccessFlags::PUBLIC),
89 JavaMethodProto::new("entrySet", "()Ljava/util/Set;", Self::entry_set, MethodAccessFlags::PUBLIC),
90 JavaMethodProto::new("rehash", "()V", Self::rehash, MethodAccessFlags::PROTECTED),
91 JavaMethodProto::new(
92 "equals",
93 "(Ljava/lang/Object;)Z",
94 Self::equals,
95 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
96 ),
97 JavaMethodProto::new(
98 "hashCode",
99 "()I",
100 Self::hash_code,
101 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
102 ),
103 JavaMethodProto::new(
104 "toString",
105 "()Ljava/lang/String;",
106 Self::to_string,
107 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
108 ),
109 ],
110 fields: vec![
111 JavaFieldProto::new(
112 "table",
113 "[Ljava/util/Hashtable$Entry;",
114 FieldAccessFlags::PRIVATE | FieldAccessFlags::TRANSIENT,
115 ),
116 JavaFieldProto::new("count", "I", FieldAccessFlags::PRIVATE | FieldAccessFlags::TRANSIENT),
117 JavaFieldProto::new("threshold", "I", FieldAccessFlags::PRIVATE),
118 JavaFieldProto::new("loadFactor", "F", FieldAccessFlags::PRIVATE),
119 ],
120 access_flags: ClassAccessFlags::PUBLIC,
121 }
122 }
123
124 async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
125 tracing::debug!("java.util.Hashtable::<init>({this:?})");
126
127 jvm.invoke_special(&this, "java/util/Hashtable", "<init>", "(I)V", (DEFAULT_INITIAL_CAPACITY,))
128 .await
129 }
130
131 async fn init_with_capacity(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, initial_capacity: i32) -> Result<()> {
132 tracing::debug!("java.util.Hashtable::<init>({this:?}, {initial_capacity:?})");
133
134 if initial_capacity < 0 {
135 return Err(jvm.exception("java/lang/IllegalArgumentException", "Illegal Capacity").await);
136 }
137
138 let _: () = jvm.invoke_special(&this, "java/util/Dictionary", "<init>", "()V", ()).await?;
139
140 let initial_capacity = initial_capacity.max(1);
141 let table = jvm.instantiate_array("Ljava/util/Hashtable$Entry;", initial_capacity as usize).await?;
142 jvm.put_field(&mut this, "table", "[Ljava/util/Hashtable$Entry;", table).await?;
143 jvm.put_field(&mut this, "count", "I", 0).await?;
144 jvm.put_field(&mut this, "threshold", "I", (initial_capacity as f32 * DEFAULT_LOAD_FACTOR) as i32)
145 .await?;
146 jvm.put_field(&mut this, "loadFactor", "F", DEFAULT_LOAD_FACTOR).await?;
147
148 Ok(())
149 }
150
151 async fn init_from_map(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, map: ClassInstanceRef<Object>) -> Result<()> {
152 tracing::debug!("java.util.Hashtable::<init>({this:?}, {map:?})");
153
154 if map.is_null() {
155 return Err(jvm.exception("java/lang/NullPointerException", "map").await);
156 }
157 let size: i32 = jvm.invoke_virtual(&map, &map.class_definition().name(), "size", "()I", ()).await?;
158 let capacity = size.saturating_mul(2).max(DEFAULT_INITIAL_CAPACITY);
159 let _: () = jvm.invoke_special(&this, "java/util/Hashtable", "<init>", "(I)V", (capacity,)).await?;
160 let _: () = jvm
161 .invoke_virtual(&this, "java/util/Hashtable", "putAll", "(Ljava/util/Map;)V", (map,))
162 .await?;
163
164 Ok(())
165 }
166
167 async fn contains(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Object>) -> Result<bool> {
168 tracing::debug!("java.util.Hashtable::contains({this:?}, {value:?})");
169 jvm.invoke_virtual(&this, "java/util/Hashtable", "containsValue", "(Ljava/lang/Object;)Z", (value,))
170 .await
171 }
172
173 async fn keys(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
174 tracing::debug!("java.util.Hashtable::keys({this:?})");
175
176 let snapshot = Self::keys_snapshot(jvm, &this).await?;
177 Ok(jvm
178 .new_class("java/util/Hashtable$Enumerator", "([Ljava/lang/Object;)V", (snapshot,))
179 .await?
180 .into())
181 }
182
183 async fn elements(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
184 tracing::debug!("java.util.Hashtable::elements({this:?})");
185
186 let snapshot = Self::values_snapshot(jvm, &this).await?;
187 Ok(jvm
188 .new_class("java/util/Hashtable$Enumerator", "([Ljava/lang/Object;)V", (snapshot,))
189 .await?
190 .into())
191 }
192
193 async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
194 tracing::debug!("java.util.Hashtable::size({this:?})");
195
196 jvm.get_field(&this, "count", "I").await
197 }
198
199 async fn is_empty(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
200 tracing::debug!("java.util.Hashtable::isEmpty({this:?})");
201
202 let count: i32 = jvm.get_field(&this, "count", "I").await?;
203
204 Ok(count == 0)
205 }
206
207 async fn contains_key(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, key: ClassInstanceRef<Object>) -> Result<bool> {
208 tracing::debug!("java.util.Hashtable::containsKey({this:?}, {key:?})");
209
210 let key_hash = Self::key_hash(jvm, &key).await?;
211 let table = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
212 let table_len = jvm.array_length(&table).await? as i32;
213 let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;
214
215 let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
216 while !entry.is_null() {
217 let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
218 if entry_hash == key_hash {
219 let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
220 let equals: bool = jvm
221 .invoke_virtual(&entry_key, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (key.clone(),))
222 .await?;
223 if equals {
224 return Ok(true);
225 }
226 }
227 entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
228 }
229
230 Ok(false)
231 }
232
233 async fn contains_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Object>) -> Result<bool> {
234 tracing::debug!("java.util.Hashtable::containsValue({this:?}, {value:?})");
235
236 if value.is_null() {
237 return Err(jvm.exception("java/lang/NullPointerException", "Hashtable value is null").await);
238 }
239
240 let table: ClassInstanceRef<Array<HashtableEntry>> = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
241 let table_len = jvm.array_length(&table).await?;
242 for bucket_index in 0..table_len {
243 let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
244 while !entry.is_null() {
245 let entry_value: ClassInstanceRef<Object> = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?;
246 if Self::object_equals(jvm, &value, &entry_value).await? {
247 return Ok(true);
248 }
249
250 entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
251 }
252 }
253
254 Ok(false)
255 }
256
257 async fn get(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, key: ClassInstanceRef<Object>) -> Result<ClassInstanceRef<Object>> {
258 tracing::debug!("java.util.Hashtable::get({this:?}, {key:?})");
259
260 let key_hash = Self::key_hash(jvm, &key).await?;
261 let table = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
262 let table_len = jvm.array_length(&table).await? as i32;
263 let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;
264
265 let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
266 while !entry.is_null() {
267 let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
268 if entry_hash == key_hash {
269 let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
270 let equals: bool = jvm
271 .invoke_virtual(&entry_key, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (key.clone(),))
272 .await?;
273 if equals {
274 return jvm.get_field(&entry, "value", "Ljava/lang/Object;").await;
275 }
276 }
277 entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
278 }
279
280 Ok(None.into())
281 }
282
283 async fn remove(
284 jvm: &Jvm,
285 _: &mut RuntimeContext,
286 mut this: ClassInstanceRef<Self>,
287 key: ClassInstanceRef<Object>,
288 ) -> Result<ClassInstanceRef<Object>> {
289 tracing::debug!("java.util.Hashtable::remove({this:?}, {key:?})");
290
291 let key_hash = Self::key_hash(jvm, &key).await?;
292 let mut table = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
293 let table_len = jvm.array_length(&table).await? as i32;
294 let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;
295
296 let mut prev: ClassInstanceRef<HashtableEntry> = None.into();
297 let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
298
299 while !entry.is_null() {
300 let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
301 if entry_hash == key_hash {
302 let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
303 let equals: bool = jvm
304 .invoke_virtual(&entry_key, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (key.clone(),))
305 .await?;
306 if equals {
307 let next: ClassInstanceRef<HashtableEntry> = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
308 if prev.is_null() {
309 jvm.store_array(&mut table, bucket_index, core::iter::once(next)).await?;
310 } else {
311 jvm.put_field(&mut prev, "next", "Ljava/util/Hashtable$Entry;", next).await?;
312 }
313
314 let count: i32 = jvm.get_field(&this, "count", "I").await?;
315 jvm.put_field(&mut this, "count", "I", count - 1).await?;
316
317 return jvm.get_field(&entry, "value", "Ljava/lang/Object;").await;
318 }
319 }
320 prev = entry;
321 entry = jvm.get_field(&prev, "next", "Ljava/util/Hashtable$Entry;").await?;
322 }
323
324 Ok(None.into())
325 }
326
327 async fn put(
328 jvm: &Jvm,
329 _: &mut RuntimeContext,
330 mut this: ClassInstanceRef<Self>,
331 key: ClassInstanceRef<Object>,
332 value: ClassInstanceRef<Object>,
333 ) -> Result<ClassInstanceRef<Object>> {
334 tracing::debug!("java.util.Hashtable::put({this:?}, {key:?}, {value:?})");
335
336 if value.is_null() {
337 return Err(jvm.exception("java/lang/NullPointerException", "Hashtable value is null").await);
338 }
339
340 let key_hash = Self::key_hash(jvm, &key).await?;
341 let mut table = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
342 let table_len = jvm.array_length(&table).await? as i32;
343 let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;
344
345 let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
346 while !entry.is_null() {
347 let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
348 if entry_hash == key_hash {
349 let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
350 let equals: bool = jvm
351 .invoke_virtual(&entry_key, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (key.clone(),))
352 .await?;
353 if equals {
354 let old_value: ClassInstanceRef<Object> = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?;
355 jvm.put_field(&mut entry, "value", "Ljava/lang/Object;", value).await?;
356 return Ok(old_value);
357 }
358 }
359 entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
360 }
361
362 let count: i32 = jvm.get_field(&this, "count", "I").await?;
363 let threshold: i32 = jvm.get_field(&this, "threshold", "I").await?;
364
365 if count >= threshold {
366 Self::rehash_table(jvm, &mut this).await?;
367 table = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
368 let new_table_len = jvm.array_length(&table).await? as i32;
369 let new_bucket_index = ((key_hash & 0x7FFFFFFF) % new_table_len) as usize;
370
371 let existing: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, new_bucket_index, 1).await?.into_iter().next().unwrap();
372 let new_entry = jvm
373 .new_class(
374 "java/util/Hashtable$Entry",
375 "(ILjava/lang/Object;Ljava/lang/Object;Ljava/util/Hashtable$Entry;)V",
376 (key_hash, key, value, existing),
377 )
378 .await?;
379 jvm.store_array(&mut table, new_bucket_index, core::iter::once(new_entry)).await?;
380 } else {
381 let existing: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
382 let new_entry = jvm
383 .new_class(
384 "java/util/Hashtable$Entry",
385 "(ILjava/lang/Object;Ljava/lang/Object;Ljava/util/Hashtable$Entry;)V",
386 (key_hash, key, value, existing),
387 )
388 .await?;
389 jvm.store_array(&mut table, bucket_index, core::iter::once(new_entry)).await?;
390 }
391
392 jvm.put_field(&mut this, "count", "I", count + 1).await?;
393
394 Ok(None.into())
395 }
396
397 async fn put_all(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, map: ClassInstanceRef<Object>) -> Result<()> {
398 tracing::debug!("java.util.Hashtable::putAll({this:?}, {map:?})");
399
400 if map.is_null() {
401 return Err(jvm.exception("java/lang/NullPointerException", "map").await);
402 }
403 if this.identity() == map.identity() {
404 return Ok(());
405 }
406
407 let entry_set: ClassInstanceRef<Object> = jvm
408 .invoke_virtual(&map, &map.class_definition().name(), "entrySet", "()Ljava/util/Set;", ())
409 .await?;
410 let entries: ClassInstanceRef<Array<Object>> = jvm
411 .invoke_virtual(&entry_set, &entry_set.class_definition().name(), "toArray", "()[Ljava/lang/Object;", ())
412 .await?;
413 let count = jvm.array_length(&entries).await?;
414 let mut validated = Vec::with_capacity(count);
415 for entry in jvm.load_array::<ClassInstanceRef<Object>>(&entries, 0, count).await? {
416 let key: ClassInstanceRef<Object> = jvm
417 .invoke_virtual(&entry, &entry.class_definition().name(), "getKey", "()Ljava/lang/Object;", ())
418 .await?;
419 let value: ClassInstanceRef<Object> = jvm
420 .invoke_virtual(&entry, &entry.class_definition().name(), "getValue", "()Ljava/lang/Object;", ())
421 .await?;
422 if key.is_null() {
423 return Err(jvm.exception("java/lang/NullPointerException", "Hashtable key is null").await);
424 }
425 if value.is_null() {
426 return Err(jvm.exception("java/lang/NullPointerException", "Hashtable value is null").await);
427 }
428 validated.push((key, value));
429 }
430
431 for (key, value) in validated {
432 let _: ClassInstanceRef<Object> = jvm
433 .invoke_virtual(
434 &this,
435 "java/util/Hashtable",
436 "put",
437 "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
438 (key, value),
439 )
440 .await?;
441 }
442
443 Ok(())
444 }
445
446 async fn clear(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
447 tracing::debug!("java.util.Hashtable::clear({this:?})");
448
449 let mut table: ClassInstanceRef<Array<HashtableEntry>> = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
450 let table_len = jvm.array_length(&table).await?;
451 if table_len > 0 {
452 let nulls: Vec<ClassInstanceRef<HashtableEntry>> = (0..table_len).map(|_| None.into()).collect();
453 jvm.store_array(&mut table, 0, nulls).await?;
454 }
455 jvm.put_field(&mut this, "count", "I", 0).await?;
456
457 Ok(())
458 }
459
460 async fn key_set(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
461 tracing::debug!("java.util.Hashtable::keySet({this:?})");
462
463 let key_set = jvm.new_class("java/util/Hashtable$KeySet", "(Ljava/util/Hashtable;)V", (this,)).await?;
464
465 Ok(key_set.into())
466 }
467
468 async fn values(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
469 tracing::debug!("java.util.Hashtable::values({this:?})");
470
471 let values = jvm.new_class("java/util/Hashtable$Values", "(Ljava/util/Hashtable;)V", (this,)).await?;
472
473 Ok(values.into())
474 }
475
476 async fn entry_set(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
477 tracing::debug!("java.util.Hashtable::entrySet({this:?})");
478
479 let entry_set = jvm.new_class("java/util/Hashtable$EntrySet", "(Ljava/util/Hashtable;)V", (this,)).await?;
480
481 Ok(entry_set.into())
482 }
483
484 pub(super) async fn keys_snapshot(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<Object>>> {
485 Self::snapshot_entries(jvm, this, SnapshotKind::Keys).await
486 }
487
488 pub(super) async fn values_snapshot(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<Object>>> {
489 Self::snapshot_entries(jvm, this, SnapshotKind::Values).await
490 }
491
492 pub(super) async fn entries_snapshot(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<Object>>> {
493 Self::snapshot_entries(jvm, this, SnapshotKind::Entries).await
494 }
495
496 pub(super) async fn find_entry(
497 jvm: &Jvm,
498 this: &ClassInstanceRef<Self>,
499 key: &ClassInstanceRef<Object>,
500 ) -> Result<ClassInstanceRef<HashtableEntry>> {
501 let key_hash = Self::key_hash(jvm, key).await?;
502 let table: ClassInstanceRef<Array<HashtableEntry>> = jvm.get_field(this, "table", "[Ljava/util/Hashtable$Entry;").await?;
503 let table_len = jvm.array_length(&table).await? as i32;
504 let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;
505
506 let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
507 while !entry.is_null() {
508 let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
509 if entry_hash == key_hash {
510 let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
511 let equals: bool = jvm
512 .invoke_virtual(&entry_key, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (key.clone(),))
513 .await?;
514 if equals {
515 return Ok(entry);
516 }
517 }
518
519 entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
520 }
521
522 Ok(None.into())
523 }
524
525 async fn rehash(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
526 tracing::debug!("java.util.Hashtable::rehash({this:?})");
527 Self::rehash_table(jvm, &mut this).await
528 }
529
530 async fn rehash_table(jvm: &Jvm, this: &mut ClassInstanceRef<Self>) -> Result<()> {
531 let old_table = jvm.get_field(this, "table", "[Ljava/util/Hashtable$Entry;").await?;
532 let old_capacity = jvm.array_length(&old_table).await?;
533 let new_capacity = old_capacity * 2 + 1;
534
535 let mut new_table = jvm.instantiate_array("Ljava/util/Hashtable$Entry;", new_capacity).await?;
536
537 for i in 0..old_capacity {
538 let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&old_table, i, 1).await?.into_iter().next().unwrap();
539 while !entry.is_null() {
540 let next: ClassInstanceRef<HashtableEntry> = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
541 let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
542 let new_index = ((entry_hash & 0x7FFFFFFF) % new_capacity as i32) as usize;
543
544 let existing: ClassInstanceRef<HashtableEntry> = jvm.load_array(&new_table, new_index, 1).await?.into_iter().next().unwrap();
545 jvm.put_field(&mut entry, "next", "Ljava/util/Hashtable$Entry;", existing).await?;
546 jvm.store_array(&mut new_table, new_index, core::iter::once(entry)).await?;
547
548 entry = next;
549 }
550 }
551
552 jvm.put_field(this, "table", "[Ljava/util/Hashtable$Entry;", new_table).await?;
553 jvm.put_field(this, "threshold", "I", (new_capacity as f32 * DEFAULT_LOAD_FACTOR) as i32)
554 .await?;
555
556 Ok(())
557 }
558
559 async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<bool> {
560 tracing::debug!("java.util.Hashtable::equals({this:?}, {other:?})");
561
562 if !other.is_null() && this.identity() == other.identity() {
563 return Ok(true);
564 }
565 if other.is_null() || !jvm.is_instance(other.as_ref(), "java/util/Map") {
566 return Ok(false);
567 }
568
569 let count: i32 = jvm.get_field(&this, "count", "I").await?;
570 let other_size: i32 = jvm.invoke_virtual(&other, &other.class_definition().name(), "size", "()I", ()).await?;
571 if count != other_size {
572 return Ok(false);
573 }
574
575 let comparison: Result<bool> = async {
576 let table: ClassInstanceRef<Array<HashtableEntry>> = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
577 let table_len = jvm.array_length(&table).await?;
578 for bucket_index in 0..table_len {
579 let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
580 while !entry.is_null() {
581 let key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
582 let value: ClassInstanceRef<Object> = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?;
583 let other_value: ClassInstanceRef<Object> = jvm
584 .invoke_virtual(
585 &other,
586 &other.class_definition().name(),
587 "get",
588 "(Ljava/lang/Object;)Ljava/lang/Object;",
589 (key.clone(),),
590 )
591 .await?;
592 if value.is_null() {
593 if !other_value.is_null()
594 || !jvm
595 .invoke_virtual::<_, bool>(&other, &other.class_definition().name(), "containsKey", "(Ljava/lang/Object;)Z", (key,))
596 .await?
597 {
598 return Ok(false);
599 }
600 } else if !jvm
601 .invoke_virtual::<_, bool>(&value, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (other_value,))
602 .await?
603 {
604 return Ok(false);
605 }
606
607 entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
608 }
609 }
610
611 Ok(true)
612 }
613 .await;
614 match comparison {
615 Err(JavaError::JavaException(exception))
616 if jvm.is_instance(exception.as_ref(), "java/lang/ClassCastException")
617 || jvm.is_instance(exception.as_ref(), "java/lang/NullPointerException") =>
618 {
619 Ok(false)
620 }
621 result => result,
622 }
623 }
624
625 async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<i32> {
626 tracing::debug!("java.util.Hashtable::hashCode({this:?})");
627
628 let count: i32 = jvm.get_field(&this, "count", "I").await?;
629 let load_factor: f32 = jvm.get_field(&this, "loadFactor", "F").await?;
630 if count == 0 || load_factor < 0.0 {
631 return Ok(0);
632 }
633
634 jvm.put_field(&mut this, "loadFactor", "F", -load_factor).await?;
635 let result: Result<i32> = async {
636 let table: ClassInstanceRef<Array<HashtableEntry>> = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
637 let table_len = jvm.array_length(&table).await?;
638 let mut hash = 0i32;
639 for bucket_index in 0..table_len {
640 let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
641 while !entry.is_null() {
642 hash = hash.wrapping_add(jvm.invoke_virtual::<_, i32>(&entry, "java/lang/Object", "hashCode", "()I", ()).await?);
643 entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
644 }
645 }
646
647 Ok(hash)
648 }
649 .await;
650 jvm.put_field(&mut this, "loadFactor", "F", load_factor).await?;
651 result
652 }
653
654 async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
655 tracing::debug!("java.util.Hashtable::toString({this:?})");
656
657 let snapshot = Self::entries_snapshot(jvm, &this).await?;
658 let count = jvm.array_length(&snapshot).await?;
659 let entries: Vec<ClassInstanceRef<Object>> = jvm.load_array(&snapshot, 0, count).await?;
660 let mut result = RustString::from("{");
661 for (index, entry) in entries.into_iter().enumerate() {
662 if index > 0 {
663 result.push_str(", ");
664 }
665
666 let entry: ClassInstanceRef<HashtableEntry> = ClassInstanceRef::new(entry.instance);
667 let key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
668 if key.instance.as_ref().unwrap().equals(&**this)? {
669 result.push_str("(this Map)");
670 } else {
671 let text: ClassInstanceRef<String> = jvm
672 .invoke_virtual(&key, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
673 .await?;
674 result.push_str(&JavaLangString::to_rust_string(jvm, &text).await?);
675 }
676 result.push('=');
677
678 let value: ClassInstanceRef<Object> = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?;
679 if value.instance.as_ref().unwrap().equals(&**this)? {
680 result.push_str("(this Map)");
681 } else {
682 let text: ClassInstanceRef<String> = jvm
683 .invoke_virtual(&value, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
684 .await?;
685 result.push_str(&JavaLangString::to_rust_string(jvm, &text).await?);
686 }
687 }
688 result.push('}');
689
690 Ok(JavaLangString::from_rust_string(jvm, &result).await?.into())
691 }
692
693 async fn load_bucket(
694 jvm: &Jvm,
695 table: &ClassInstanceRef<Array<HashtableEntry>>,
696 bucket_index: usize,
697 ) -> Result<ClassInstanceRef<HashtableEntry>> {
698 Ok(jvm.load_array(table, bucket_index, 1).await?.remove(0))
699 }
700
701 async fn key_hash(jvm: &Jvm, key: &ClassInstanceRef<Object>) -> Result<i32> {
702 if key.is_null() {
703 return Err(jvm.exception("java/lang/NullPointerException", "Hashtable key is null").await);
704 }
705
706 jvm.invoke_virtual(key, "java/lang/Object", "hashCode", "()I", ()).await
707 }
708
709 async fn object_equals(jvm: &Jvm, left: &ClassInstanceRef<Object>, right: &ClassInstanceRef<Object>) -> Result<bool> {
710 if left.is_null() {
711 return Ok(right.is_null());
712 }
713
714 if right.is_null() {
715 return Ok(false);
716 }
717
718 jvm.invoke_virtual(left, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (right.clone(),))
719 .await
720 }
721
722 async fn snapshot_entries(jvm: &Jvm, this: &ClassInstanceRef<Self>, kind: SnapshotKind) -> Result<ClassInstanceRef<Array<Object>>> {
723 let table: ClassInstanceRef<Array<HashtableEntry>> = jvm.get_field(this, "table", "[Ljava/util/Hashtable$Entry;").await?;
724 let table_len = jvm.array_length(&table).await?;
725 let count: i32 = jvm.get_field(this, "count", "I").await?;
726 let mut elements: Vec<ClassInstanceRef<Object>> = Vec::with_capacity(count as usize);
727
728 for bucket_index in 0..table_len {
729 let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
730 while !entry.is_null() {
731 let element = match kind {
732 SnapshotKind::Keys => jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?,
733 SnapshotKind::Values => jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?,
734 SnapshotKind::Entries => ClassInstanceRef::new(entry.clone().instance),
735 };
736 elements.push(element);
737
738 entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
739 }
740 }
741
742 let mut snapshot: ClassInstanceRef<Array<Object>> = jvm.instantiate_array("Ljava/lang/Object;", elements.len()).await?.into();
743 if !elements.is_empty() {
744 jvm.store_array(&mut snapshot, 0, elements).await?;
745 }
746
747 Ok(snapshot)
748 }
749}
750
751#[derive(Copy, Clone)]
752enum SnapshotKind {
753 Keys,
754 Values,
755 Entries,
756}