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 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}