Skip to main content

rustjava_runtime/classes/java/util/
hash_map.rs

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
14// class java.util.HashMap
15pub 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}