Skip to main content

rustjava_runtime/classes/java/util/
linked_list.rs

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
12// class java.util.LinkedList
13pub 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}