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, "java/util/LinkedHashMap", "accessOrder", "Z", access_order)
127            .await
128    }
129
130    async fn init_from_map(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, map: ClassInstanceRef<Object>) -> Result<()> {
131        if map.is_null() {
132            return Err(jvm.exception("java/lang/NullPointerException", "map").await);
133        }
134        let size: i32 = jvm.invoke_virtual(&map, &map.class_definition().name(), "size", "()I", ()).await?;
135        let capacity = size.saturating_mul(2).max(DEFAULT_INITIAL_CAPACITY);
136        let _: () = jvm
137            .invoke_special(
138                &this,
139                "java/util/LinkedHashMap",
140                "<init>",
141                "(IFZ)V",
142                (capacity, DEFAULT_LOAD_FACTOR, false),
143            )
144            .await?;
145
146        let entry_set: ClassInstanceRef<Object> = jvm
147            .invoke_virtual(&map, &map.class_definition().name(), "entrySet", "()Ljava/util/Set;", ())
148            .await?;
149        let entries: ClassInstanceRef<Array<Object>> = jvm
150            .invoke_virtual(&entry_set, &entry_set.class_definition().name(), "toArray", "()[Ljava/lang/Object;", ())
151            .await?;
152        let count = jvm.array_length(&entries).await?;
153        let mut hash_map: ClassInstanceRef<HashMap> = ClassInstanceRef::new(this.instance);
154        for entry in jvm.load_array::<ClassInstanceRef<Object>>(&entries, 0, count).await? {
155            let key: ClassInstanceRef<Object> = jvm
156                .invoke_virtual(&entry, &entry.class_definition().name(), "getKey", "()Ljava/lang/Object;", ())
157                .await?;
158            let value: ClassInstanceRef<Object> = jvm
159                .invoke_virtual(&entry, &entry.class_definition().name(), "getValue", "()Ljava/lang/Object;", ())
160                .await?;
161            HashMap::put_for_create(jvm, &mut hash_map, key, value).await?;
162        }
163
164        Ok(())
165    }
166
167    async fn initialize_map(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
168        let null: ClassInstanceRef<Object> = None.into();
169        let next: ClassInstanceRef<HashMapEntry> = None.into();
170        let mut header: ClassInstanceRef<LinkedHashMapEntry> = jvm
171            .new_class(
172                "java/util/LinkedHashMap$Entry",
173                "(ILjava/lang/Object;Ljava/lang/Object;Ljava/util/HashMap$Entry;)V",
174                (-1, null.clone(), null, next),
175            )
176            .await?
177            .into();
178        let header_ref = header.clone();
179        jvm.put_field(
180            &mut header,
181            "java/util/LinkedHashMap$Entry",
182            "before",
183            "Ljava/util/LinkedHashMap$Entry;",
184            header_ref,
185        )
186        .await?;
187        let header_ref = header.clone();
188        jvm.put_field(
189            &mut header,
190            "java/util/LinkedHashMap$Entry",
191            "after",
192            "Ljava/util/LinkedHashMap$Entry;",
193            header_ref,
194        )
195        .await?;
196        jvm.put_field(&mut this, "java/util/LinkedHashMap", "header", "Ljava/util/LinkedHashMap$Entry;", header)
197            .await
198    }
199
200    async fn contains_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Object>) -> Result<bool> {
201        let header: ClassInstanceRef<LinkedHashMapEntry> = jvm
202            .get_field(&this, "java/util/LinkedHashMap", "header", "Ljava/util/LinkedHashMap$Entry;")
203            .await?;
204        let mut entry: ClassInstanceRef<LinkedHashMapEntry> = jvm
205            .get_field(&header, "java/util/LinkedHashMap$Entry", "after", "Ljava/util/LinkedHashMap$Entry;")
206            .await?;
207        while entry.identity() != header.identity() {
208            let entry_value: ClassInstanceRef<Object> = jvm
209                .get_field(&entry, "java/util/LinkedHashMap$Entry", "value", "Ljava/lang/Object;")
210                .await?;
211            let equal = if value.is_null() {
212                entry_value.is_null()
213            } else if entry_value.is_null() {
214                false
215            } else {
216                jvm.invoke_virtual(&value, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (entry_value,))
217                    .await?
218            };
219            if equal {
220                return Ok(true);
221            }
222            entry = jvm
223                .get_field(&entry, "java/util/LinkedHashMap$Entry", "after", "Ljava/util/LinkedHashMap$Entry;")
224                .await?;
225        }
226
227        Ok(false)
228    }
229
230    async fn get(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, key: ClassInstanceRef<Object>) -> Result<ClassInstanceRef<Object>> {
231        let map: ClassInstanceRef<HashMap> = ClassInstanceRef::new(this.instance.clone());
232        let entry = HashMap::find_entry(jvm, &map, &key).await?;
233        if entry.is_null() {
234            return Ok(None.into());
235        }
236        let _: () = jvm
237            .invoke_virtual(&entry, "java/util/HashMap$Entry", "onAccess", "(Ljava/util/HashMap;)V", (map,))
238            .await?;
239
240        jvm.get_field(&entry, "java/util/HashMap$Entry", "value", "Ljava/lang/Object;").await
241    }
242
243    async fn clear(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
244        let _: () = jvm.invoke_special(&this, "java/util/HashMap", "clear", "()V", ()).await?;
245        let mut header: ClassInstanceRef<LinkedHashMapEntry> = jvm
246            .get_field(&this, "java/util/LinkedHashMap", "header", "Ljava/util/LinkedHashMap$Entry;")
247            .await?;
248        let header_ref = header.clone();
249        jvm.put_field(
250            &mut header,
251            "java/util/LinkedHashMap$Entry",
252            "before",
253            "Ljava/util/LinkedHashMap$Entry;",
254            header_ref,
255        )
256        .await?;
257        let header_ref = header.clone();
258        jvm.put_field(
259            &mut header,
260            "java/util/LinkedHashMap$Entry",
261            "after",
262            "Ljava/util/LinkedHashMap$Entry;",
263            header_ref,
264        )
265        .await
266    }
267
268    async fn store_new_entry(
269        jvm: &Jvm,
270        _: &mut RuntimeContext,
271        mut this: ClassInstanceRef<Self>,
272        hash: i32,
273        key: ClassInstanceRef<Object>,
274        value: ClassInstanceRef<Object>,
275        bucket_index: i32,
276    ) -> Result<()> {
277        let mut table: ClassInstanceRef<Array<HashMapEntry>> = jvm
278            .get_field(&this, "java/util/LinkedHashMap", "table", "[Ljava/util/HashMap$Entry;")
279            .await?;
280        let existing = jvm
281            .load_array::<ClassInstanceRef<HashMapEntry>>(&table, bucket_index as usize, 1)
282            .await?
283            .remove(0);
284        let mut entry: ClassInstanceRef<LinkedHashMapEntry> = jvm
285            .new_class(
286                "java/util/LinkedHashMap$Entry",
287                "(ILjava/lang/Object;Ljava/lang/Object;Ljava/util/HashMap$Entry;)V",
288                (hash, key, value, existing),
289            )
290            .await?
291            .into();
292        let bucket_entry: ClassInstanceRef<HashMapEntry> = ClassInstanceRef::new(entry.instance.clone());
293        jvm.store_array(&mut table, bucket_index as usize, core::iter::once(bucket_entry)).await?;
294
295        let mut header: ClassInstanceRef<LinkedHashMapEntry> = jvm
296            .get_field(&this, "java/util/LinkedHashMap", "header", "Ljava/util/LinkedHashMap$Entry;")
297            .await?;
298        let mut tail: ClassInstanceRef<LinkedHashMapEntry> = jvm
299            .get_field(&header, "java/util/LinkedHashMap$Entry", "before", "Ljava/util/LinkedHashMap$Entry;")
300            .await?;
301        jvm.put_field(
302            &mut entry,
303            "java/util/LinkedHashMap$Entry",
304            "before",
305            "Ljava/util/LinkedHashMap$Entry;",
306            tail.clone(),
307        )
308        .await?;
309        jvm.put_field(
310            &mut entry,
311            "java/util/LinkedHashMap$Entry",
312            "after",
313            "Ljava/util/LinkedHashMap$Entry;",
314            header.clone(),
315        )
316        .await?;
317        jvm.put_field(
318            &mut tail,
319            "java/util/LinkedHashMap$Entry",
320            "after",
321            "Ljava/util/LinkedHashMap$Entry;",
322            entry.clone(),
323        )
324        .await?;
325        jvm.put_field(
326            &mut header,
327            "java/util/LinkedHashMap$Entry",
328            "before",
329            "Ljava/util/LinkedHashMap$Entry;",
330            entry,
331        )
332        .await?;
333
334        let size: i32 = jvm.get_field(&this, "java/util/LinkedHashMap", "size", "I").await?;
335        jvm.put_field(&mut this, "java/util/LinkedHashMap", "size", "I", size + 1).await
336    }
337
338    async fn insert_new_entry(
339        jvm: &Jvm,
340        _: &mut RuntimeContext,
341        mut this: ClassInstanceRef<Self>,
342        hash: i32,
343        key: ClassInstanceRef<Object>,
344        value: ClassInstanceRef<Object>,
345        bucket_index: i32,
346    ) -> Result<()> {
347        let size: i32 = jvm.get_field(&this, "java/util/LinkedHashMap", "size", "I").await?;
348        let mod_count: i32 = jvm.get_field(&this, "java/util/LinkedHashMap", "modCount", "I").await?;
349        jvm.put_field(&mut this, "java/util/LinkedHashMap", "modCount", "I", mod_count.wrapping_add(1))
350            .await?;
351        let _: () = jvm
352            .invoke_virtual(
353                &this,
354                "java/util/HashMap",
355                "storeNewEntry",
356                "(ILjava/lang/Object;Ljava/lang/Object;I)V",
357                (hash, key, value, bucket_index),
358            )
359            .await?;
360
361        let header: ClassInstanceRef<LinkedHashMapEntry> = jvm
362            .get_field(&this, "java/util/LinkedHashMap", "header", "Ljava/util/LinkedHashMap$Entry;")
363            .await?;
364        let eldest: ClassInstanceRef<LinkedHashMapEntry> = jvm
365            .get_field(&header, "java/util/LinkedHashMap$Entry", "after", "Ljava/util/LinkedHashMap$Entry;")
366            .await?;
367        let eldest_entry: ClassInstanceRef<Object> = ClassInstanceRef::new(eldest.instance.clone());
368        if jvm
369            .invoke_virtual::<_, bool>(
370                &this,
371                "java/util/LinkedHashMap",
372                "removeEldestEntry",
373                "(Ljava/util/Map$Entry;)Z",
374                (eldest_entry,),
375            )
376            .await?
377        {
378            let key: ClassInstanceRef<Object> = jvm
379                .get_field(&eldest, "java/util/LinkedHashMap$Entry", "key", "Ljava/lang/Object;")
380                .await?;
381            let _: ClassInstanceRef<Object> = jvm
382                .invoke_virtual(
383                    &this,
384                    "java/util/LinkedHashMap",
385                    "remove",
386                    "(Ljava/lang/Object;)Ljava/lang/Object;",
387                    (key,),
388                )
389                .await?;
390        } else {
391            let threshold: i32 = jvm.get_field(&this, "java/util/LinkedHashMap", "threshold", "I").await?;
392            if size >= threshold {
393                let mut map: ClassInstanceRef<HashMap> = ClassInstanceRef::new(this.instance.clone());
394                HashMap::rehash(jvm, &mut map).await?;
395            }
396        }
397
398        Ok(())
399    }
400
401    async fn remove_eldest_entry(_: &Jvm, _: &mut RuntimeContext, _: ClassInstanceRef<Self>, _: ClassInstanceRef<Object>) -> Result<bool> {
402        Ok(false)
403    }
404
405    async fn key_iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
406        Ok(jvm
407            .new_class("java/util/LinkedHashMap$KeyIterator", "(Ljava/util/LinkedHashMap;)V", (this,))
408            .await?
409            .into())
410    }
411
412    async fn value_iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
413        Ok(jvm
414            .new_class("java/util/LinkedHashMap$ValueIterator", "(Ljava/util/LinkedHashMap;)V", (this,))
415            .await?
416            .into())
417    }
418
419    async fn entry_iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
420        Ok(jvm
421            .new_class("java/util/LinkedHashMap$EntryIterator", "(Ljava/util/LinkedHashMap;)V", (this,))
422            .await?
423            .into())
424    }
425}