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