Skip to main content

rustjava_runtime/classes/java/util/
abstract_list_sub_list.rs

1use alloc::vec;
2
3use jvm::{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// class java.util.AbstractList$SubList
10pub struct AbstractListSubList;
11
12impl AbstractListSubList {
13    pub fn as_proto() -> RuntimeClassProto {
14        RuntimeClassProto {
15            name: "java/util/AbstractList$SubList",
16            parent_class: Some("java/util/AbstractList"),
17            interfaces: vec![],
18            methods: vec![
19                JavaMethodProto::new(
20                    "<init>",
21                    "(Ljava/util/List;Ljava/util/AbstractList$SubList;II)V",
22                    Self::init,
23                    MethodAccessFlags::empty(),
24                ),
25                JavaMethodProto::new("size", "()I", Self::size, MethodAccessFlags::PUBLIC),
26                JavaMethodProto::new("get", "(I)Ljava/lang/Object;", Self::get, MethodAccessFlags::PUBLIC),
27                JavaMethodProto::new("set", "(ILjava/lang/Object;)Ljava/lang/Object;", Self::set, MethodAccessFlags::PUBLIC),
28                JavaMethodProto::new("add", "(Ljava/lang/Object;)Z", Self::add, MethodAccessFlags::PUBLIC),
29                JavaMethodProto::new("add", "(ILjava/lang/Object;)V", Self::add_at, MethodAccessFlags::PUBLIC),
30                JavaMethodProto::new("addAll", "(Ljava/util/Collection;)Z", Self::add_all, MethodAccessFlags::PUBLIC),
31                JavaMethodProto::new("addAll", "(ILjava/util/Collection;)Z", Self::add_all_at, MethodAccessFlags::PUBLIC),
32                JavaMethodProto::new("remove", "(I)Ljava/lang/Object;", Self::remove_at, MethodAccessFlags::PUBLIC),
33                JavaMethodProto::new("remove", "(Ljava/lang/Object;)Z", Self::remove_object, MethodAccessFlags::PUBLIC),
34                JavaMethodProto::new("indexOf", "(Ljava/lang/Object;)I", Self::index_of, MethodAccessFlags::PUBLIC),
35                JavaMethodProto::new("lastIndexOf", "(Ljava/lang/Object;)I", Self::last_index_of, MethodAccessFlags::PUBLIC),
36                JavaMethodProto::new("clear", "()V", Self::clear, MethodAccessFlags::PUBLIC),
37                JavaMethodProto::new("iterator", "()Ljava/util/Iterator;", Self::iterator, MethodAccessFlags::PUBLIC),
38                JavaMethodProto::new(
39                    "listIterator",
40                    "()Ljava/util/ListIterator;",
41                    Self::list_iterator,
42                    MethodAccessFlags::PUBLIC,
43                ),
44                JavaMethodProto::new(
45                    "listIterator",
46                    "(I)Ljava/util/ListIterator;",
47                    Self::list_iterator_at,
48                    MethodAccessFlags::PUBLIC,
49                ),
50                JavaMethodProto::new("subList", "(II)Ljava/util/List;", Self::sub_list, MethodAccessFlags::PUBLIC),
51            ],
52            fields: vec![
53                JavaFieldProto::new("root", "Ljava/util/List;", FieldAccessFlags::PRIVATE),
54                JavaFieldProto::new(
55                    "parent",
56                    "Ljava/util/AbstractList$SubList;",
57                    FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL,
58                ),
59                JavaFieldProto::new("offset", "I", FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL),
60                JavaFieldProto::new("size", "I", FieldAccessFlags::PROTECTED),
61            ],
62            access_flags: ClassAccessFlags::empty(),
63        }
64    }
65
66    async fn init(
67        jvm: &Jvm,
68        _: &mut RuntimeContext,
69        mut this: ClassInstanceRef<Self>,
70        root: ClassInstanceRef<Object>,
71        parent: ClassInstanceRef<Self>,
72        offset: i32,
73        size: i32,
74    ) -> Result<()> {
75        let _: () = jvm.invoke_special(&this, "java/util/AbstractList", "<init>", "()V", ()).await?;
76        jvm.put_field(&mut this, "root", "Ljava/util/List;", root).await?;
77        jvm.put_field(&mut this, "parent", "Ljava/util/AbstractList$SubList;", parent).await?;
78        jvm.put_field(&mut this, "offset", "I", offset).await?;
79        jvm.put_field(&mut this, "size", "I", size).await
80    }
81
82    async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
83        jvm.get_field(&this, "size", "I").await
84    }
85
86    async fn get(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<Object>> {
87        let size: i32 = jvm.get_field(&this, "size", "I").await?;
88        if index < 0 || index >= size {
89            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "subList index").await);
90        }
91        let root: ClassInstanceRef<Object> = jvm.get_field(&this, "root", "Ljava/util/List;").await?;
92        let offset: i32 = jvm.get_field(&this, "offset", "I").await?;
93        jvm.invoke_virtual(&root, &root.class_definition().name(), "get", "(I)Ljava/lang/Object;", (offset + index,))
94            .await
95    }
96
97    async fn set(
98        jvm: &Jvm,
99        _: &mut RuntimeContext,
100        this: ClassInstanceRef<Self>,
101        index: i32,
102        element: ClassInstanceRef<Object>,
103    ) -> Result<ClassInstanceRef<Object>> {
104        let size: i32 = jvm.get_field(&this, "size", "I").await?;
105        if index < 0 || index >= size {
106            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "subList index").await);
107        }
108        let root: ClassInstanceRef<Object> = jvm.get_field(&this, "root", "Ljava/util/List;").await?;
109        let offset: i32 = jvm.get_field(&this, "offset", "I").await?;
110        jvm.invoke_virtual(
111            &root,
112            &root.class_definition().name(),
113            "set",
114            "(ILjava/lang/Object;)Ljava/lang/Object;",
115            (offset + index, element),
116        )
117        .await
118    }
119
120    async fn add(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<bool> {
121        let size: i32 = jvm.get_field(&this, "size", "I").await?;
122        let _: () = jvm
123            .invoke_virtual(&this, "java/util/AbstractList$SubList", "add", "(ILjava/lang/Object;)V", (size, element))
124            .await?;
125        Ok(true)
126    }
127
128    async fn add_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32, element: ClassInstanceRef<Object>) -> Result<()> {
129        let size: i32 = jvm.get_field(&this, "size", "I").await?;
130        if index < 0 || index > size {
131            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "subList index").await);
132        }
133        let root: ClassInstanceRef<Object> = jvm.get_field(&this, "root", "Ljava/util/List;").await?;
134        let offset: i32 = jvm.get_field(&this, "offset", "I").await?;
135        let _: () = jvm
136            .invoke_virtual(
137                &root,
138                &root.class_definition().name(),
139                "add",
140                "(ILjava/lang/Object;)V",
141                (offset + index, element),
142            )
143            .await?;
144        Self::update_sizes(jvm, this, 1).await
145    }
146
147    async fn add_all(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, collection: ClassInstanceRef<Object>) -> Result<bool> {
148        let size: i32 = jvm.get_field(&this, "size", "I").await?;
149        jvm.invoke_virtual(
150            &this,
151            "java/util/AbstractList$SubList",
152            "addAll",
153            "(ILjava/util/Collection;)Z",
154            (size, collection),
155        )
156        .await
157    }
158
159    async fn add_all_at(
160        jvm: &Jvm,
161        _: &mut RuntimeContext,
162        this: ClassInstanceRef<Self>,
163        index: i32,
164        collection: ClassInstanceRef<Object>,
165    ) -> Result<bool> {
166        let size: i32 = jvm.get_field(&this, "size", "I").await?;
167        if index < 0 || index > size {
168            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "subList index").await);
169        }
170        if collection.is_null() {
171            return Err(jvm.exception("java/lang/NullPointerException", "collection").await);
172        }
173        if jvm
174            .invoke_virtual::<_, i32>(&collection, &collection.class_definition().name(), "size", "()I", ())
175            .await?
176            == 0
177        {
178            return Ok(false);
179        }
180        let root: ClassInstanceRef<Object> = jvm.get_field(&this, "root", "Ljava/util/List;").await?;
181        let offset: i32 = jvm.get_field(&this, "offset", "I").await?;
182        let old_root_size: i32 = jvm.invoke_virtual(&root, &root.class_definition().name(), "size", "()I", ()).await?;
183        let modified: bool = jvm
184            .invoke_virtual(
185                &root,
186                &root.class_definition().name(),
187                "addAll",
188                "(ILjava/util/Collection;)Z",
189                (offset + index, collection),
190            )
191            .await?;
192        if modified {
193            let new_root_size: i32 = jvm.invoke_virtual(&root, &root.class_definition().name(), "size", "()I", ()).await?;
194            Self::update_sizes(jvm, this, new_root_size - old_root_size).await?;
195        }
196        Ok(modified)
197    }
198
199    async fn remove_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<Object>> {
200        let size: i32 = jvm.get_field(&this, "size", "I").await?;
201        if index < 0 || index >= size {
202            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "subList index").await);
203        }
204        let root: ClassInstanceRef<Object> = jvm.get_field(&this, "root", "Ljava/util/List;").await?;
205        let offset: i32 = jvm.get_field(&this, "offset", "I").await?;
206        let removed = jvm
207            .invoke_virtual(
208                &root,
209                &root.class_definition().name(),
210                "remove",
211                "(I)Ljava/lang/Object;",
212                (offset + index,),
213            )
214            .await?;
215        Self::update_sizes(jvm, this, -1).await?;
216        Ok(removed)
217    }
218
219    async fn remove_object(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<bool> {
220        let index: i32 = jvm
221            .invoke_virtual(&this, "java/util/AbstractList$SubList", "indexOf", "(Ljava/lang/Object;)I", (element,))
222            .await?;
223        if index < 0 {
224            return Ok(false);
225        }
226        let _: ClassInstanceRef<Object> = jvm
227            .invoke_virtual(&this, "java/util/AbstractList$SubList", "remove", "(I)Ljava/lang/Object;", (index,))
228            .await?;
229        Ok(true)
230    }
231
232    async fn index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<i32> {
233        let size: i32 = jvm.get_field(&this, "size", "I").await?;
234        for index in 0..size {
235            let current: ClassInstanceRef<Object> = jvm
236                .invoke_virtual(&this, "java/util/AbstractList$SubList", "get", "(I)Ljava/lang/Object;", (index,))
237                .await?;
238            if (element.is_null() && current.is_null())
239                || (!element.is_null()
240                    && jvm
241                        .invoke_virtual::<_, bool>(&element, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (current,))
242                        .await?)
243            {
244                return Ok(index);
245            }
246        }
247        Ok(-1)
248    }
249
250    async fn last_index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<i32> {
251        let size: i32 = jvm.get_field(&this, "size", "I").await?;
252        for index in (0..size).rev() {
253            let current: ClassInstanceRef<Object> = jvm
254                .invoke_virtual(&this, "java/util/AbstractList$SubList", "get", "(I)Ljava/lang/Object;", (index,))
255                .await?;
256            if (element.is_null() && current.is_null())
257                || (!element.is_null()
258                    && jvm
259                        .invoke_virtual::<_, bool>(&element, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (current,))
260                        .await?)
261            {
262                return Ok(index);
263            }
264        }
265        Ok(-1)
266    }
267
268    async fn clear(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
269        while jvm.get_field::<i32>(&this, "size", "I").await? > 0 {
270            let _: ClassInstanceRef<Object> = jvm
271                .invoke_virtual(&this, "java/util/AbstractList$SubList", "remove", "(I)Ljava/lang/Object;", (0,))
272                .await?;
273        }
274        Ok(())
275    }
276
277    async fn iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
278        let iterator = jvm.new_class("java/util/AbstractList$Itr", "(Ljava/util/List;I)V", (this, 0)).await?;
279        Ok(iterator.into())
280    }
281
282    async fn list_iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
283        let iterator = jvm.new_class("java/util/AbstractList$ListItr", "(Ljava/util/List;I)V", (this, 0)).await?;
284        Ok(iterator.into())
285    }
286
287    async fn list_iterator_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<Object>> {
288        let iterator = jvm
289            .new_class("java/util/AbstractList$ListItr", "(Ljava/util/List;I)V", (this, index))
290            .await?;
291        Ok(iterator.into())
292    }
293
294    async fn sub_list(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, from: i32, to: i32) -> Result<ClassInstanceRef<Object>> {
295        let size: i32 = jvm.get_field(&this, "size", "I").await?;
296        if from < 0 || to > size {
297            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "subList range").await);
298        }
299        if from > to {
300            return Err(jvm.exception("java/lang/IllegalArgumentException", "fromIndex > toIndex").await);
301        }
302        let root: ClassInstanceRef<Object> = jvm.get_field(&this, "root", "Ljava/util/List;").await?;
303        let offset: i32 = jvm.get_field(&this, "offset", "I").await?;
304        let sub_list = jvm
305            .new_class(
306                "java/util/AbstractList$SubList",
307                "(Ljava/util/List;Ljava/util/AbstractList$SubList;II)V",
308                (root, this, offset + from, to - from),
309            )
310            .await?;
311        Ok(sub_list.into())
312    }
313
314    async fn update_sizes(jvm: &Jvm, mut current: ClassInstanceRef<Self>, delta: i32) -> Result<()> {
315        while !current.is_null() {
316            let size: i32 = jvm.get_field(&current, "size", "I").await?;
317            jvm.put_field(&mut current, "size", "I", size + delta).await?;
318            current = jvm.get_field(&current, "parent", "Ljava/util/AbstractList$SubList;").await?;
319        }
320        Ok(())
321    }
322}