1use alloc::{format, vec};
2
3use jvm::{ClassInstanceRef, Jvm, Result};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{
8 RuntimeClassProto, RuntimeContext,
9 classes::java::{lang::Object, util::LinkedListEntry},
10};
11
12pub struct LinkedList;
14
15impl LinkedList {
16 pub fn as_proto() -> RuntimeClassProto {
17 RuntimeClassProto {
18 name: "java/util/LinkedList",
19 parent_class: Some("java/util/AbstractList"),
20 interfaces: vec!["java/util/List", "java/lang/Cloneable", "java/io/Serializable"],
21 methods: vec![
22 JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
23 JavaMethodProto::new("<init>", "(Ljava/util/Collection;)V", Self::init_collection, MethodAccessFlags::PUBLIC),
24 JavaMethodProto::new("addFirst", "(Ljava/lang/Object;)V", Self::add_first, MethodAccessFlags::PUBLIC),
25 JavaMethodProto::new("addLast", "(Ljava/lang/Object;)V", Self::add_last, MethodAccessFlags::PUBLIC),
26 JavaMethodProto::new("getFirst", "()Ljava/lang/Object;", Self::get_first, MethodAccessFlags::PUBLIC),
27 JavaMethodProto::new("getLast", "()Ljava/lang/Object;", Self::get_last, MethodAccessFlags::PUBLIC),
28 JavaMethodProto::new("removeFirst", "()Ljava/lang/Object;", Self::remove_first, MethodAccessFlags::PUBLIC),
29 JavaMethodProto::new("removeLast", "()Ljava/lang/Object;", Self::remove_last, MethodAccessFlags::PUBLIC),
30 JavaMethodProto::new("size", "()I", Self::size, MethodAccessFlags::PUBLIC),
31 JavaMethodProto::new("get", "(I)Ljava/lang/Object;", Self::get, MethodAccessFlags::PUBLIC),
32 JavaMethodProto::new("set", "(ILjava/lang/Object;)Ljava/lang/Object;", Self::set, MethodAccessFlags::PUBLIC),
33 JavaMethodProto::new("add", "(ILjava/lang/Object;)V", Self::add_at, MethodAccessFlags::PUBLIC),
34 JavaMethodProto::new("add", "(Ljava/lang/Object;)Z", Self::add, MethodAccessFlags::PUBLIC),
35 JavaMethodProto::new("remove", "(I)Ljava/lang/Object;", Self::remove_at, MethodAccessFlags::PUBLIC),
36 JavaMethodProto::new("remove", "(Ljava/lang/Object;)Z", Self::remove_object, MethodAccessFlags::PUBLIC),
37 JavaMethodProto::new("indexOf", "(Ljava/lang/Object;)I", Self::index_of, MethodAccessFlags::PUBLIC),
38 JavaMethodProto::new("lastIndexOf", "(Ljava/lang/Object;)I", Self::last_index_of, MethodAccessFlags::PUBLIC),
39 JavaMethodProto::new("clear", "()V", Self::clear, MethodAccessFlags::PUBLIC),
40 JavaMethodProto::new("iterator", "()Ljava/util/Iterator;", Self::iterator, MethodAccessFlags::PUBLIC),
41 JavaMethodProto::new(
42 "listIterator",
43 "()Ljava/util/ListIterator;",
44 Self::list_iterator,
45 MethodAccessFlags::PUBLIC,
46 ),
47 JavaMethodProto::new(
48 "listIterator",
49 "(I)Ljava/util/ListIterator;",
50 Self::list_iterator_at,
51 MethodAccessFlags::PUBLIC,
52 ),
53 ],
54 fields: vec![
55 JavaFieldProto::new("header", "Ljava/util/LinkedList$Entry;", FieldAccessFlags::PRIVATE),
56 JavaFieldProto::new("size", "I", FieldAccessFlags::PRIVATE),
57 ],
58 access_flags: ClassAccessFlags::PUBLIC,
59 }
60 }
61
62 async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
63 let _: () = jvm.invoke_special(&this, "java/util/AbstractList", "<init>", "()V", ()).await?;
64 let null_object: ClassInstanceRef<Object> = None.into();
65 let null_entry: ClassInstanceRef<LinkedListEntry> = None.into();
66 let mut header: ClassInstanceRef<LinkedListEntry> = jvm
67 .new_class(
68 "java/util/LinkedList$Entry",
69 "(Ljava/lang/Object;Ljava/util/LinkedList$Entry;Ljava/util/LinkedList$Entry;)V",
70 (null_object, null_entry.clone(), null_entry),
71 )
72 .await?
73 .into();
74 let header_next = header.clone();
75 jvm.put_field(
76 &mut header,
77 "java/util/LinkedList$Entry",
78 "next",
79 "Ljava/util/LinkedList$Entry;",
80 header_next,
81 )
82 .await?;
83 let header_previous = header.clone();
84 jvm.put_field(
85 &mut header,
86 "java/util/LinkedList$Entry",
87 "previous",
88 "Ljava/util/LinkedList$Entry;",
89 header_previous,
90 )
91 .await?;
92 jvm.put_field(&mut this, "java/util/LinkedList", "header", "Ljava/util/LinkedList$Entry;", header)
93 .await?;
94 jvm.put_field(&mut this, "java/util/LinkedList", "size", "I", 0).await
95 }
96
97 async fn init_collection(
98 jvm: &Jvm,
99 context: &mut RuntimeContext,
100 this: ClassInstanceRef<Self>,
101 collection: ClassInstanceRef<Object>,
102 ) -> Result<()> {
103 if collection.is_null() {
104 return Err(jvm.exception("java/lang/NullPointerException", "collection").await);
105 }
106 Self::init(jvm, context, this.clone()).await?;
107 let _: bool = jvm
108 .invoke_virtual(&this, "java/util/LinkedList", "addAll", "(Ljava/util/Collection;)Z", (collection,))
109 .await?;
110 Ok(())
111 }
112
113 async fn add_first(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<()> {
114 let header: ClassInstanceRef<LinkedListEntry> = jvm
115 .get_field(&this, "java/util/LinkedList", "header", "Ljava/util/LinkedList$Entry;")
116 .await?;
117 let first = jvm
118 .get_field(&header, "java/util/LinkedList$Entry", "next", "Ljava/util/LinkedList$Entry;")
119 .await?;
120 Self::add_before(jvm, &this, element, first).await
121 }
122
123 async fn add_last(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<()> {
124 let header = jvm
125 .get_field(&this, "java/util/LinkedList", "header", "Ljava/util/LinkedList$Entry;")
126 .await?;
127 Self::add_before(jvm, &this, element, header).await
128 }
129
130 async fn get_first(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
131 if jvm.get_field::<i32>(&this, "java/util/LinkedList", "size", "I").await? == 0 {
132 return Err(jvm.exception("java/util/NoSuchElementException", "LinkedList is empty").await);
133 }
134 let header: ClassInstanceRef<LinkedListEntry> = jvm
135 .get_field(&this, "java/util/LinkedList", "header", "Ljava/util/LinkedList$Entry;")
136 .await?;
137 let first: ClassInstanceRef<LinkedListEntry> = jvm
138 .get_field(&header, "java/util/LinkedList$Entry", "next", "Ljava/util/LinkedList$Entry;")
139 .await?;
140 jvm.get_field(&first, "java/util/LinkedList$Entry", "element", "Ljava/lang/Object;").await
141 }
142
143 async fn get_last(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
144 if jvm.get_field::<i32>(&this, "java/util/LinkedList", "size", "I").await? == 0 {
145 return Err(jvm.exception("java/util/NoSuchElementException", "LinkedList is empty").await);
146 }
147 let header: ClassInstanceRef<LinkedListEntry> = jvm
148 .get_field(&this, "java/util/LinkedList", "header", "Ljava/util/LinkedList$Entry;")
149 .await?;
150 let last: ClassInstanceRef<LinkedListEntry> = jvm
151 .get_field(&header, "java/util/LinkedList$Entry", "previous", "Ljava/util/LinkedList$Entry;")
152 .await?;
153 jvm.get_field(&last, "java/util/LinkedList$Entry", "element", "Ljava/lang/Object;").await
154 }
155
156 async fn remove_first(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
157 if jvm.get_field::<i32>(&this, "java/util/LinkedList", "size", "I").await? == 0 {
158 return Err(jvm.exception("java/util/NoSuchElementException", "LinkedList is empty").await);
159 }
160 let header: ClassInstanceRef<LinkedListEntry> = jvm
161 .get_field(&this, "java/util/LinkedList", "header", "Ljava/util/LinkedList$Entry;")
162 .await?;
163 let first = jvm
164 .get_field(&header, "java/util/LinkedList$Entry", "next", "Ljava/util/LinkedList$Entry;")
165 .await?;
166 Self::remove_entry(jvm, &this, first).await
167 }
168
169 async fn remove_last(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
170 if jvm.get_field::<i32>(&this, "java/util/LinkedList", "size", "I").await? == 0 {
171 return Err(jvm.exception("java/util/NoSuchElementException", "LinkedList is empty").await);
172 }
173 let header: ClassInstanceRef<LinkedListEntry> = jvm
174 .get_field(&this, "java/util/LinkedList", "header", "Ljava/util/LinkedList$Entry;")
175 .await?;
176 let last = jvm
177 .get_field(&header, "java/util/LinkedList$Entry", "previous", "Ljava/util/LinkedList$Entry;")
178 .await?;
179 Self::remove_entry(jvm, &this, last).await
180 }
181
182 async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
183 jvm.get_field(&this, "java/util/LinkedList", "size", "I").await
184 }
185
186 async fn get(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<Object>> {
187 let entry = Self::entry_at(jvm, &this, index).await?;
188 jvm.get_field(&entry, "java/util/LinkedList$Entry", "element", "Ljava/lang/Object;").await
189 }
190
191 async fn set(
192 jvm: &Jvm,
193 _: &mut RuntimeContext,
194 this: ClassInstanceRef<Self>,
195 index: i32,
196 element: ClassInstanceRef<Object>,
197 ) -> Result<ClassInstanceRef<Object>> {
198 let mut entry = Self::entry_at(jvm, &this, index).await?;
199 let old = jvm
200 .get_field(&entry, "java/util/LinkedList$Entry", "element", "Ljava/lang/Object;")
201 .await?;
202 jvm.put_field(&mut entry, "java/util/LinkedList$Entry", "element", "Ljava/lang/Object;", element)
203 .await?;
204 Ok(old)
205 }
206
207 async fn add_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32, element: ClassInstanceRef<Object>) -> Result<()> {
208 let size: i32 = jvm.get_field(&this, "java/util/LinkedList", "size", "I").await?;
209 if index < 0 || index > size {
210 return Err(jvm
211 .exception("java/lang/IndexOutOfBoundsException", &format!("Index: {index}, Size: {size}"))
212 .await);
213 }
214 let successor = if index == size {
215 jvm.get_field(&this, "java/util/LinkedList", "header", "Ljava/util/LinkedList$Entry;")
216 .await?
217 } else {
218 Self::entry_at(jvm, &this, index).await?
219 };
220 Self::add_before(jvm, &this, element, successor).await
221 }
222
223 async fn add(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<bool> {
224 let header = jvm
225 .get_field(&this, "java/util/LinkedList", "header", "Ljava/util/LinkedList$Entry;")
226 .await?;
227 Self::add_before(jvm, &this, element, header).await?;
228 Ok(true)
229 }
230
231 async fn remove_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<Object>> {
232 let entry = Self::entry_at(jvm, &this, index).await?;
233 Self::remove_entry(jvm, &this, entry).await
234 }
235
236 async fn remove_object(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<bool> {
237 let size: i32 = jvm.get_field(&this, "java/util/LinkedList", "size", "I").await?;
238 for index in 0..size {
239 let entry = Self::entry_at(jvm, &this, index).await?;
240 let current: ClassInstanceRef<Object> = jvm
241 .get_field(&entry, "java/util/LinkedList$Entry", "element", "Ljava/lang/Object;")
242 .await?;
243 let equal = if element.is_null() {
244 current.is_null()
245 } else {
246 jvm.invoke_virtual::<_, bool>(&element, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (current,))
247 .await?
248 };
249 if equal {
250 let _: ClassInstanceRef<Object> = Self::remove_entry(jvm, &this, entry).await?;
251 return Ok(true);
252 }
253 }
254 Ok(false)
255 }
256
257 async fn index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<i32> {
258 let size: i32 = jvm.get_field(&this, "java/util/LinkedList", "size", "I").await?;
259 for index in 0..size {
260 let entry = Self::entry_at(jvm, &this, index).await?;
261 let current: ClassInstanceRef<Object> = jvm
262 .get_field(&entry, "java/util/LinkedList$Entry", "element", "Ljava/lang/Object;")
263 .await?;
264 if (element.is_null() && current.is_null())
265 || (!element.is_null()
266 && jvm
267 .invoke_virtual::<_, bool>(&element, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (current,))
268 .await?)
269 {
270 return Ok(index);
271 }
272 }
273 Ok(-1)
274 }
275
276 async fn last_index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<i32> {
277 let size: i32 = jvm.get_field(&this, "java/util/LinkedList", "size", "I").await?;
278 for index in (0..size).rev() {
279 let entry = Self::entry_at(jvm, &this, index).await?;
280 let current: ClassInstanceRef<Object> = jvm
281 .get_field(&entry, "java/util/LinkedList$Entry", "element", "Ljava/lang/Object;")
282 .await?;
283 if (element.is_null() && current.is_null())
284 || (!element.is_null()
285 && jvm
286 .invoke_virtual::<_, bool>(&element, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (current,))
287 .await?)
288 {
289 return Ok(index);
290 }
291 }
292 Ok(-1)
293 }
294
295 async fn clear(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
296 while jvm.get_field::<i32>(&this, "java/util/LinkedList", "size", "I").await? > 0 {
297 let _: ClassInstanceRef<Object> = jvm
298 .invoke_virtual(&this, "java/util/LinkedList", "removeFirst", "()Ljava/lang/Object;", ())
299 .await?;
300 }
301 Ok(())
302 }
303
304 async fn iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
305 let iterator = jvm
306 .new_class("java/util/LinkedList$ListItr", "(Ljava/util/LinkedList;I)V", (this, 0))
307 .await?;
308 Ok(iterator.into())
309 }
310
311 async fn list_iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
312 let iterator = jvm
313 .new_class("java/util/LinkedList$ListItr", "(Ljava/util/LinkedList;I)V", (this, 0))
314 .await?;
315 Ok(iterator.into())
316 }
317
318 async fn list_iterator_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<Object>> {
319 let iterator = jvm
320 .new_class("java/util/LinkedList$ListItr", "(Ljava/util/LinkedList;I)V", (this, index))
321 .await?;
322 Ok(iterator.into())
323 }
324
325 async fn entry_at(jvm: &Jvm, this: &ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<LinkedListEntry>> {
326 let size: i32 = jvm.get_field(this, "java/util/LinkedList", "size", "I").await?;
327 if index < 0 || index >= size {
328 return Err(jvm
329 .exception("java/lang/IndexOutOfBoundsException", &format!("Index: {index}, Size: {size}"))
330 .await);
331 }
332 let header: ClassInstanceRef<LinkedListEntry> = jvm
333 .get_field(this, "java/util/LinkedList", "header", "Ljava/util/LinkedList$Entry;")
334 .await?;
335 if index < size / 2 {
336 let mut entry: ClassInstanceRef<LinkedListEntry> = jvm
337 .get_field(&header, "java/util/LinkedList$Entry", "next", "Ljava/util/LinkedList$Entry;")
338 .await?;
339 for _ in 0..index {
340 entry = jvm
341 .get_field(&entry, "java/util/LinkedList$Entry", "next", "Ljava/util/LinkedList$Entry;")
342 .await?;
343 }
344 Ok(entry)
345 } else {
346 let mut entry: ClassInstanceRef<LinkedListEntry> = jvm
347 .get_field(&header, "java/util/LinkedList$Entry", "previous", "Ljava/util/LinkedList$Entry;")
348 .await?;
349 for _ in (index + 1)..size {
350 entry = jvm
351 .get_field(&entry, "java/util/LinkedList$Entry", "previous", "Ljava/util/LinkedList$Entry;")
352 .await?;
353 }
354 Ok(entry)
355 }
356 }
357
358 async fn add_before(
359 jvm: &Jvm,
360 this: &ClassInstanceRef<Self>,
361 element: ClassInstanceRef<Object>,
362 mut successor: ClassInstanceRef<LinkedListEntry>,
363 ) -> Result<()> {
364 let mut predecessor: ClassInstanceRef<LinkedListEntry> = jvm
365 .get_field(&successor, "java/util/LinkedList$Entry", "previous", "Ljava/util/LinkedList$Entry;")
366 .await?;
367 let entry: ClassInstanceRef<LinkedListEntry> = jvm
368 .new_class(
369 "java/util/LinkedList$Entry",
370 "(Ljava/lang/Object;Ljava/util/LinkedList$Entry;Ljava/util/LinkedList$Entry;)V",
371 (element, successor.clone(), predecessor.clone()),
372 )
373 .await?
374 .into();
375 jvm.put_field(
376 &mut predecessor,
377 "java/util/LinkedList$Entry",
378 "next",
379 "Ljava/util/LinkedList$Entry;",
380 entry.clone(),
381 )
382 .await?;
383 jvm.put_field(
384 &mut successor,
385 "java/util/LinkedList$Entry",
386 "previous",
387 "Ljava/util/LinkedList$Entry;",
388 entry.clone(),
389 )
390 .await?;
391 let size: i32 = jvm.get_field(this, "java/util/LinkedList", "size", "I").await?;
392 let mut list = this.clone();
393 jvm.put_field(&mut list, "java/util/LinkedList", "size", "I", size + 1).await?;
394 Ok(())
395 }
396
397 async fn remove_entry(
398 jvm: &Jvm,
399 this: &ClassInstanceRef<Self>,
400 mut entry: ClassInstanceRef<LinkedListEntry>,
401 ) -> Result<ClassInstanceRef<Object>> {
402 let mut previous: ClassInstanceRef<LinkedListEntry> = jvm
403 .get_field(&entry, "java/util/LinkedList$Entry", "previous", "Ljava/util/LinkedList$Entry;")
404 .await?;
405 let mut next: ClassInstanceRef<LinkedListEntry> = jvm
406 .get_field(&entry, "java/util/LinkedList$Entry", "next", "Ljava/util/LinkedList$Entry;")
407 .await?;
408 jvm.put_field(
409 &mut previous,
410 "java/util/LinkedList$Entry",
411 "next",
412 "Ljava/util/LinkedList$Entry;",
413 next.clone(),
414 )
415 .await?;
416 jvm.put_field(
417 &mut next,
418 "java/util/LinkedList$Entry",
419 "previous",
420 "Ljava/util/LinkedList$Entry;",
421 previous,
422 )
423 .await?;
424 let element = jvm
425 .get_field(&entry, "java/util/LinkedList$Entry", "element", "Ljava/lang/Object;")
426 .await?;
427 let null_object: ClassInstanceRef<Object> = None.into();
428 let null_entry: ClassInstanceRef<LinkedListEntry> = None.into();
429 jvm.put_field(&mut entry, "java/util/LinkedList$Entry", "element", "Ljava/lang/Object;", null_object)
430 .await?;
431 jvm.put_field(
432 &mut entry,
433 "java/util/LinkedList$Entry",
434 "next",
435 "Ljava/util/LinkedList$Entry;",
436 null_entry.clone(),
437 )
438 .await?;
439 jvm.put_field(
440 &mut entry,
441 "java/util/LinkedList$Entry",
442 "previous",
443 "Ljava/util/LinkedList$Entry;",
444 null_entry,
445 )
446 .await?;
447 let size: i32 = jvm.get_field(this, "java/util/LinkedList", "size", "I").await?;
448 let mut list = this.clone();
449 jvm.put_field(&mut list, "java/util/LinkedList", "size", "I", size - 1).await?;
450 Ok(element)
451 }
452}