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
9pub 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(¤t, "size", "I").await?;
317 jvm.put_field(&mut current, "size", "I", size + delta).await?;
318 current = jvm.get_field(¤t, "parent", "Ljava/util/AbstractList$SubList;").await?;
319 }
320 Ok(())
321 }
322}