Skip to main content

rustjava_runtime/classes/java/util/
linked_hash_map.rs

1use alloc::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::{HashMap, HashMapEntry, LinkedHashMapEntry};
10
11const DEFAULT_INITIAL_CAPACITY: i32 = 16;
12const DEFAULT_LOAD_FACTOR: f32 = 0.75;
13
14// public class java.util.LinkedHashMap
15pub struct LinkedHashMap;
16
17impl LinkedHashMap {
18    pub fn as_proto() -> RuntimeClassProto {
19        RuntimeClassProto {
20            name: "java/util/LinkedHashMap",
21            parent_class: Some("java/util/HashMap"),
22            interfaces: vec!["java/util/Map"],
23            methods: vec![
24                JavaMethodProto::new("<init>", "()V", Self::init_default, 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(
28                    "<init>",
29                    "(IFZ)V",
30                    Self::init_with_capacity_load_factor_and_order,
31                    MethodAccessFlags::PUBLIC,
32                ),
33                JavaMethodProto::new("<init>", "(Ljava/util/Map;)V", Self::init_from_map, MethodAccessFlags::PUBLIC),
34                JavaMethodProto::new("containsValue", "(Ljava/lang/Object;)Z", Self::contains_value, MethodAccessFlags::PUBLIC),
35                JavaMethodProto::new("get", "(Ljava/lang/Object;)Ljava/lang/Object;", Self::get, MethodAccessFlags::PUBLIC),
36                JavaMethodProto::new("clear", "()V", Self::clear, MethodAccessFlags::PUBLIC),
37                JavaMethodProto::new(
38                    "removeEldestEntry",
39                    "(Ljava/util/Map$Entry;)Z",
40                    Self::remove_eldest_entry,
41                    MethodAccessFlags::PROTECTED,
42                ),
43                JavaMethodProto::new("initializeMap", "()V", Self::initialize_map, MethodAccessFlags::empty()),
44                JavaMethodProto::new(
45                    "storeNewEntry",
46                    "(ILjava/lang/Object;Ljava/lang/Object;I)V",
47                    Self::store_new_entry,
48                    MethodAccessFlags::empty(),
49                ),
50                JavaMethodProto::new(
51                    "insertNewEntry",
52                    "(ILjava/lang/Object;Ljava/lang/Object;I)V",
53                    Self::insert_new_entry,
54                    MethodAccessFlags::empty(),
55                ),
56                JavaMethodProto::new("keyIterator", "()Ljava/util/Iterator;", Self::key_iterator, MethodAccessFlags::empty()),
57                JavaMethodProto::new(
58                    "valueIterator",
59                    "()Ljava/util/Iterator;",
60                    Self::value_iterator,
61                    MethodAccessFlags::empty(),
62                ),
63                JavaMethodProto::new(
64                    "entryIterator",
65                    "()Ljava/util/Iterator;",
66                    Self::entry_iterator,
67                    MethodAccessFlags::empty(),
68                ),
69            ],
70            fields: vec![
71                JavaFieldProto::new(
72                    "header",
73                    "Ljava/util/LinkedHashMap$Entry;",
74                    FieldAccessFlags::PRIVATE | FieldAccessFlags::TRANSIENT,
75                ),
76                JavaFieldProto::new("accessOrder", "Z", FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL),
77            ],
78            access_flags: ClassAccessFlags::PUBLIC,
79        }
80    }
81
82    async fn init_default(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
83        jvm.invoke_special(
84            &this,
85            "java/util/LinkedHashMap",
86            "<init>",
87            "(IFZ)V",
88            (DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, false),
89        )
90        .await
91    }
92
93    async fn init_with_capacity(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, capacity: i32) -> Result<()> {
94        jvm.invoke_special(
95            &this,
96            "java/util/LinkedHashMap",
97            "<init>",
98            "(IFZ)V",
99            (capacity, DEFAULT_LOAD_FACTOR, false),
100        )
101        .await
102    }
103
104    async fn init_with_capacity_and_load_factor(
105        jvm: &Jvm,
106        _: &mut RuntimeContext,
107        this: ClassInstanceRef<Self>,
108        capacity: i32,
109        load_factor: f32,
110    ) -> Result<()> {
111        jvm.invoke_special(&this, "java/util/LinkedHashMap", "<init>", "(IFZ)V", (capacity, load_factor, false))
112            .await
113    }
114
115    async fn init_with_capacity_load_factor_and_order(
116        jvm: &Jvm,
117        _: &mut RuntimeContext,
118        mut this: ClassInstanceRef<Self>,
119        capacity: i32,
120        load_factor: f32,
121        access_order: bool,
122    ) -> Result<()> {
123        let _: () = jvm
124            .invoke_special(&this, "java/util/HashMap", "<init>", "(IF)V", (capacity, load_factor))
125            .await?;
126        jvm.put_field(&mut this, "accessOrder", "Z", access_order).await
127    }
128
129    async fn init_from_map(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, map: ClassInstanceRef<Object>) -> Result<()> {
130        if map.is_null() {
131            return Err(jvm.exception("java/lang/NullPointerException", "map").await);
132        }
133        let size: i32 = jvm.invoke_virtual(&map, &map.class_definition().name(), "size", "()I", ()).await?;
134        let capacity = size.saturating_mul(2).max(DEFAULT_INITIAL_CAPACITY);
135        let _: () = jvm
136            .invoke_special(
137                &this,
138                "java/util/LinkedHashMap",
139                "<init>",
140                "(IFZ)V",
141                (capacity, DEFAULT_LOAD_FACTOR, false),
142            )
143            .await?;
144
145        let entry_set: ClassInstanceRef<Object> = jvm
146            .invoke_virtual(&map, &map.class_definition().name(), "entrySet", "()Ljava/util/Set;", ())
147            .await?;
148        let entries: ClassInstanceRef<Array<Object>> = jvm
149            .invoke_virtual(&entry_set, &entry_set.class_definition().name(), "toArray", "()[Ljava/lang/Object;", ())
150            .await?;
151        let count = jvm.array_length(&entries).await?;
152        let mut hash_map: ClassInstanceRef<HashMap> = ClassInstanceRef::new(this.instance);
153        for entry in jvm.load_array::<ClassInstanceRef<Object>>(&entries, 0, count).await? {
154            let key: ClassInstanceRef<Object> = jvm
155                .invoke_virtual(&entry, &entry.class_definition().name(), "getKey", "()Ljava/lang/Object;", ())
156                .await?;
157            let value: ClassInstanceRef<Object> = jvm
158                .invoke_virtual(&entry, &entry.class_definition().name(), "getValue", "()Ljava/lang/Object;", ())
159                .await?;
160            HashMap::put_for_create(jvm, &mut hash_map, key, value).await?;
161        }
162
163        Ok(())
164    }
165
166    async fn initialize_map(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
167        let null: ClassInstanceRef<Object> = None.into();
168        let next: ClassInstanceRef<HashMapEntry> = None.into();
169        let mut header: ClassInstanceRef<LinkedHashMapEntry> = jvm
170            .new_class(
171                "java/util/LinkedHashMap$Entry",
172                "(ILjava/lang/Object;Ljava/lang/Object;Ljava/util/HashMap$Entry;)V",
173                (-1, null.clone(), null, next),
174            )
175            .await?
176            .into();
177        let header_ref = header.clone();
178        jvm.put_field(&mut header, "before", "Ljava/util/LinkedHashMap$Entry;", header_ref)
179            .await?;
180        let header_ref = header.clone();
181        jvm.put_field(&mut header, "after", "Ljava/util/LinkedHashMap$Entry;", header_ref).await?;
182        jvm.put_field(&mut this, "header", "Ljava/util/LinkedHashMap$Entry;", header).await
183    }
184
185    async fn contains_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Object>) -> Result<bool> {
186        let header: ClassInstanceRef<LinkedHashMapEntry> = jvm.get_field(&this, "header", "Ljava/util/LinkedHashMap$Entry;").await?;
187        let mut entry: ClassInstanceRef<LinkedHashMapEntry> = jvm.get_field(&header, "after", "Ljava/util/LinkedHashMap$Entry;").await?;
188        while entry.identity() != header.identity() {
189            let entry_value: ClassInstanceRef<Object> = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?;
190            let equal = if value.is_null() {
191                entry_value.is_null()
192            } else if entry_value.is_null() {
193                false
194            } else {
195                jvm.invoke_virtual(&value, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (entry_value,))
196                    .await?
197            };
198            if equal {
199                return Ok(true);
200            }
201            entry = jvm.get_field(&entry, "after", "Ljava/util/LinkedHashMap$Entry;").await?;
202        }
203
204        Ok(false)
205    }
206
207    async fn get(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, key: ClassInstanceRef<Object>) -> Result<ClassInstanceRef<Object>> {
208        let map: ClassInstanceRef<HashMap> = ClassInstanceRef::new(this.instance.clone());
209        let entry = HashMap::find_entry(jvm, &map, &key).await?;
210        if entry.is_null() {
211            return Ok(None.into());
212        }
213        let _: () = jvm
214            .invoke_virtual(&entry, "java/util/HashMap$Entry", "onAccess", "(Ljava/util/HashMap;)V", (map,))
215            .await?;
216
217        jvm.get_field(&entry, "value", "Ljava/lang/Object;").await
218    }
219
220    async fn clear(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
221        let _: () = jvm.invoke_special(&this, "java/util/HashMap", "clear", "()V", ()).await?;
222        let mut header: ClassInstanceRef<LinkedHashMapEntry> = jvm.get_field(&this, "header", "Ljava/util/LinkedHashMap$Entry;").await?;
223        let header_ref = header.clone();
224        jvm.put_field(&mut header, "before", "Ljava/util/LinkedHashMap$Entry;", header_ref)
225            .await?;
226        let header_ref = header.clone();
227        jvm.put_field(&mut header, "after", "Ljava/util/LinkedHashMap$Entry;", header_ref).await
228    }
229
230    async fn store_new_entry(
231        jvm: &Jvm,
232        _: &mut RuntimeContext,
233        mut this: ClassInstanceRef<Self>,
234        hash: i32,
235        key: ClassInstanceRef<Object>,
236        value: ClassInstanceRef<Object>,
237        bucket_index: i32,
238    ) -> Result<()> {
239        let mut table: ClassInstanceRef<Array<HashMapEntry>> = jvm.get_field(&this, "table", "[Ljava/util/HashMap$Entry;").await?;
240        let existing = jvm
241            .load_array::<ClassInstanceRef<HashMapEntry>>(&table, bucket_index as usize, 1)
242            .await?
243            .remove(0);
244        let mut entry: ClassInstanceRef<LinkedHashMapEntry> = jvm
245            .new_class(
246                "java/util/LinkedHashMap$Entry",
247                "(ILjava/lang/Object;Ljava/lang/Object;Ljava/util/HashMap$Entry;)V",
248                (hash, key, value, existing),
249            )
250            .await?
251            .into();
252        let bucket_entry: ClassInstanceRef<HashMapEntry> = ClassInstanceRef::new(entry.instance.clone());
253        jvm.store_array(&mut table, bucket_index as usize, core::iter::once(bucket_entry)).await?;
254
255        let mut header: ClassInstanceRef<LinkedHashMapEntry> = jvm.get_field(&this, "header", "Ljava/util/LinkedHashMap$Entry;").await?;
256        let mut tail: ClassInstanceRef<LinkedHashMapEntry> = jvm.get_field(&header, "before", "Ljava/util/LinkedHashMap$Entry;").await?;
257        jvm.put_field(&mut entry, "before", "Ljava/util/LinkedHashMap$Entry;", tail.clone())
258            .await?;
259        jvm.put_field(&mut entry, "after", "Ljava/util/LinkedHashMap$Entry;", header.clone())
260            .await?;
261        jvm.put_field(&mut tail, "after", "Ljava/util/LinkedHashMap$Entry;", entry.clone())
262            .await?;
263        jvm.put_field(&mut header, "before", "Ljava/util/LinkedHashMap$Entry;", entry).await?;
264
265        let size: i32 = jvm.get_field(&this, "size", "I").await?;
266        jvm.put_field(&mut this, "size", "I", size + 1).await
267    }
268
269    async fn insert_new_entry(
270        jvm: &Jvm,
271        _: &mut RuntimeContext,
272        mut this: ClassInstanceRef<Self>,
273        hash: i32,
274        key: ClassInstanceRef<Object>,
275        value: ClassInstanceRef<Object>,
276        bucket_index: i32,
277    ) -> Result<()> {
278        let size: i32 = jvm.get_field(&this, "size", "I").await?;
279        let mod_count: i32 = jvm.get_field(&this, "modCount", "I").await?;
280        jvm.put_field(&mut this, "modCount", "I", mod_count.wrapping_add(1)).await?;
281        let _: () = jvm
282            .invoke_virtual(
283                &this,
284                "java/util/HashMap",
285                "storeNewEntry",
286                "(ILjava/lang/Object;Ljava/lang/Object;I)V",
287                (hash, key, value, bucket_index),
288            )
289            .await?;
290
291        let header: ClassInstanceRef<LinkedHashMapEntry> = jvm.get_field(&this, "header", "Ljava/util/LinkedHashMap$Entry;").await?;
292        let eldest: ClassInstanceRef<LinkedHashMapEntry> = jvm.get_field(&header, "after", "Ljava/util/LinkedHashMap$Entry;").await?;
293        let eldest_entry: ClassInstanceRef<Object> = ClassInstanceRef::new(eldest.instance.clone());
294        if jvm
295            .invoke_virtual::<_, bool>(
296                &this,
297                "java/util/LinkedHashMap",
298                "removeEldestEntry",
299                "(Ljava/util/Map$Entry;)Z",
300                (eldest_entry,),
301            )
302            .await?
303        {
304            let key: ClassInstanceRef<Object> = jvm.get_field(&eldest, "key", "Ljava/lang/Object;").await?;
305            let _: ClassInstanceRef<Object> = jvm
306                .invoke_virtual(
307                    &this,
308                    "java/util/LinkedHashMap",
309                    "remove",
310                    "(Ljava/lang/Object;)Ljava/lang/Object;",
311                    (key,),
312                )
313                .await?;
314        } else {
315            let threshold: i32 = jvm.get_field(&this, "threshold", "I").await?;
316            if size >= threshold {
317                let mut map: ClassInstanceRef<HashMap> = ClassInstanceRef::new(this.instance.clone());
318                HashMap::rehash(jvm, &mut map).await?;
319            }
320        }
321
322        Ok(())
323    }
324
325    async fn remove_eldest_entry(_: &Jvm, _: &mut RuntimeContext, _: ClassInstanceRef<Self>, _: ClassInstanceRef<Object>) -> Result<bool> {
326        Ok(false)
327    }
328
329    async fn key_iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
330        Ok(jvm
331            .new_class("java/util/LinkedHashMap$KeyIterator", "(Ljava/util/LinkedHashMap;)V", (this,))
332            .await?
333            .into())
334    }
335
336    async fn value_iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
337        Ok(jvm
338            .new_class("java/util/LinkedHashMap$ValueIterator", "(Ljava/util/LinkedHashMap;)V", (this,))
339            .await?
340            .into())
341    }
342
343    async fn entry_iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
344        Ok(jvm
345            .new_class("java/util/LinkedHashMap$EntryIterator", "(Ljava/util/LinkedHashMap;)V", (this,))
346            .await?
347            .into())
348    }
349}