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(&mut header, "next", "Ljava/util/LinkedList$Entry;", header_next).await?;
76 let header_previous = header.clone();
77 jvm.put_field(&mut header, "previous", "Ljava/util/LinkedList$Entry;", header_previous)
78 .await?;
79 jvm.put_field(&mut this, "header", "Ljava/util/LinkedList$Entry;", header).await?;
80 jvm.put_field(&mut this, "size", "I", 0).await
81 }
82
83 async fn init_collection(
84 jvm: &Jvm,
85 context: &mut RuntimeContext,
86 this: ClassInstanceRef<Self>,
87 collection: ClassInstanceRef<Object>,
88 ) -> Result<()> {
89 if collection.is_null() {
90 return Err(jvm.exception("java/lang/NullPointerException", "collection").await);
91 }
92 Self::init(jvm, context, this.clone()).await?;
93 let _: bool = jvm
94 .invoke_virtual(&this, "java/util/LinkedList", "addAll", "(Ljava/util/Collection;)Z", (collection,))
95 .await?;
96 Ok(())
97 }
98
99 async fn add_first(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<()> {
100 let header: ClassInstanceRef<LinkedListEntry> = jvm.get_field(&this, "header", "Ljava/util/LinkedList$Entry;").await?;
101 let first = jvm.get_field(&header, "next", "Ljava/util/LinkedList$Entry;").await?;
102 Self::add_before(jvm, &this, element, first).await
103 }
104
105 async fn add_last(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<()> {
106 let header = jvm.get_field(&this, "header", "Ljava/util/LinkedList$Entry;").await?;
107 Self::add_before(jvm, &this, element, header).await
108 }
109
110 async fn get_first(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
111 if jvm.get_field::<i32>(&this, "size", "I").await? == 0 {
112 return Err(jvm.exception("java/util/NoSuchElementException", "LinkedList is empty").await);
113 }
114 let header: ClassInstanceRef<LinkedListEntry> = jvm.get_field(&this, "header", "Ljava/util/LinkedList$Entry;").await?;
115 let first: ClassInstanceRef<LinkedListEntry> = jvm.get_field(&header, "next", "Ljava/util/LinkedList$Entry;").await?;
116 jvm.get_field(&first, "element", "Ljava/lang/Object;").await
117 }
118
119 async fn get_last(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
120 if jvm.get_field::<i32>(&this, "size", "I").await? == 0 {
121 return Err(jvm.exception("java/util/NoSuchElementException", "LinkedList is empty").await);
122 }
123 let header: ClassInstanceRef<LinkedListEntry> = jvm.get_field(&this, "header", "Ljava/util/LinkedList$Entry;").await?;
124 let last: ClassInstanceRef<LinkedListEntry> = jvm.get_field(&header, "previous", "Ljava/util/LinkedList$Entry;").await?;
125 jvm.get_field(&last, "element", "Ljava/lang/Object;").await
126 }
127
128 async fn remove_first(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
129 if jvm.get_field::<i32>(&this, "size", "I").await? == 0 {
130 return Err(jvm.exception("java/util/NoSuchElementException", "LinkedList is empty").await);
131 }
132 let header: ClassInstanceRef<LinkedListEntry> = jvm.get_field(&this, "header", "Ljava/util/LinkedList$Entry;").await?;
133 let first = jvm.get_field(&header, "next", "Ljava/util/LinkedList$Entry;").await?;
134 Self::remove_entry(jvm, &this, first).await
135 }
136
137 async fn remove_last(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
138 if jvm.get_field::<i32>(&this, "size", "I").await? == 0 {
139 return Err(jvm.exception("java/util/NoSuchElementException", "LinkedList is empty").await);
140 }
141 let header: ClassInstanceRef<LinkedListEntry> = jvm.get_field(&this, "header", "Ljava/util/LinkedList$Entry;").await?;
142 let last = jvm.get_field(&header, "previous", "Ljava/util/LinkedList$Entry;").await?;
143 Self::remove_entry(jvm, &this, last).await
144 }
145
146 async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
147 jvm.get_field(&this, "size", "I").await
148 }
149
150 async fn get(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<Object>> {
151 let entry = Self::entry_at(jvm, &this, index).await?;
152 jvm.get_field(&entry, "element", "Ljava/lang/Object;").await
153 }
154
155 async fn set(
156 jvm: &Jvm,
157 _: &mut RuntimeContext,
158 this: ClassInstanceRef<Self>,
159 index: i32,
160 element: ClassInstanceRef<Object>,
161 ) -> Result<ClassInstanceRef<Object>> {
162 let mut entry = Self::entry_at(jvm, &this, index).await?;
163 let old = jvm.get_field(&entry, "element", "Ljava/lang/Object;").await?;
164 jvm.put_field(&mut entry, "element", "Ljava/lang/Object;", element).await?;
165 Ok(old)
166 }
167
168 async fn add_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32, element: ClassInstanceRef<Object>) -> Result<()> {
169 let size: i32 = jvm.get_field(&this, "size", "I").await?;
170 if index < 0 || index > size {
171 return Err(jvm
172 .exception("java/lang/IndexOutOfBoundsException", &format!("Index: {index}, Size: {size}"))
173 .await);
174 }
175 let successor = if index == size {
176 jvm.get_field(&this, "header", "Ljava/util/LinkedList$Entry;").await?
177 } else {
178 Self::entry_at(jvm, &this, index).await?
179 };
180 Self::add_before(jvm, &this, element, successor).await
181 }
182
183 async fn add(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<bool> {
184 let header = jvm.get_field(&this, "header", "Ljava/util/LinkedList$Entry;").await?;
185 Self::add_before(jvm, &this, element, header).await?;
186 Ok(true)
187 }
188
189 async fn remove_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<Object>> {
190 let entry = Self::entry_at(jvm, &this, index).await?;
191 Self::remove_entry(jvm, &this, entry).await
192 }
193
194 async fn remove_object(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<bool> {
195 let size: i32 = jvm.get_field(&this, "size", "I").await?;
196 for index in 0..size {
197 let entry = Self::entry_at(jvm, &this, index).await?;
198 let current: ClassInstanceRef<Object> = jvm.get_field(&entry, "element", "Ljava/lang/Object;").await?;
199 let equal = if element.is_null() {
200 current.is_null()
201 } else {
202 jvm.invoke_virtual::<_, bool>(&element, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (current,))
203 .await?
204 };
205 if equal {
206 let _: ClassInstanceRef<Object> = Self::remove_entry(jvm, &this, entry).await?;
207 return Ok(true);
208 }
209 }
210 Ok(false)
211 }
212
213 async fn index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<i32> {
214 let size: i32 = jvm.get_field(&this, "size", "I").await?;
215 for index in 0..size {
216 let entry = Self::entry_at(jvm, &this, index).await?;
217 let current: ClassInstanceRef<Object> = jvm.get_field(&entry, "element", "Ljava/lang/Object;").await?;
218 if (element.is_null() && current.is_null())
219 || (!element.is_null()
220 && jvm
221 .invoke_virtual::<_, bool>(&element, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (current,))
222 .await?)
223 {
224 return Ok(index);
225 }
226 }
227 Ok(-1)
228 }
229
230 async fn last_index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<i32> {
231 let size: i32 = jvm.get_field(&this, "size", "I").await?;
232 for index in (0..size).rev() {
233 let entry = Self::entry_at(jvm, &this, index).await?;
234 let current: ClassInstanceRef<Object> = jvm.get_field(&entry, "element", "Ljava/lang/Object;").await?;
235 if (element.is_null() && current.is_null())
236 || (!element.is_null()
237 && jvm
238 .invoke_virtual::<_, bool>(&element, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (current,))
239 .await?)
240 {
241 return Ok(index);
242 }
243 }
244 Ok(-1)
245 }
246
247 async fn clear(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
248 while jvm.get_field::<i32>(&this, "size", "I").await? > 0 {
249 let _: ClassInstanceRef<Object> = jvm
250 .invoke_virtual(&this, "java/util/LinkedList", "removeFirst", "()Ljava/lang/Object;", ())
251 .await?;
252 }
253 Ok(())
254 }
255
256 async fn iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
257 let iterator = jvm
258 .new_class("java/util/LinkedList$ListItr", "(Ljava/util/LinkedList;I)V", (this, 0))
259 .await?;
260 Ok(iterator.into())
261 }
262
263 async fn list_iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
264 let iterator = jvm
265 .new_class("java/util/LinkedList$ListItr", "(Ljava/util/LinkedList;I)V", (this, 0))
266 .await?;
267 Ok(iterator.into())
268 }
269
270 async fn list_iterator_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<Object>> {
271 let iterator = jvm
272 .new_class("java/util/LinkedList$ListItr", "(Ljava/util/LinkedList;I)V", (this, index))
273 .await?;
274 Ok(iterator.into())
275 }
276
277 async fn entry_at(jvm: &Jvm, this: &ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<LinkedListEntry>> {
278 let size: i32 = jvm.get_field(this, "size", "I").await?;
279 if index < 0 || index >= size {
280 return Err(jvm
281 .exception("java/lang/IndexOutOfBoundsException", &format!("Index: {index}, Size: {size}"))
282 .await);
283 }
284 let header: ClassInstanceRef<LinkedListEntry> = jvm.get_field(this, "header", "Ljava/util/LinkedList$Entry;").await?;
285 if index < size / 2 {
286 let mut entry: ClassInstanceRef<LinkedListEntry> = jvm.get_field(&header, "next", "Ljava/util/LinkedList$Entry;").await?;
287 for _ in 0..index {
288 entry = jvm.get_field(&entry, "next", "Ljava/util/LinkedList$Entry;").await?;
289 }
290 Ok(entry)
291 } else {
292 let mut entry: ClassInstanceRef<LinkedListEntry> = jvm.get_field(&header, "previous", "Ljava/util/LinkedList$Entry;").await?;
293 for _ in (index + 1)..size {
294 entry = jvm.get_field(&entry, "previous", "Ljava/util/LinkedList$Entry;").await?;
295 }
296 Ok(entry)
297 }
298 }
299
300 async fn add_before(
301 jvm: &Jvm,
302 this: &ClassInstanceRef<Self>,
303 element: ClassInstanceRef<Object>,
304 mut successor: ClassInstanceRef<LinkedListEntry>,
305 ) -> Result<()> {
306 let mut predecessor: ClassInstanceRef<LinkedListEntry> = jvm.get_field(&successor, "previous", "Ljava/util/LinkedList$Entry;").await?;
307 let entry: ClassInstanceRef<LinkedListEntry> = jvm
308 .new_class(
309 "java/util/LinkedList$Entry",
310 "(Ljava/lang/Object;Ljava/util/LinkedList$Entry;Ljava/util/LinkedList$Entry;)V",
311 (element, successor.clone(), predecessor.clone()),
312 )
313 .await?
314 .into();
315 jvm.put_field(&mut predecessor, "next", "Ljava/util/LinkedList$Entry;", entry.clone())
316 .await?;
317 jvm.put_field(&mut successor, "previous", "Ljava/util/LinkedList$Entry;", entry.clone())
318 .await?;
319 let size: i32 = jvm.get_field(this, "size", "I").await?;
320 let mut list = this.clone();
321 jvm.put_field(&mut list, "size", "I", size + 1).await?;
322 Ok(())
323 }
324
325 async fn remove_entry(
326 jvm: &Jvm,
327 this: &ClassInstanceRef<Self>,
328 mut entry: ClassInstanceRef<LinkedListEntry>,
329 ) -> Result<ClassInstanceRef<Object>> {
330 let mut previous: ClassInstanceRef<LinkedListEntry> = jvm.get_field(&entry, "previous", "Ljava/util/LinkedList$Entry;").await?;
331 let mut next: ClassInstanceRef<LinkedListEntry> = jvm.get_field(&entry, "next", "Ljava/util/LinkedList$Entry;").await?;
332 jvm.put_field(&mut previous, "next", "Ljava/util/LinkedList$Entry;", next.clone()).await?;
333 jvm.put_field(&mut next, "previous", "Ljava/util/LinkedList$Entry;", previous).await?;
334 let element = jvm.get_field(&entry, "element", "Ljava/lang/Object;").await?;
335 let null_object: ClassInstanceRef<Object> = None.into();
336 let null_entry: ClassInstanceRef<LinkedListEntry> = None.into();
337 jvm.put_field(&mut entry, "element", "Ljava/lang/Object;", null_object).await?;
338 jvm.put_field(&mut entry, "next", "Ljava/util/LinkedList$Entry;", null_entry.clone())
339 .await?;
340 jvm.put_field(&mut entry, "previous", "Ljava/util/LinkedList$Entry;", null_entry).await?;
341 let size: i32 = jvm.get_field(this, "size", "I").await?;
342 let mut list = this.clone();
343 jvm.put_field(&mut list, "size", "I", size - 1).await?;
344 Ok(element)
345 }
346}