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(
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}