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, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;", table)
143 .await?;
144 jvm.put_field(&mut this, "java/util/Hashtable", "count", "I", 0).await?;
145 jvm.put_field(
146 &mut this,
147 "java/util/Hashtable",
148 "threshold",
149 "I",
150 (initial_capacity as f32 * DEFAULT_LOAD_FACTOR) as i32,
151 )
152 .await?;
153 jvm.put_field(&mut this, "java/util/Hashtable", "loadFactor", "F", DEFAULT_LOAD_FACTOR)
154 .await?;
155
156 Ok(())
157 }
158
159 async fn init_from_map(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, map: ClassInstanceRef<Object>) -> Result<()> {
160 tracing::debug!("java.util.Hashtable::<init>({this:?}, {map:?})");
161
162 if map.is_null() {
163 return Err(jvm.exception("java/lang/NullPointerException", "map").await);
164 }
165 let size: i32 = jvm.invoke_virtual(&map, &map.class_definition().name(), "size", "()I", ()).await?;
166 let capacity = size.saturating_mul(2).max(DEFAULT_INITIAL_CAPACITY);
167 let _: () = jvm.invoke_special(&this, "java/util/Hashtable", "<init>", "(I)V", (capacity,)).await?;
168 let _: () = jvm
169 .invoke_virtual(&this, "java/util/Hashtable", "putAll", "(Ljava/util/Map;)V", (map,))
170 .await?;
171
172 Ok(())
173 }
174
175 async fn contains(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Object>) -> Result<bool> {
176 tracing::debug!("java.util.Hashtable::contains({this:?}, {value:?})");
177 jvm.invoke_virtual(&this, "java/util/Hashtable", "containsValue", "(Ljava/lang/Object;)Z", (value,))
178 .await
179 }
180
181 async fn keys(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
182 tracing::debug!("java.util.Hashtable::keys({this:?})");
183
184 let snapshot = Self::keys_snapshot(jvm, &this).await?;
185 Ok(jvm
186 .new_class("java/util/Hashtable$Enumerator", "([Ljava/lang/Object;)V", (snapshot,))
187 .await?
188 .into())
189 }
190
191 async fn elements(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
192 tracing::debug!("java.util.Hashtable::elements({this:?})");
193
194 let snapshot = Self::values_snapshot(jvm, &this).await?;
195 Ok(jvm
196 .new_class("java/util/Hashtable$Enumerator", "([Ljava/lang/Object;)V", (snapshot,))
197 .await?
198 .into())
199 }
200
201 async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
202 tracing::debug!("java.util.Hashtable::size({this:?})");
203
204 jvm.get_field(&this, "java/util/Hashtable", "count", "I").await
205 }
206
207 async fn is_empty(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
208 tracing::debug!("java.util.Hashtable::isEmpty({this:?})");
209
210 let count: i32 = jvm.get_field(&this, "java/util/Hashtable", "count", "I").await?;
211
212 Ok(count == 0)
213 }
214
215 async fn contains_key(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, key: ClassInstanceRef<Object>) -> Result<bool> {
216 tracing::debug!("java.util.Hashtable::containsKey({this:?}, {key:?})");
217
218 let key_hash = Self::key_hash(jvm, &key).await?;
219 let table = jvm
220 .get_field(&this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;")
221 .await?;
222 let table_len = jvm.array_length(&table).await? as i32;
223 let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;
224
225 let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
226 while !entry.is_null() {
227 let entry_hash: i32 = jvm.get_field(&entry, "java/util/Hashtable$Entry", "hash", "I").await?;
228 if entry_hash == key_hash {
229 let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "java/util/Hashtable$Entry", "key", "Ljava/lang/Object;").await?;
230 let equals: bool = jvm
231 .invoke_virtual(&entry_key, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (key.clone(),))
232 .await?;
233 if equals {
234 return Ok(true);
235 }
236 }
237 entry = jvm
238 .get_field(&entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;")
239 .await?;
240 }
241
242 Ok(false)
243 }
244
245 async fn contains_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Object>) -> Result<bool> {
246 tracing::debug!("java.util.Hashtable::containsValue({this:?}, {value:?})");
247
248 if value.is_null() {
249 return Err(jvm.exception("java/lang/NullPointerException", "Hashtable value is null").await);
250 }
251
252 let table: ClassInstanceRef<Array<HashtableEntry>> = jvm
253 .get_field(&this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;")
254 .await?;
255 let table_len = jvm.array_length(&table).await?;
256 for bucket_index in 0..table_len {
257 let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
258 while !entry.is_null() {
259 let entry_value: ClassInstanceRef<Object> = jvm.get_field(&entry, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;").await?;
260 if Self::object_equals(jvm, &value, &entry_value).await? {
261 return Ok(true);
262 }
263
264 entry = jvm
265 .get_field(&entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;")
266 .await?;
267 }
268 }
269
270 Ok(false)
271 }
272
273 async fn get(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, key: ClassInstanceRef<Object>) -> Result<ClassInstanceRef<Object>> {
274 tracing::debug!("java.util.Hashtable::get({this:?}, {key:?})");
275
276 let key_hash = Self::key_hash(jvm, &key).await?;
277 let table = jvm
278 .get_field(&this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;")
279 .await?;
280 let table_len = jvm.array_length(&table).await? as i32;
281 let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;
282
283 let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
284 while !entry.is_null() {
285 let entry_hash: i32 = jvm.get_field(&entry, "java/util/Hashtable$Entry", "hash", "I").await?;
286 if entry_hash == key_hash {
287 let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "java/util/Hashtable$Entry", "key", "Ljava/lang/Object;").await?;
288 let equals: bool = jvm
289 .invoke_virtual(&entry_key, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (key.clone(),))
290 .await?;
291 if equals {
292 return jvm.get_field(&entry, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;").await;
293 }
294 }
295 entry = jvm
296 .get_field(&entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;")
297 .await?;
298 }
299
300 Ok(None.into())
301 }
302
303 async fn remove(
304 jvm: &Jvm,
305 _: &mut RuntimeContext,
306 mut this: ClassInstanceRef<Self>,
307 key: ClassInstanceRef<Object>,
308 ) -> Result<ClassInstanceRef<Object>> {
309 tracing::debug!("java.util.Hashtable::remove({this:?}, {key:?})");
310
311 let key_hash = Self::key_hash(jvm, &key).await?;
312 let mut table = jvm
313 .get_field(&this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;")
314 .await?;
315 let table_len = jvm.array_length(&table).await? as i32;
316 let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;
317
318 let mut prev: ClassInstanceRef<HashtableEntry> = None.into();
319 let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
320
321 while !entry.is_null() {
322 let entry_hash: i32 = jvm.get_field(&entry, "java/util/Hashtable$Entry", "hash", "I").await?;
323 if entry_hash == key_hash {
324 let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "java/util/Hashtable$Entry", "key", "Ljava/lang/Object;").await?;
325 let equals: bool = jvm
326 .invoke_virtual(&entry_key, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (key.clone(),))
327 .await?;
328 if equals {
329 let next: ClassInstanceRef<HashtableEntry> = jvm
330 .get_field(&entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;")
331 .await?;
332 if prev.is_null() {
333 jvm.store_array(&mut table, bucket_index, core::iter::once(next)).await?;
334 } else {
335 jvm.put_field(&mut prev, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;", next)
336 .await?;
337 }
338
339 let count: i32 = jvm.get_field(&this, "java/util/Hashtable", "count", "I").await?;
340 jvm.put_field(&mut this, "java/util/Hashtable", "count", "I", count - 1).await?;
341
342 return jvm.get_field(&entry, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;").await;
343 }
344 }
345 prev = entry;
346 entry = jvm
347 .get_field(&prev, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;")
348 .await?;
349 }
350
351 Ok(None.into())
352 }
353
354 async fn put(
355 jvm: &Jvm,
356 _: &mut RuntimeContext,
357 mut this: ClassInstanceRef<Self>,
358 key: ClassInstanceRef<Object>,
359 value: ClassInstanceRef<Object>,
360 ) -> Result<ClassInstanceRef<Object>> {
361 tracing::debug!("java.util.Hashtable::put({this:?}, {key:?}, {value:?})");
362
363 if value.is_null() {
364 return Err(jvm.exception("java/lang/NullPointerException", "Hashtable value is null").await);
365 }
366
367 let key_hash = Self::key_hash(jvm, &key).await?;
368 let mut table = jvm
369 .get_field(&this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;")
370 .await?;
371 let table_len = jvm.array_length(&table).await? as i32;
372 let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;
373
374 let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
375 while !entry.is_null() {
376 let entry_hash: i32 = jvm.get_field(&entry, "java/util/Hashtable$Entry", "hash", "I").await?;
377 if entry_hash == key_hash {
378 let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "java/util/Hashtable$Entry", "key", "Ljava/lang/Object;").await?;
379 let equals: bool = jvm
380 .invoke_virtual(&entry_key, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (key.clone(),))
381 .await?;
382 if equals {
383 let old_value: ClassInstanceRef<Object> =
384 jvm.get_field(&entry, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;").await?;
385 jvm.put_field(&mut entry, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;", value)
386 .await?;
387 return Ok(old_value);
388 }
389 }
390 entry = jvm
391 .get_field(&entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;")
392 .await?;
393 }
394
395 let count: i32 = jvm.get_field(&this, "java/util/Hashtable", "count", "I").await?;
396 let threshold: i32 = jvm.get_field(&this, "java/util/Hashtable", "threshold", "I").await?;
397
398 if count >= threshold {
399 Self::rehash_table(jvm, &mut this).await?;
400 table = jvm
401 .get_field(&this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;")
402 .await?;
403 let new_table_len = jvm.array_length(&table).await? as i32;
404 let new_bucket_index = ((key_hash & 0x7FFFFFFF) % new_table_len) as usize;
405
406 let existing: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, new_bucket_index, 1).await?.into_iter().next().unwrap();
407 let new_entry = jvm
408 .new_class(
409 "java/util/Hashtable$Entry",
410 "(ILjava/lang/Object;Ljava/lang/Object;Ljava/util/Hashtable$Entry;)V",
411 (key_hash, key, value, existing),
412 )
413 .await?;
414 jvm.store_array(&mut table, new_bucket_index, core::iter::once(new_entry)).await?;
415 } else {
416 let existing: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
417 let new_entry = jvm
418 .new_class(
419 "java/util/Hashtable$Entry",
420 "(ILjava/lang/Object;Ljava/lang/Object;Ljava/util/Hashtable$Entry;)V",
421 (key_hash, key, value, existing),
422 )
423 .await?;
424 jvm.store_array(&mut table, bucket_index, core::iter::once(new_entry)).await?;
425 }
426
427 jvm.put_field(&mut this, "java/util/Hashtable", "count", "I", count + 1).await?;
428
429 Ok(None.into())
430 }
431
432 async fn put_all(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, map: ClassInstanceRef<Object>) -> Result<()> {
433 tracing::debug!("java.util.Hashtable::putAll({this:?}, {map:?})");
434
435 if map.is_null() {
436 return Err(jvm.exception("java/lang/NullPointerException", "map").await);
437 }
438 if this.identity() == map.identity() {
439 return Ok(());
440 }
441
442 let entry_set: ClassInstanceRef<Object> = jvm
443 .invoke_virtual(&map, &map.class_definition().name(), "entrySet", "()Ljava/util/Set;", ())
444 .await?;
445 let entries: ClassInstanceRef<Array<Object>> = jvm
446 .invoke_virtual(&entry_set, &entry_set.class_definition().name(), "toArray", "()[Ljava/lang/Object;", ())
447 .await?;
448 let count = jvm.array_length(&entries).await?;
449 let mut validated = Vec::with_capacity(count);
450 for entry in jvm.load_array::<ClassInstanceRef<Object>>(&entries, 0, count).await? {
451 let key: ClassInstanceRef<Object> = jvm
452 .invoke_virtual(&entry, &entry.class_definition().name(), "getKey", "()Ljava/lang/Object;", ())
453 .await?;
454 let value: ClassInstanceRef<Object> = jvm
455 .invoke_virtual(&entry, &entry.class_definition().name(), "getValue", "()Ljava/lang/Object;", ())
456 .await?;
457 if key.is_null() {
458 return Err(jvm.exception("java/lang/NullPointerException", "Hashtable key is null").await);
459 }
460 if value.is_null() {
461 return Err(jvm.exception("java/lang/NullPointerException", "Hashtable value is null").await);
462 }
463 validated.push((key, value));
464 }
465
466 for (key, value) in validated {
467 let _: ClassInstanceRef<Object> = jvm
468 .invoke_virtual(
469 &this,
470 "java/util/Hashtable",
471 "put",
472 "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
473 (key, value),
474 )
475 .await?;
476 }
477
478 Ok(())
479 }
480
481 async fn clear(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
482 tracing::debug!("java.util.Hashtable::clear({this:?})");
483
484 let mut table: ClassInstanceRef<Array<HashtableEntry>> = jvm
485 .get_field(&this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;")
486 .await?;
487 let table_len = jvm.array_length(&table).await?;
488 if table_len > 0 {
489 let nulls: Vec<ClassInstanceRef<HashtableEntry>> = (0..table_len).map(|_| None.into()).collect();
490 jvm.store_array(&mut table, 0, nulls).await?;
491 }
492 jvm.put_field(&mut this, "java/util/Hashtable", "count", "I", 0).await?;
493
494 Ok(())
495 }
496
497 async fn key_set(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
498 tracing::debug!("java.util.Hashtable::keySet({this:?})");
499
500 let key_set = jvm.new_class("java/util/Hashtable$KeySet", "(Ljava/util/Hashtable;)V", (this,)).await?;
501
502 Ok(key_set.into())
503 }
504
505 async fn values(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
506 tracing::debug!("java.util.Hashtable::values({this:?})");
507
508 let values = jvm.new_class("java/util/Hashtable$Values", "(Ljava/util/Hashtable;)V", (this,)).await?;
509
510 Ok(values.into())
511 }
512
513 async fn entry_set(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
514 tracing::debug!("java.util.Hashtable::entrySet({this:?})");
515
516 let entry_set = jvm.new_class("java/util/Hashtable$EntrySet", "(Ljava/util/Hashtable;)V", (this,)).await?;
517
518 Ok(entry_set.into())
519 }
520
521 pub(super) async fn keys_snapshot(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<Object>>> {
522 Self::snapshot_entries(jvm, this, SnapshotKind::Keys).await
523 }
524
525 pub(super) async fn values_snapshot(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<Object>>> {
526 Self::snapshot_entries(jvm, this, SnapshotKind::Values).await
527 }
528
529 pub(super) async fn entries_snapshot(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<Object>>> {
530 Self::snapshot_entries(jvm, this, SnapshotKind::Entries).await
531 }
532
533 pub(super) async fn find_entry(
534 jvm: &Jvm,
535 this: &ClassInstanceRef<Self>,
536 key: &ClassInstanceRef<Object>,
537 ) -> Result<ClassInstanceRef<HashtableEntry>> {
538 let key_hash = Self::key_hash(jvm, key).await?;
539 let table: ClassInstanceRef<Array<HashtableEntry>> = jvm
540 .get_field(this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;")
541 .await?;
542 let table_len = jvm.array_length(&table).await? as i32;
543 let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;
544
545 let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
546 while !entry.is_null() {
547 let entry_hash: i32 = jvm.get_field(&entry, "java/util/Hashtable$Entry", "hash", "I").await?;
548 if entry_hash == key_hash {
549 let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "java/util/Hashtable$Entry", "key", "Ljava/lang/Object;").await?;
550 let equals: bool = jvm
551 .invoke_virtual(&entry_key, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (key.clone(),))
552 .await?;
553 if equals {
554 return Ok(entry);
555 }
556 }
557
558 entry = jvm
559 .get_field(&entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;")
560 .await?;
561 }
562
563 Ok(None.into())
564 }
565
566 async fn rehash(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
567 tracing::debug!("java.util.Hashtable::rehash({this:?})");
568 Self::rehash_table(jvm, &mut this).await
569 }
570
571 async fn rehash_table(jvm: &Jvm, this: &mut ClassInstanceRef<Self>) -> Result<()> {
572 let old_table = jvm
573 .get_field(this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;")
574 .await?;
575 let old_capacity = jvm.array_length(&old_table).await?;
576 let new_capacity = old_capacity * 2 + 1;
577
578 let mut new_table = jvm.instantiate_array("Ljava/util/Hashtable$Entry;", new_capacity).await?;
579
580 for i in 0..old_capacity {
581 let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&old_table, i, 1).await?.into_iter().next().unwrap();
582 while !entry.is_null() {
583 let next: ClassInstanceRef<HashtableEntry> = jvm
584 .get_field(&entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;")
585 .await?;
586 let entry_hash: i32 = jvm.get_field(&entry, "java/util/Hashtable$Entry", "hash", "I").await?;
587 let new_index = ((entry_hash & 0x7FFFFFFF) % new_capacity as i32) as usize;
588
589 let existing: ClassInstanceRef<HashtableEntry> = jvm.load_array(&new_table, new_index, 1).await?.into_iter().next().unwrap();
590 jvm.put_field(&mut entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;", existing)
591 .await?;
592 jvm.store_array(&mut new_table, new_index, core::iter::once(entry)).await?;
593
594 entry = next;
595 }
596 }
597
598 jvm.put_field(this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;", new_table)
599 .await?;
600 jvm.put_field(
601 this,
602 "java/util/Hashtable",
603 "threshold",
604 "I",
605 (new_capacity as f32 * DEFAULT_LOAD_FACTOR) as i32,
606 )
607 .await?;
608
609 Ok(())
610 }
611
612 async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<bool> {
613 tracing::debug!("java.util.Hashtable::equals({this:?}, {other:?})");
614
615 if !other.is_null() && this.identity() == other.identity() {
616 return Ok(true);
617 }
618 if other.is_null() || !jvm.is_instance(other.as_ref(), "java/util/Map") {
619 return Ok(false);
620 }
621
622 let count: i32 = jvm.get_field(&this, "java/util/Hashtable", "count", "I").await?;
623 let other_size: i32 = jvm.invoke_virtual(&other, &other.class_definition().name(), "size", "()I", ()).await?;
624 if count != other_size {
625 return Ok(false);
626 }
627
628 let comparison: Result<bool> = async {
629 let table: ClassInstanceRef<Array<HashtableEntry>> = jvm
630 .get_field(&this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;")
631 .await?;
632 let table_len = jvm.array_length(&table).await?;
633 for bucket_index in 0..table_len {
634 let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
635 while !entry.is_null() {
636 let key: ClassInstanceRef<Object> = jvm.get_field(&entry, "java/util/Hashtable$Entry", "key", "Ljava/lang/Object;").await?;
637 let value: ClassInstanceRef<Object> = jvm.get_field(&entry, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;").await?;
638 let other_value: ClassInstanceRef<Object> = jvm
639 .invoke_virtual(
640 &other,
641 &other.class_definition().name(),
642 "get",
643 "(Ljava/lang/Object;)Ljava/lang/Object;",
644 (key.clone(),),
645 )
646 .await?;
647 if value.is_null() {
648 if !other_value.is_null()
649 || !jvm
650 .invoke_virtual::<_, bool>(&other, &other.class_definition().name(), "containsKey", "(Ljava/lang/Object;)Z", (key,))
651 .await?
652 {
653 return Ok(false);
654 }
655 } else if !jvm
656 .invoke_virtual::<_, bool>(&value, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (other_value,))
657 .await?
658 {
659 return Ok(false);
660 }
661
662 entry = jvm
663 .get_field(&entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;")
664 .await?;
665 }
666 }
667
668 Ok(true)
669 }
670 .await;
671 match comparison {
672 Err(JavaError::JavaException(exception))
673 if jvm.is_instance(exception.as_ref(), "java/lang/ClassCastException")
674 || jvm.is_instance(exception.as_ref(), "java/lang/NullPointerException") =>
675 {
676 Ok(false)
677 }
678 result => result,
679 }
680 }
681
682 async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<i32> {
683 tracing::debug!("java.util.Hashtable::hashCode({this:?})");
684
685 let count: i32 = jvm.get_field(&this, "java/util/Hashtable", "count", "I").await?;
686 let load_factor: f32 = jvm.get_field(&this, "java/util/Hashtable", "loadFactor", "F").await?;
687 if count == 0 || load_factor < 0.0 {
688 return Ok(0);
689 }
690
691 jvm.put_field(&mut this, "java/util/Hashtable", "loadFactor", "F", -load_factor).await?;
692 let result: Result<i32> = async {
693 let table: ClassInstanceRef<Array<HashtableEntry>> = jvm
694 .get_field(&this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;")
695 .await?;
696 let table_len = jvm.array_length(&table).await?;
697 let mut hash = 0i32;
698 for bucket_index in 0..table_len {
699 let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
700 while !entry.is_null() {
701 hash = hash.wrapping_add(jvm.invoke_virtual::<_, i32>(&entry, "java/lang/Object", "hashCode", "()I", ()).await?);
702 entry = jvm
703 .get_field(&entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;")
704 .await?;
705 }
706 }
707
708 Ok(hash)
709 }
710 .await;
711 jvm.put_field(&mut this, "java/util/Hashtable", "loadFactor", "F", load_factor).await?;
712 result
713 }
714
715 async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
716 tracing::debug!("java.util.Hashtable::toString({this:?})");
717
718 let snapshot = Self::entries_snapshot(jvm, &this).await?;
719 let count = jvm.array_length(&snapshot).await?;
720 let entries: Vec<ClassInstanceRef<Object>> = jvm.load_array(&snapshot, 0, count).await?;
721 let mut result = RustString::from("{");
722 for (index, entry) in entries.into_iter().enumerate() {
723 if index > 0 {
724 result.push_str(", ");
725 }
726
727 let entry: ClassInstanceRef<HashtableEntry> = ClassInstanceRef::new(entry.instance);
728 let key: ClassInstanceRef<Object> = jvm.get_field(&entry, "java/util/Hashtable$Entry", "key", "Ljava/lang/Object;").await?;
729 if key.instance.as_ref().unwrap().equals(&**this)? {
730 result.push_str("(this Map)");
731 } else {
732 let text: ClassInstanceRef<String> = jvm
733 .invoke_virtual(&key, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
734 .await?;
735 result.push_str(&JavaLangString::to_rust_string(jvm, &text).await?);
736 }
737 result.push('=');
738
739 let value: ClassInstanceRef<Object> = jvm.get_field(&entry, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;").await?;
740 if value.instance.as_ref().unwrap().equals(&**this)? {
741 result.push_str("(this Map)");
742 } else {
743 let text: ClassInstanceRef<String> = jvm
744 .invoke_virtual(&value, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
745 .await?;
746 result.push_str(&JavaLangString::to_rust_string(jvm, &text).await?);
747 }
748 }
749 result.push('}');
750
751 Ok(JavaLangString::from_rust_string(jvm, &result).await?.into())
752 }
753
754 async fn load_bucket(
755 jvm: &Jvm,
756 table: &ClassInstanceRef<Array<HashtableEntry>>,
757 bucket_index: usize,
758 ) -> Result<ClassInstanceRef<HashtableEntry>> {
759 Ok(jvm.load_array(table, bucket_index, 1).await?.remove(0))
760 }
761
762 async fn key_hash(jvm: &Jvm, key: &ClassInstanceRef<Object>) -> Result<i32> {
763 if key.is_null() {
764 return Err(jvm.exception("java/lang/NullPointerException", "Hashtable key is null").await);
765 }
766
767 jvm.invoke_virtual(key, "java/lang/Object", "hashCode", "()I", ()).await
768 }
769
770 async fn object_equals(jvm: &Jvm, left: &ClassInstanceRef<Object>, right: &ClassInstanceRef<Object>) -> Result<bool> {
771 if left.is_null() {
772 return Ok(right.is_null());
773 }
774
775 if right.is_null() {
776 return Ok(false);
777 }
778
779 jvm.invoke_virtual(left, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (right.clone(),))
780 .await
781 }
782
783 async fn snapshot_entries(jvm: &Jvm, this: &ClassInstanceRef<Self>, kind: SnapshotKind) -> Result<ClassInstanceRef<Array<Object>>> {
784 let table: ClassInstanceRef<Array<HashtableEntry>> = jvm
785 .get_field(this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;")
786 .await?;
787 let table_len = jvm.array_length(&table).await?;
788 let count: i32 = jvm.get_field(this, "java/util/Hashtable", "count", "I").await?;
789 let mut elements: Vec<ClassInstanceRef<Object>> = Vec::with_capacity(count as usize);
790
791 for bucket_index in 0..table_len {
792 let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
793 while !entry.is_null() {
794 let element = match kind {
795 SnapshotKind::Keys => jvm.get_field(&entry, "java/util/Hashtable$Entry", "key", "Ljava/lang/Object;").await?,
796 SnapshotKind::Values => jvm.get_field(&entry, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;").await?,
797 SnapshotKind::Entries => ClassInstanceRef::new(entry.clone().instance),
798 };
799 elements.push(element);
800
801 entry = jvm
802 .get_field(&entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;")
803 .await?;
804 }
805 }
806
807 let mut snapshot: ClassInstanceRef<Array<Object>> = jvm.instantiate_array("Ljava/lang/Object;", elements.len()).await?.into();
808 if !elements.is_empty() {
809 jvm.store_array(&mut snapshot, 0, elements).await?;
810 }
811
812 Ok(snapshot)
813 }
814}
815
816#[derive(Copy, Clone)]
817enum SnapshotKind {
818 Keys,
819 Values,
820 Entries,
821}