Skip to main content

rustjava_runtime/classes/java/util/
abstract_list.rs

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
9// abstract class java.util.AbstractList
10pub struct AbstractList;
11
12impl AbstractList {
13    pub fn as_proto() -> RuntimeClassProto {
14        RuntimeClassProto {
15            name: "java/util/AbstractList",
16            parent_class: Some("java/util/AbstractCollection"),
17            interfaces: vec!["java/util/List"],
18            methods: vec![
19                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PROTECTED),
20                JavaMethodProto::new("add", "(Ljava/lang/Object;)Z", Self::add, MethodAccessFlags::PUBLIC),
21                JavaMethodProto::new("addAll", "(ILjava/util/Collection;)Z", Self::add_all, MethodAccessFlags::PUBLIC),
22                JavaMethodProto::new("indexOf", "(Ljava/lang/Object;)I", Self::index_of, MethodAccessFlags::PUBLIC),
23                JavaMethodProto::new("lastIndexOf", "(Ljava/lang/Object;)I", Self::last_index_of, MethodAccessFlags::PUBLIC),
24                JavaMethodProto::new("iterator", "()Ljava/util/Iterator;", Self::iterator, MethodAccessFlags::PUBLIC),
25                JavaMethodProto::new(
26                    "listIterator",
27                    "()Ljava/util/ListIterator;",
28                    Self::list_iterator,
29                    MethodAccessFlags::PUBLIC,
30                ),
31                JavaMethodProto::new(
32                    "listIterator",
33                    "(I)Ljava/util/ListIterator;",
34                    Self::list_iterator_at,
35                    MethodAccessFlags::PUBLIC,
36                ),
37                JavaMethodProto::new("subList", "(II)Ljava/util/List;", Self::sub_list, MethodAccessFlags::PUBLIC),
38                JavaMethodProto::new("equals", "(Ljava/lang/Object;)Z", Self::equals, MethodAccessFlags::PUBLIC),
39                JavaMethodProto::new("hashCode", "()I", Self::hash_code, MethodAccessFlags::PUBLIC),
40            ],
41            fields: vec![],
42            access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::ABSTRACT,
43        }
44    }
45
46    async fn add(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<bool> {
47        let size: i32 = jvm.invoke_virtual(&this, "java/util/AbstractList", "size", "()I", ()).await?;
48        let _: () = jvm
49            .invoke_virtual(&this, "java/util/AbstractList", "add", "(ILjava/lang/Object;)V", (size, element))
50            .await?;
51        Ok(true)
52    }
53
54    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
55        tracing::debug!("java.util.AbstractList::<init>({this:?})");
56
57        let _: () = jvm.invoke_special(&this, "java/util/AbstractCollection", "<init>", "()V", ()).await?;
58
59        Ok(())
60    }
61
62    async fn add_all(
63        jvm: &Jvm,
64        _: &mut RuntimeContext,
65        this: ClassInstanceRef<Self>,
66        index: i32,
67        collection: ClassInstanceRef<Object>,
68    ) -> Result<bool> {
69        tracing::debug!("java.util.AbstractList::addAll({this:?}, {index:?}, {collection:?})");
70
71        let size: i32 = jvm.invoke_virtual(&this, "java/util/AbstractList", "size", "()I", ()).await?;
72        if index < 0 || index > size {
73            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "index").await);
74        }
75        if collection.is_null() {
76            return Err(jvm.exception("java/lang/NullPointerException", "collection").await);
77        }
78
79        let elements: ClassInstanceRef<Array<Object>> = jvm
80            .invoke_virtual(&collection, &collection.class_definition().name(), "toArray", "()[Ljava/lang/Object;", ())
81            .await?;
82        let count = jvm.array_length(&elements).await?;
83        for (offset, element) in jvm
84            .load_array::<ClassInstanceRef<Object>>(&elements, 0, count)
85            .await?
86            .into_iter()
87            .enumerate()
88        {
89            let _: () = jvm
90                .invoke_virtual(
91                    &this,
92                    "java/util/AbstractList",
93                    "add",
94                    "(ILjava/lang/Object;)V",
95                    (index + offset as i32, element),
96                )
97                .await?;
98        }
99
100        Ok(count != 0)
101    }
102
103    async fn last_index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<i32> {
104        tracing::debug!("java.util.AbstractList::lastIndexOf({this:?}, {element:?})");
105
106        let size: i32 = jvm.invoke_virtual(&this, "java/util/AbstractList", "size", "()I", ()).await?;
107        for index in (0..size).rev() {
108            let current: ClassInstanceRef<Object> = jvm
109                .invoke_virtual(&this, "java/util/AbstractList", "get", "(I)Ljava/lang/Object;", (index,))
110                .await?;
111            if element.is_null() {
112                if current.is_null() {
113                    return Ok(index);
114                }
115            } else if !current.is_null()
116                && jvm
117                    .invoke_virtual::<_, bool>(&element, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (current,))
118                    .await?
119            {
120                return Ok(index);
121            }
122        }
123
124        Ok(-1)
125    }
126
127    async fn index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<i32> {
128        let size: i32 = jvm.invoke_virtual(&this, "java/util/AbstractList", "size", "()I", ()).await?;
129        for index in 0..size {
130            let current: ClassInstanceRef<Object> = jvm
131                .invoke_virtual(&this, "java/util/AbstractList", "get", "(I)Ljava/lang/Object;", (index,))
132                .await?;
133            if element.is_null() {
134                if current.is_null() {
135                    return Ok(index);
136                }
137            } else if !current.is_null()
138                && jvm
139                    .invoke_virtual::<_, bool>(&element, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (current,))
140                    .await?
141            {
142                return Ok(index);
143            }
144        }
145        Ok(-1)
146    }
147
148    async fn iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
149        let iterator = jvm.new_class("java/util/AbstractList$Itr", "(Ljava/util/List;I)V", (this, 0)).await?;
150        Ok(iterator.into())
151    }
152
153    async fn list_iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
154        let iterator = jvm.new_class("java/util/AbstractList$ListItr", "(Ljava/util/List;I)V", (this, 0)).await?;
155        Ok(iterator.into())
156    }
157
158    async fn list_iterator_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<Object>> {
159        let iterator = jvm
160            .new_class("java/util/AbstractList$ListItr", "(Ljava/util/List;I)V", (this, index))
161            .await?;
162        Ok(iterator.into())
163    }
164
165    async fn sub_list(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, from: i32, to: i32) -> Result<ClassInstanceRef<Object>> {
166        let size: i32 = jvm.invoke_virtual(&this, "java/util/AbstractList", "size", "()I", ()).await?;
167        if from < 0 || to > size {
168            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "subList range").await);
169        }
170        if from > to {
171            return Err(jvm.exception("java/lang/IllegalArgumentException", "fromIndex > toIndex").await);
172        }
173        let parent: ClassInstanceRef<crate::classes::java::util::AbstractListSubList> = None.into();
174        let sub_list = jvm
175            .new_class(
176                "java/util/AbstractList$SubList",
177                "(Ljava/util/List;Ljava/util/AbstractList$SubList;II)V",
178                (this, parent, from, to - from),
179            )
180            .await?;
181        Ok(sub_list.into())
182    }
183
184    async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<bool> {
185        if other.is_null() {
186            return Ok(false);
187        }
188        if this.identity() == other.identity() {
189            return Ok(true);
190        }
191        if !jvm.is_instance(other.as_ref(), "java/util/List") {
192            return Ok(false);
193        }
194
195        let left: ClassInstanceRef<Object> = jvm
196            .invoke_virtual(&this, "java/util/AbstractList", "listIterator", "()Ljava/util/ListIterator;", ())
197            .await?;
198        let right: ClassInstanceRef<Object> = jvm
199            .invoke_virtual(&other, &other.class_definition().name(), "listIterator", "()Ljava/util/ListIterator;", ())
200            .await?;
201        loop {
202            let left_has_next: bool = jvm.invoke_virtual(&left, &left.class_definition().name(), "hasNext", "()Z", ()).await?;
203            let right_has_next: bool = jvm.invoke_virtual(&right, &right.class_definition().name(), "hasNext", "()Z", ()).await?;
204            if !left_has_next || !right_has_next {
205                return Ok(left_has_next == right_has_next);
206            }
207
208            let left_element: ClassInstanceRef<Object> = jvm
209                .invoke_virtual(&left, &left.class_definition().name(), "next", "()Ljava/lang/Object;", ())
210                .await?;
211            let right_element: ClassInstanceRef<Object> = jvm
212                .invoke_virtual(&right, &right.class_definition().name(), "next", "()Ljava/lang/Object;", ())
213                .await?;
214            let equal = if left_element.is_null() {
215                right_element.is_null()
216            } else if right_element.is_null() {
217                false
218            } else {
219                jvm.invoke_virtual::<_, bool>(&left_element, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (right_element,))
220                    .await?
221            };
222            if !equal {
223                return Ok(false);
224            }
225        }
226    }
227
228    async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
229        let iterator: ClassInstanceRef<Object> = jvm
230            .invoke_virtual(&this, "java/util/AbstractList", "iterator", "()Ljava/util/Iterator;", ())
231            .await?;
232        let mut hash = 1i32;
233        while jvm
234            .invoke_virtual::<_, bool>(&iterator, &iterator.class_definition().name(), "hasNext", "()Z", ())
235            .await?
236        {
237            let element: ClassInstanceRef<Object> = jvm
238                .invoke_virtual(&iterator, &iterator.class_definition().name(), "next", "()Ljava/lang/Object;", ())
239                .await?;
240            let element_hash = if element.is_null() {
241                0
242            } else {
243                jvm.invoke_virtual(&element, "java/lang/Object", "hashCode", "()I", ()).await?
244            };
245            hash = hash.wrapping_mul(31).wrapping_add(element_hash);
246        }
247        Ok(hash)
248    }
249}
250
251// classes java.util.AbstractList$Itr and java.util.AbstractList$ListItr
252pub struct AbstractListItr;
253
254impl AbstractListItr {
255    pub fn as_proto() -> RuntimeClassProto {
256        RuntimeClassProto {
257            name: "java/util/AbstractList$Itr",
258            parent_class: Some("java/lang/Object"),
259            interfaces: vec!["java/util/Iterator"],
260            methods: vec![
261                JavaMethodProto::new("<init>", "(Ljava/util/List;I)V", Self::init, MethodAccessFlags::empty()),
262                JavaMethodProto::new("hasNext", "()Z", Self::has_next, MethodAccessFlags::PUBLIC),
263                JavaMethodProto::new("next", "()Ljava/lang/Object;", Self::next, MethodAccessFlags::PUBLIC),
264                JavaMethodProto::new("remove", "()V", Self::remove, MethodAccessFlags::PUBLIC),
265            ],
266            fields: vec![
267                JavaFieldProto::new("list", "Ljava/util/List;", FieldAccessFlags::PRIVATE),
268                JavaFieldProto::new("cursor", "I", FieldAccessFlags::empty()),
269                JavaFieldProto::new("lastReturned", "I", FieldAccessFlags::PRIVATE),
270            ],
271            access_flags: ClassAccessFlags::empty(),
272        }
273    }
274
275    pub fn list_proto() -> RuntimeClassProto {
276        RuntimeClassProto {
277            name: "java/util/AbstractList$ListItr",
278            parent_class: Some("java/util/AbstractList$Itr"),
279            interfaces: vec!["java/util/ListIterator"],
280            methods: vec![
281                JavaMethodProto::new("<init>", "(Ljava/util/List;I)V", Self::init, MethodAccessFlags::empty()),
282                JavaMethodProto::new("hasPrevious", "()Z", Self::has_previous, MethodAccessFlags::PUBLIC),
283                JavaMethodProto::new("previous", "()Ljava/lang/Object;", Self::previous, MethodAccessFlags::PUBLIC),
284                JavaMethodProto::new("nextIndex", "()I", Self::next_index, MethodAccessFlags::PUBLIC),
285                JavaMethodProto::new("previousIndex", "()I", Self::previous_index, MethodAccessFlags::PUBLIC),
286                JavaMethodProto::new("set", "(Ljava/lang/Object;)V", Self::set, MethodAccessFlags::PUBLIC),
287                JavaMethodProto::new("add", "(Ljava/lang/Object;)V", Self::add, MethodAccessFlags::PUBLIC),
288            ],
289            fields: vec![],
290            access_flags: ClassAccessFlags::empty(),
291        }
292    }
293
294    async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, list: ClassInstanceRef<Object>, index: i32) -> Result<()> {
295        let size: i32 = jvm.invoke_virtual(&list, &list.class_definition().name(), "size", "()I", ()).await?;
296        if index < 0 || index > size {
297            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "list iterator index").await);
298        }
299        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
300        jvm.put_field(&mut this, "java/util/AbstractList$Itr", "list", "Ljava/util/List;", list)
301            .await?;
302        jvm.put_field(&mut this, "java/util/AbstractList$Itr", "cursor", "I", index).await?;
303        jvm.put_field(&mut this, "java/util/AbstractList$Itr", "lastReturned", "I", -1).await
304    }
305
306    async fn has_next(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
307        let list: ClassInstanceRef<Object> = jvm.get_field(&this, "java/util/AbstractList$Itr", "list", "Ljava/util/List;").await?;
308        let cursor: i32 = jvm.get_field(&this, "java/util/AbstractList$Itr", "cursor", "I").await?;
309        Ok(cursor
310            < jvm
311                .invoke_virtual::<_, i32>(&list, &list.class_definition().name(), "size", "()I", ())
312                .await?)
313    }
314
315    async fn next(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
316        let list: ClassInstanceRef<Object> = jvm.get_field(&this, "java/util/AbstractList$Itr", "list", "Ljava/util/List;").await?;
317        let cursor: i32 = jvm.get_field(&this, "java/util/AbstractList$Itr", "cursor", "I").await?;
318        if cursor
319            >= jvm
320                .invoke_virtual::<_, i32>(&list, &list.class_definition().name(), "size", "()I", ())
321                .await?
322        {
323            return Err(jvm.exception("java/util/NoSuchElementException", "AbstractList iterator exhausted").await);
324        }
325        let element = jvm
326            .invoke_virtual(&list, &list.class_definition().name(), "get", "(I)Ljava/lang/Object;", (cursor,))
327            .await?;
328        jvm.put_field(&mut this, "java/util/AbstractList$Itr", "cursor", "I", cursor + 1).await?;
329        jvm.put_field(&mut this, "java/util/AbstractList$Itr", "lastReturned", "I", cursor)
330            .await?;
331        Ok(element)
332    }
333
334    async fn has_previous(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
335        Ok(jvm.get_field::<i32>(&this, "java/util/AbstractList$Itr", "cursor", "I").await? > 0)
336    }
337
338    async fn previous(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
339        let cursor: i32 = jvm.get_field(&this, "java/util/AbstractList$Itr", "cursor", "I").await?;
340        if cursor <= 0 {
341            return Err(jvm.exception("java/util/NoSuchElementException", "AbstractList iterator exhausted").await);
342        }
343        let index = cursor - 1;
344        let list: ClassInstanceRef<Object> = jvm.get_field(&this, "java/util/AbstractList$Itr", "list", "Ljava/util/List;").await?;
345        let element = jvm
346            .invoke_virtual(&list, &list.class_definition().name(), "get", "(I)Ljava/lang/Object;", (index,))
347            .await?;
348        jvm.put_field(&mut this, "java/util/AbstractList$Itr", "cursor", "I", index).await?;
349        jvm.put_field(&mut this, "java/util/AbstractList$Itr", "lastReturned", "I", index).await?;
350        Ok(element)
351    }
352
353    async fn next_index(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
354        jvm.get_field(&this, "java/util/AbstractList$Itr", "cursor", "I").await
355    }
356
357    async fn previous_index(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
358        Ok(jvm.get_field::<i32>(&this, "java/util/AbstractList$Itr", "cursor", "I").await? - 1)
359    }
360
361    async fn remove(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
362        let last_returned: i32 = jvm.get_field(&this, "java/util/AbstractList$Itr", "lastReturned", "I").await?;
363        if last_returned < 0 {
364            return Err(jvm.exception("java/lang/IllegalStateException", "iterator state").await);
365        }
366        let list: ClassInstanceRef<Object> = jvm.get_field(&this, "java/util/AbstractList$Itr", "list", "Ljava/util/List;").await?;
367        let _: ClassInstanceRef<Object> = jvm
368            .invoke_virtual(
369                &list,
370                &list.class_definition().name(),
371                "remove",
372                "(I)Ljava/lang/Object;",
373                (last_returned,),
374            )
375            .await?;
376        let cursor: i32 = jvm.get_field(&this, "java/util/AbstractList$Itr", "cursor", "I").await?;
377        if last_returned < cursor {
378            jvm.put_field(&mut this, "java/util/AbstractList$Itr", "cursor", "I", cursor - 1).await?;
379        }
380        jvm.put_field(&mut this, "java/util/AbstractList$Itr", "lastReturned", "I", -1).await
381    }
382
383    async fn set(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<()> {
384        let last_returned: i32 = jvm.get_field(&this, "java/util/AbstractList$Itr", "lastReturned", "I").await?;
385        if last_returned < 0 {
386            return Err(jvm.exception("java/lang/IllegalStateException", "iterator state").await);
387        }
388        let list: ClassInstanceRef<Object> = jvm.get_field(&this, "java/util/AbstractList$Itr", "list", "Ljava/util/List;").await?;
389        let _: ClassInstanceRef<Object> = jvm
390            .invoke_virtual(
391                &list,
392                &list.class_definition().name(),
393                "set",
394                "(ILjava/lang/Object;)Ljava/lang/Object;",
395                (last_returned, element),
396            )
397            .await?;
398        Ok(())
399    }
400
401    async fn add(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<()> {
402        let cursor: i32 = jvm.get_field(&this, "java/util/AbstractList$Itr", "cursor", "I").await?;
403        let list: ClassInstanceRef<Object> = jvm.get_field(&this, "java/util/AbstractList$Itr", "list", "Ljava/util/List;").await?;
404        let _: () = jvm
405            .invoke_virtual(&list, &list.class_definition().name(), "add", "(ILjava/lang/Object;)V", (cursor, element))
406            .await?;
407        jvm.put_field(&mut this, "java/util/AbstractList$Itr", "cursor", "I", cursor + 1).await?;
408        jvm.put_field(&mut this, "java/util/AbstractList$Itr", "lastReturned", "I", -1).await
409    }
410}