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, "java/util/AbstractList$SubList", "root", "Ljava/util/List;", root)
77            .await?;
78        jvm.put_field(
79            &mut this,
80            "java/util/AbstractList$SubList",
81            "parent",
82            "Ljava/util/AbstractList$SubList;",
83            parent,
84        )
85        .await?;
86        jvm.put_field(&mut this, "java/util/AbstractList$SubList", "offset", "I", offset).await?;
87        jvm.put_field(&mut this, "java/util/AbstractList$SubList", "size", "I", size).await
88    }
89
90    async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
91        jvm.get_field(&this, "java/util/AbstractList$SubList", "size", "I").await
92    }
93
94    async fn get(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<Object>> {
95        let size: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "size", "I").await?;
96        if index < 0 || index >= size {
97            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "subList index").await);
98        }
99        let root: ClassInstanceRef<Object> = jvm.get_field(&this, "java/util/AbstractList$SubList", "root", "Ljava/util/List;").await?;
100        let offset: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "offset", "I").await?;
101        jvm.invoke_virtual(&root, &root.class_definition().name(), "get", "(I)Ljava/lang/Object;", (offset + index,))
102            .await
103    }
104
105    async fn set(
106        jvm: &Jvm,
107        _: &mut RuntimeContext,
108        this: ClassInstanceRef<Self>,
109        index: i32,
110        element: ClassInstanceRef<Object>,
111    ) -> Result<ClassInstanceRef<Object>> {
112        let size: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "size", "I").await?;
113        if index < 0 || index >= size {
114            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "subList index").await);
115        }
116        let root: ClassInstanceRef<Object> = jvm.get_field(&this, "java/util/AbstractList$SubList", "root", "Ljava/util/List;").await?;
117        let offset: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "offset", "I").await?;
118        jvm.invoke_virtual(
119            &root,
120            &root.class_definition().name(),
121            "set",
122            "(ILjava/lang/Object;)Ljava/lang/Object;",
123            (offset + index, element),
124        )
125        .await
126    }
127
128    async fn add(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<bool> {
129        let size: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "size", "I").await?;
130        let _: () = jvm
131            .invoke_virtual(&this, "java/util/AbstractList$SubList", "add", "(ILjava/lang/Object;)V", (size, element))
132            .await?;
133        Ok(true)
134    }
135
136    async fn add_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32, element: ClassInstanceRef<Object>) -> Result<()> {
137        let size: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "size", "I").await?;
138        if index < 0 || index > size {
139            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "subList index").await);
140        }
141        let root: ClassInstanceRef<Object> = jvm.get_field(&this, "java/util/AbstractList$SubList", "root", "Ljava/util/List;").await?;
142        let offset: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "offset", "I").await?;
143        let _: () = jvm
144            .invoke_virtual(
145                &root,
146                &root.class_definition().name(),
147                "add",
148                "(ILjava/lang/Object;)V",
149                (offset + index, element),
150            )
151            .await?;
152        Self::update_sizes(jvm, this, 1).await
153    }
154
155    async fn add_all(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, collection: ClassInstanceRef<Object>) -> Result<bool> {
156        let size: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "size", "I").await?;
157        jvm.invoke_virtual(
158            &this,
159            "java/util/AbstractList$SubList",
160            "addAll",
161            "(ILjava/util/Collection;)Z",
162            (size, collection),
163        )
164        .await
165    }
166
167    async fn add_all_at(
168        jvm: &Jvm,
169        _: &mut RuntimeContext,
170        this: ClassInstanceRef<Self>,
171        index: i32,
172        collection: ClassInstanceRef<Object>,
173    ) -> Result<bool> {
174        let size: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "size", "I").await?;
175        if index < 0 || index > size {
176            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "subList index").await);
177        }
178        if collection.is_null() {
179            return Err(jvm.exception("java/lang/NullPointerException", "collection").await);
180        }
181        if jvm
182            .invoke_virtual::<_, i32>(&collection, &collection.class_definition().name(), "size", "()I", ())
183            .await?
184            == 0
185        {
186            return Ok(false);
187        }
188        let root: ClassInstanceRef<Object> = jvm.get_field(&this, "java/util/AbstractList$SubList", "root", "Ljava/util/List;").await?;
189        let offset: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "offset", "I").await?;
190        let old_root_size: i32 = jvm.invoke_virtual(&root, &root.class_definition().name(), "size", "()I", ()).await?;
191        let modified: bool = jvm
192            .invoke_virtual(
193                &root,
194                &root.class_definition().name(),
195                "addAll",
196                "(ILjava/util/Collection;)Z",
197                (offset + index, collection),
198            )
199            .await?;
200        if modified {
201            let new_root_size: i32 = jvm.invoke_virtual(&root, &root.class_definition().name(), "size", "()I", ()).await?;
202            Self::update_sizes(jvm, this, new_root_size - old_root_size).await?;
203        }
204        Ok(modified)
205    }
206
207    async fn remove_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<Object>> {
208        let size: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "size", "I").await?;
209        if index < 0 || index >= size {
210            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "subList index").await);
211        }
212        let root: ClassInstanceRef<Object> = jvm.get_field(&this, "java/util/AbstractList$SubList", "root", "Ljava/util/List;").await?;
213        let offset: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "offset", "I").await?;
214        let removed = jvm
215            .invoke_virtual(
216                &root,
217                &root.class_definition().name(),
218                "remove",
219                "(I)Ljava/lang/Object;",
220                (offset + index,),
221            )
222            .await?;
223        Self::update_sizes(jvm, this, -1).await?;
224        Ok(removed)
225    }
226
227    async fn remove_object(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<bool> {
228        let index: i32 = jvm
229            .invoke_virtual(&this, "java/util/AbstractList$SubList", "indexOf", "(Ljava/lang/Object;)I", (element,))
230            .await?;
231        if index < 0 {
232            return Ok(false);
233        }
234        let _: ClassInstanceRef<Object> = jvm
235            .invoke_virtual(&this, "java/util/AbstractList$SubList", "remove", "(I)Ljava/lang/Object;", (index,))
236            .await?;
237        Ok(true)
238    }
239
240    async fn index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<i32> {
241        let size: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "size", "I").await?;
242        for index in 0..size {
243            let current: ClassInstanceRef<Object> = jvm
244                .invoke_virtual(&this, "java/util/AbstractList$SubList", "get", "(I)Ljava/lang/Object;", (index,))
245                .await?;
246            if (element.is_null() && current.is_null())
247                || (!element.is_null()
248                    && jvm
249                        .invoke_virtual::<_, bool>(&element, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (current,))
250                        .await?)
251            {
252                return Ok(index);
253            }
254        }
255        Ok(-1)
256    }
257
258    async fn last_index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<i32> {
259        let size: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "size", "I").await?;
260        for index in (0..size).rev() {
261            let current: ClassInstanceRef<Object> = jvm
262                .invoke_virtual(&this, "java/util/AbstractList$SubList", "get", "(I)Ljava/lang/Object;", (index,))
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 clear(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
277        while jvm.get_field::<i32>(&this, "java/util/AbstractList$SubList", "size", "I").await? > 0 {
278            let _: ClassInstanceRef<Object> = jvm
279                .invoke_virtual(&this, "java/util/AbstractList$SubList", "remove", "(I)Ljava/lang/Object;", (0,))
280                .await?;
281        }
282        Ok(())
283    }
284
285    async fn iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
286        let iterator = jvm.new_class("java/util/AbstractList$Itr", "(Ljava/util/List;I)V", (this, 0)).await?;
287        Ok(iterator.into())
288    }
289
290    async fn list_iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
291        let iterator = jvm.new_class("java/util/AbstractList$ListItr", "(Ljava/util/List;I)V", (this, 0)).await?;
292        Ok(iterator.into())
293    }
294
295    async fn list_iterator_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<Object>> {
296        let iterator = jvm
297            .new_class("java/util/AbstractList$ListItr", "(Ljava/util/List;I)V", (this, index))
298            .await?;
299        Ok(iterator.into())
300    }
301
302    async fn sub_list(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, from: i32, to: i32) -> Result<ClassInstanceRef<Object>> {
303        let size: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "size", "I").await?;
304        if from < 0 || to > size {
305            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "subList range").await);
306        }
307        if from > to {
308            return Err(jvm.exception("java/lang/IllegalArgumentException", "fromIndex > toIndex").await);
309        }
310        let root: ClassInstanceRef<Object> = jvm.get_field(&this, "java/util/AbstractList$SubList", "root", "Ljava/util/List;").await?;
311        let offset: i32 = jvm.get_field(&this, "java/util/AbstractList$SubList", "offset", "I").await?;
312        let sub_list = jvm
313            .new_class(
314                "java/util/AbstractList$SubList",
315                "(Ljava/util/List;Ljava/util/AbstractList$SubList;II)V",
316                (root, this, offset + from, to - from),
317            )
318            .await?;
319        Ok(sub_list.into())
320    }
321
322    async fn update_sizes(jvm: &Jvm, mut current: ClassInstanceRef<Self>, delta: i32) -> Result<()> {
323        while !current.is_null() {
324            let size: i32 = jvm.get_field(&current, "java/util/AbstractList$SubList", "size", "I").await?;
325            jvm.put_field(&mut current, "java/util/AbstractList$SubList", "size", "I", size + delta)
326                .await?;
327            current = jvm
328                .get_field(&current, "java/util/AbstractList$SubList", "parent", "Ljava/util/AbstractList$SubList;")
329                .await?;
330        }
331        Ok(())
332    }
333}