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