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