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 keys_snapshot(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<Object>>> {
129 Self::snapshot_entries(jvm, this, SnapshotKind::Keys).await
130 }
131
132 async fn values_snapshot(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<Object>>> {
133 Self::snapshot_entries(jvm, this, SnapshotKind::Values).await
134 }
135
136 async fn entries_snapshot(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<Object>>> {
137 Self::snapshot_entries(jvm, this, SnapshotKind::Entries).await
138 }
139
140 async fn init_with_capacity(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, capacity: i32) -> Result<()> {
141 tracing::debug!("java.util.HashMap::<init>({this:?}, {capacity:?})");
142
143 jvm.invoke_special(&this, "java/util/HashMap", "<init>", "(IF)V", (capacity, DEFAULT_LOAD_FACTOR))
144 .await
145 }
146
147 async fn init_with_capacity_and_load_factor(
148 jvm: &Jvm,
149 _: &mut RuntimeContext,
150 mut this: ClassInstanceRef<Self>,
151 capacity: i32,
152 load_factor: f32,
153 ) -> Result<()> {
154 tracing::debug!("java.util.HashMap::<init>({this:?}, {capacity:?}, {load_factor:?})");
155
156 if capacity < 0 {
157 return Err(jvm
158 .exception("java/lang/IllegalArgumentException", &format!("Illegal Capacity: {capacity}"))
159 .await);
160 }
161 if load_factor <= 0.0 || load_factor.is_nan() {
162 return Err(jvm
163 .exception("java/lang/IllegalArgumentException", &format!("Illegal Load: {load_factor}"))
164 .await);
165 }
166
167 let _: () = jvm.invoke_special(&this, "java/util/AbstractMap", "<init>", "()V", ()).await?;
168
169 let table: ClassInstanceRef<Array<HashMapEntry>> = jvm.instantiate_array("Ljava/util/HashMap$Entry;", capacity as usize).await?.into();
170 jvm.put_field(&mut this, "table", "[Ljava/util/HashMap$Entry;", table).await?;
171 jvm.put_field(&mut this, "size", "I", 0).await?;
172 jvm.put_field(&mut this, "threshold", "I", Self::threshold_for_capacity(capacity, load_factor))
173 .await?;
174 jvm.put_field(&mut this, "loadFactor", "F", load_factor).await?;
175 jvm.put_field(&mut this, "modCount", "I", 0).await?;
176 let _: () = jvm.invoke_virtual(&this, "java/util/HashMap", "initializeMap", "()V", ()).await?;
177
178 Ok(())
179 }
180
181 async fn init_from_map(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, map: ClassInstanceRef<Object>) -> Result<()> {
182 tracing::debug!("java.util.HashMap::<init>({this:?}, {map:?})");
183
184 if map.is_null() {
185 return Err(jvm.exception("java/lang/NullPointerException", "map").await);
186 }
187 let size: i32 = jvm.invoke_virtual(&map, &map.class_definition().name(), "size", "()I", ()).await?;
188 let capacity = size.saturating_mul(2).max(DEFAULT_INITIAL_CAPACITY);
189 let _: () = jvm
190 .invoke_special(&this, "java/util/HashMap", "<init>", "(IF)V", (capacity, DEFAULT_LOAD_FACTOR))
191 .await?;
192 let entry_set: ClassInstanceRef<Object> = jvm
193 .invoke_virtual(&map, &map.class_definition().name(), "entrySet", "()Ljava/util/Set;", ())
194 .await?;
195 let entries: ClassInstanceRef<Array<Object>> = jvm
196 .invoke_virtual(&entry_set, &entry_set.class_definition().name(), "toArray", "()[Ljava/lang/Object;", ())
197 .await?;
198 let count = jvm.array_length(&entries).await?;
199 for entry in jvm.load_array::<ClassInstanceRef<Object>>(&entries, 0, count).await? {
200 let key: ClassInstanceRef<Object> = jvm
201 .invoke_virtual(&entry, &entry.class_definition().name(), "getKey", "()Ljava/lang/Object;", ())
202 .await?;
203 let value: ClassInstanceRef<Object> = jvm
204 .invoke_virtual(&entry, &entry.class_definition().name(), "getValue", "()Ljava/lang/Object;", ())
205 .await?;
206 Self::put_for_create(jvm, &mut this, key, value).await?;
207 }
208
209 Ok(())
210 }
211
212 async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
213 tracing::debug!("java.util.HashMap::size({this:?})");
214
215 jvm.get_field(&this, "size", "I").await
216 }
217
218 async fn is_empty(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
219 tracing::debug!("java.util.HashMap::isEmpty({this:?})");
220
221 let size: i32 = jvm.get_field(&this, "size", "I").await?;
222
223 Ok(size == 0)
224 }
225
226 async fn contains_key(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, key: ClassInstanceRef<Object>) -> Result<bool> {
227 tracing::debug!("java.util.HashMap::containsKey({this:?}, {key:?})");
228
229 let entry = Self::find_entry(jvm, &this, &key).await?;
230
231 Ok(!entry.is_null())
232 }
233
234 async fn contains_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Object>) -> Result<bool> {
235 tracing::debug!("java.util.HashMap::containsValue({this:?}, {value:?})");
236
237 let table: ClassInstanceRef<Array<HashMapEntry>> = jvm.get_field(&this, "table", "[Ljava/util/HashMap$Entry;").await?;
238 let table_len = jvm.array_length(&table).await?;
239 for bucket_index in 0..table_len {
240 let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
241 while !entry.is_null() {
242 let entry_value: ClassInstanceRef<Object> = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?;
243 if Self::object_equals(jvm, &value, &entry_value).await? {
244 return Ok(true);
245 }
246
247 entry = jvm.get_field(&entry, "next", "Ljava/util/HashMap$Entry;").await?;
248 }
249 }
250
251 Ok(false)
252 }
253
254 async fn get(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, key: ClassInstanceRef<Object>) -> Result<ClassInstanceRef<Object>> {
255 tracing::debug!("java.util.HashMap::get({this:?}, {key:?})");
256
257 let entry = Self::find_entry(jvm, &this, &key).await?;
258 if entry.is_null() {
259 return Ok(None.into());
260 }
261
262 jvm.get_field(&entry, "value", "Ljava/lang/Object;").await
263 }
264
265 async fn put(
266 jvm: &Jvm,
267 _: &mut RuntimeContext,
268 mut this: ClassInstanceRef<Self>,
269 key: ClassInstanceRef<Object>,
270 value: ClassInstanceRef<Object>,
271 ) -> Result<ClassInstanceRef<Object>> {
272 tracing::debug!("java.util.HashMap::put({this:?}, {key:?}, {value:?})");
273
274 let key_hash = Self::object_hash_or_zero(jvm, &key).await?;
275 Self::ensure_table_for_insert(jvm, &mut this).await?;
276
277 let table: ClassInstanceRef<Array<HashMapEntry>> = jvm.get_field(&this, "table", "[Ljava/util/HashMap$Entry;").await?;
278 let table_len = jvm.array_length(&table).await?;
279 let bucket_index = Self::bucket_index(key_hash, table_len);
280
281 let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
282 while !entry.is_null() {
283 let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
284 if entry_hash == key_hash {
285 let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
286 if Self::keys_equal(jvm, &key, &entry_key).await? {
287 let old_value: ClassInstanceRef<Object> = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?;
288 jvm.put_field(&mut entry, "value", "Ljava/lang/Object;", value).await?;
289 let _: () = jvm
290 .invoke_virtual(&entry, "java/util/HashMap$Entry", "onAccess", "(Ljava/util/HashMap;)V", (this.clone(),))
291 .await?;
292 return Ok(old_value);
293 }
294 }
295
296 entry = jvm.get_field(&entry, "next", "Ljava/util/HashMap$Entry;").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>> = jvm.get_field(&this, "table", "[Ljava/util/HashMap$Entry;").await?;
329 let table_len = jvm.array_length(&table).await?;
330 if table_len == 0 {
331 return Ok(None.into());
332 }
333 let bucket_index = Self::bucket_index(key_hash, table_len);
334
335 let mut previous: ClassInstanceRef<HashMapEntry> = None.into();
336 let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
337 while !entry.is_null() {
338 let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
339 if entry_hash == key_hash {
340 let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
341 if Self::keys_equal(jvm, &key, &entry_key).await? {
342 let next: ClassInstanceRef<HashMapEntry> = jvm.get_field(&entry, "next", "Ljava/util/HashMap$Entry;").await?;
343 if previous.is_null() {
344 jvm.store_array(&mut table, bucket_index, core::iter::once(next.clone())).await?;
345 } else {
346 jvm.put_field(&mut previous, "next", "Ljava/util/HashMap$Entry;", next.clone()).await?;
347 }
348
349 let old_value: ClassInstanceRef<Object> = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?;
350 let _: () = jvm
351 .invoke_virtual(&entry, "java/util/HashMap$Entry", "onRemoval", "(Ljava/util/HashMap;)V", (this.clone(),))
352 .await?;
353 let null_entry: ClassInstanceRef<HashMapEntry> = None.into();
354 jvm.put_field(&mut entry, "next", "Ljava/util/HashMap$Entry;", null_entry).await?;
355
356 let size: i32 = jvm.get_field(&this, "size", "I").await?;
357 jvm.put_field(&mut this, "size", "I", size - 1).await?;
358 let mod_count: i32 = jvm.get_field(&this, "modCount", "I").await?;
359 jvm.put_field(&mut this, "modCount", "I", mod_count.wrapping_add(1)).await?;
360
361 return Ok(old_value);
362 }
363 }
364
365 previous = entry;
366 entry = jvm.get_field(&previous, "next", "Ljava/util/HashMap$Entry;").await?;
367 }
368
369 Ok(None.into())
370 }
371
372 async fn clear(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
373 tracing::debug!("java.util.HashMap::clear({this:?})");
374
375 let mut table: ClassInstanceRef<Array<HashMapEntry>> = jvm.get_field(&this, "table", "[Ljava/util/HashMap$Entry;").await?;
376 let table_len = jvm.array_length(&table).await?;
377 if table_len > 0 {
378 let nulls: Vec<ClassInstanceRef<HashMapEntry>> = (0..table_len).map(|_| None.into()).collect();
379 jvm.store_array(&mut table, 0, nulls).await?;
380 }
381 jvm.put_field(&mut this, "size", "I", 0).await?;
382 let mod_count: i32 = jvm.get_field(&this, "modCount", "I").await?;
383 jvm.put_field(&mut this, "modCount", "I", mod_count.wrapping_add(1)).await?;
384
385 Ok(())
386 }
387
388 async fn initialize_map(_: &Jvm, _: &mut RuntimeContext, _: ClassInstanceRef<Self>) -> Result<()> {
389 Ok(())
390 }
391
392 async fn store_new_entry(
393 jvm: &Jvm,
394 _: &mut RuntimeContext,
395 mut this: ClassInstanceRef<Self>,
396 hash: i32,
397 key: ClassInstanceRef<Object>,
398 value: ClassInstanceRef<Object>,
399 bucket_index: i32,
400 ) -> Result<()> {
401 let mut table: ClassInstanceRef<Array<HashMapEntry>> = jvm.get_field(&this, "table", "[Ljava/util/HashMap$Entry;").await?;
402 let existing = Self::load_bucket(jvm, &table, bucket_index as usize).await?;
403 let entry: ClassInstanceRef<HashMapEntry> = jvm
404 .new_class(
405 "java/util/HashMap$Entry",
406 "(ILjava/lang/Object;Ljava/lang/Object;Ljava/util/HashMap$Entry;)V",
407 (hash, key, value, existing),
408 )
409 .await?
410 .into();
411 jvm.store_array(&mut table, bucket_index as usize, core::iter::once(entry)).await?;
412 let size: i32 = jvm.get_field(&this, "size", "I").await?;
413 jvm.put_field(&mut this, "size", "I", size + 1).await
414 }
415
416 async fn insert_new_entry(
417 jvm: &Jvm,
418 _: &mut RuntimeContext,
419 mut this: ClassInstanceRef<Self>,
420 hash: i32,
421 key: ClassInstanceRef<Object>,
422 value: ClassInstanceRef<Object>,
423 bucket_index: i32,
424 ) -> Result<()> {
425 let size: i32 = jvm.get_field(&this, "size", "I").await?;
426 let mod_count: i32 = jvm.get_field(&this, "modCount", "I").await?;
427 jvm.put_field(&mut this, "modCount", "I", mod_count.wrapping_add(1)).await?;
428 let _: () = jvm
429 .invoke_virtual(
430 &this,
431 "java/util/HashMap",
432 "storeNewEntry",
433 "(ILjava/lang/Object;Ljava/lang/Object;I)V",
434 (hash, key, value, bucket_index),
435 )
436 .await?;
437 let threshold: i32 = jvm.get_field(&this, "threshold", "I").await?;
438 if size >= threshold {
439 Self::rehash(jvm, &mut this).await?;
440 }
441
442 Ok(())
443 }
444
445 async fn key_iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
446 let snapshot = Self::keys_snapshot(jvm, &this).await?;
447
448 Ok(jvm
449 .new_class("java/util/HashMap$KeyIterator", "([Ljava/lang/Object;)V", (snapshot,))
450 .await?
451 .into())
452 }
453
454 async fn value_iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
455 let snapshot = Self::values_snapshot(jvm, &this).await?;
456
457 Ok(jvm
458 .new_class("java/util/HashMap$ValueIterator", "([Ljava/lang/Object;)V", (snapshot,))
459 .await?
460 .into())
461 }
462
463 async fn entry_iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
464 let snapshot = Self::entries_snapshot(jvm, &this).await?;
465
466 Ok(jvm
467 .new_class("java/util/HashMap$EntryIterator", "([Ljava/lang/Object;)V", (snapshot,))
468 .await?
469 .into())
470 }
471
472 pub(super) async fn find_entry(
473 jvm: &Jvm,
474 this: &ClassInstanceRef<Self>,
475 key: &ClassInstanceRef<Object>,
476 ) -> Result<ClassInstanceRef<HashMapEntry>> {
477 let key_hash = Self::object_hash_or_zero(jvm, key).await?;
478 let table: ClassInstanceRef<Array<HashMapEntry>> = jvm.get_field(this, "table", "[Ljava/util/HashMap$Entry;").await?;
479 let table_len = jvm.array_length(&table).await?;
480 if table_len == 0 {
481 return Ok(None.into());
482 }
483 let bucket_index = Self::bucket_index(key_hash, table_len);
484
485 let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
486 while !entry.is_null() {
487 let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
488 if entry_hash == key_hash {
489 let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
490 if Self::keys_equal(jvm, key, &entry_key).await? {
491 return Ok(entry);
492 }
493 }
494
495 entry = jvm.get_field(&entry, "next", "Ljava/util/HashMap$Entry;").await?;
496 }
497
498 Ok(None.into())
499 }
500
501 pub(super) async fn put_for_create(
502 jvm: &Jvm,
503 this: &mut ClassInstanceRef<Self>,
504 key: ClassInstanceRef<Object>,
505 value: ClassInstanceRef<Object>,
506 ) -> Result<()> {
507 let hash = Self::object_hash_or_zero(jvm, &key).await?;
508 Self::ensure_table_for_insert(jvm, this).await?;
509 let table: ClassInstanceRef<Array<HashMapEntry>> = jvm.get_field(this, "table", "[Ljava/util/HashMap$Entry;").await?;
510 let bucket_index = Self::bucket_index(hash, jvm.array_length(&table).await?);
511 jvm.invoke_virtual(
512 this,
513 "java/util/HashMap",
514 "storeNewEntry",
515 "(ILjava/lang/Object;Ljava/lang/Object;I)V",
516 (hash, key, value, bucket_index as i32),
517 )
518 .await
519 }
520
521 async fn ensure_table_for_insert(jvm: &Jvm, this: &mut ClassInstanceRef<Self>) -> Result<()> {
522 let table: ClassInstanceRef<Array<HashMapEntry>> = jvm.get_field(this, "table", "[Ljava/util/HashMap$Entry;").await?;
523 if jvm.array_length(&table).await? > 0 {
524 return Ok(());
525 }
526
527 let new_capacity = 1;
528 let new_table: ClassInstanceRef<Array<HashMapEntry>> = jvm.instantiate_array("Ljava/util/HashMap$Entry;", new_capacity).await?.into();
529 jvm.put_field(this, "table", "[Ljava/util/HashMap$Entry;", new_table).await?;
530 let load_factor: f32 = jvm.get_field(this, "loadFactor", "F").await?;
531 jvm.put_field(this, "threshold", "I", Self::threshold_for_capacity(new_capacity as i32, load_factor))
532 .await?;
533
534 Ok(())
535 }
536
537 pub(super) async fn rehash(jvm: &Jvm, this: &mut ClassInstanceRef<Self>) -> Result<()> {
538 let old_table: ClassInstanceRef<Array<HashMapEntry>> = jvm.get_field(this, "table", "[Ljava/util/HashMap$Entry;").await?;
539 let old_capacity = jvm.array_length(&old_table).await?;
540 let new_capacity = old_capacity * 2 + 1;
541
542 let mut new_table: ClassInstanceRef<Array<HashMapEntry>> = jvm.instantiate_array("Ljava/util/HashMap$Entry;", new_capacity).await?.into();
543 for bucket_index in 0..old_capacity {
544 let mut entry = Self::load_bucket(jvm, &old_table, bucket_index).await?;
545 while !entry.is_null() {
546 let next: ClassInstanceRef<HashMapEntry> = jvm.get_field(&entry, "next", "Ljava/util/HashMap$Entry;").await?;
547 let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
548 let new_index = Self::bucket_index(entry_hash, new_capacity);
549
550 let existing = Self::load_bucket(jvm, &new_table, new_index).await?;
551 jvm.put_field(&mut entry, "next", "Ljava/util/HashMap$Entry;", existing).await?;
552 jvm.store_array(&mut new_table, new_index, core::iter::once(entry)).await?;
553
554 entry = next;
555 }
556 }
557
558 jvm.put_field(this, "table", "[Ljava/util/HashMap$Entry;", new_table).await?;
559 let load_factor: f32 = jvm.get_field(this, "loadFactor", "F").await?;
560 jvm.put_field(this, "threshold", "I", Self::threshold_for_capacity(new_capacity as i32, load_factor))
561 .await?;
562
563 Ok(())
564 }
565
566 async fn load_bucket(jvm: &Jvm, table: &ClassInstanceRef<Array<HashMapEntry>>, bucket_index: usize) -> Result<ClassInstanceRef<HashMapEntry>> {
567 Ok(jvm.load_array(table, bucket_index, 1).await?.remove(0))
568 }
569
570 async fn object_equals(jvm: &Jvm, left: &ClassInstanceRef<Object>, right: &ClassInstanceRef<Object>) -> Result<bool> {
571 if left.is_null() {
572 return Ok(right.is_null());
573 }
574
575 if right.is_null() {
576 return Ok(false);
577 }
578
579 jvm.invoke_virtual(left, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (right.clone(),))
580 .await
581 }
582
583 async fn keys_equal(jvm: &Jvm, query_key: &ClassInstanceRef<Object>, stored_key: &ClassInstanceRef<Object>) -> Result<bool> {
584 if query_key.is_null() {
585 return Ok(stored_key.is_null());
586 }
587
588 if stored_key.is_null() {
589 return Ok(false);
590 }
591
592 jvm.invoke_virtual(query_key, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (stored_key.clone(),))
593 .await
594 }
595
596 async fn object_hash_or_zero(jvm: &Jvm, value: &ClassInstanceRef<Object>) -> Result<i32> {
597 if value.is_null() {
598 return Ok(0);
599 }
600
601 jvm.invoke_virtual(value, "java/lang/Object", "hashCode", "()I", ()).await
602 }
603
604 fn bucket_index(hash: i32, table_len: usize) -> usize {
605 (hash & 0x7FFFFFFF) as usize % table_len
606 }
607
608 async fn snapshot_entries(jvm: &Jvm, this: &ClassInstanceRef<Self>, kind: SnapshotKind) -> Result<ClassInstanceRef<Array<Object>>> {
609 let table: ClassInstanceRef<Array<HashMapEntry>> = jvm.get_field(this, "table", "[Ljava/util/HashMap$Entry;").await?;
610 let table_len = jvm.array_length(&table).await?;
611 let size: i32 = jvm.get_field(this, "size", "I").await?;
612 let mut elements: Vec<ClassInstanceRef<Object>> = Vec::with_capacity(size as usize);
613
614 for bucket_index in 0..table_len {
615 let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
616 while !entry.is_null() {
617 let element = match kind {
618 SnapshotKind::Keys => jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?,
619 SnapshotKind::Values => jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?,
620 SnapshotKind::Entries => ClassInstanceRef::new(entry.clone().instance),
621 };
622 elements.push(element);
623
624 entry = jvm.get_field(&entry, "next", "Ljava/util/HashMap$Entry;").await?;
625 }
626 }
627
628 let mut snapshot: ClassInstanceRef<Array<Object>> = jvm.instantiate_array("Ljava/lang/Object;", elements.len()).await?.into();
629 if !elements.is_empty() {
630 jvm.store_array(&mut snapshot, 0, elements).await?;
631 }
632
633 Ok(snapshot)
634 }
635
636 fn threshold_for_capacity(capacity: i32, load_factor: f32) -> i32 {
637 if capacity <= 0 { 0 } else { (capacity as f32 * load_factor) as i32 }
638 }
639}
640
641#[derive(Copy, Clone)]
642enum SnapshotKind {
643 Keys,
644 Values,
645 Entries,
646}