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
9pub 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
251pub 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, "list", "Ljava/util/List;", list).await?;
301 jvm.put_field(&mut this, "cursor", "I", index).await?;
302 jvm.put_field(&mut this, "lastReturned", "I", -1).await
303 }
304
305 async fn has_next(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
306 let list: ClassInstanceRef<Object> = jvm.get_field(&this, "list", "Ljava/util/List;").await?;
307 let cursor: i32 = jvm.get_field(&this, "cursor", "I").await?;
308 Ok(cursor
309 < jvm
310 .invoke_virtual::<_, i32>(&list, &list.class_definition().name(), "size", "()I", ())
311 .await?)
312 }
313
314 async fn next(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
315 let list: ClassInstanceRef<Object> = jvm.get_field(&this, "list", "Ljava/util/List;").await?;
316 let cursor: i32 = jvm.get_field(&this, "cursor", "I").await?;
317 if cursor
318 >= jvm
319 .invoke_virtual::<_, i32>(&list, &list.class_definition().name(), "size", "()I", ())
320 .await?
321 {
322 return Err(jvm.exception("java/util/NoSuchElementException", "AbstractList iterator exhausted").await);
323 }
324 let element = jvm
325 .invoke_virtual(&list, &list.class_definition().name(), "get", "(I)Ljava/lang/Object;", (cursor,))
326 .await?;
327 jvm.put_field(&mut this, "cursor", "I", cursor + 1).await?;
328 jvm.put_field(&mut this, "lastReturned", "I", cursor).await?;
329 Ok(element)
330 }
331
332 async fn has_previous(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
333 Ok(jvm.get_field::<i32>(&this, "cursor", "I").await? > 0)
334 }
335
336 async fn previous(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
337 let cursor: i32 = jvm.get_field(&this, "cursor", "I").await?;
338 if cursor <= 0 {
339 return Err(jvm.exception("java/util/NoSuchElementException", "AbstractList iterator exhausted").await);
340 }
341 let index = cursor - 1;
342 let list: ClassInstanceRef<Object> = jvm.get_field(&this, "list", "Ljava/util/List;").await?;
343 let element = jvm
344 .invoke_virtual(&list, &list.class_definition().name(), "get", "(I)Ljava/lang/Object;", (index,))
345 .await?;
346 jvm.put_field(&mut this, "cursor", "I", index).await?;
347 jvm.put_field(&mut this, "lastReturned", "I", index).await?;
348 Ok(element)
349 }
350
351 async fn next_index(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
352 jvm.get_field(&this, "cursor", "I").await
353 }
354
355 async fn previous_index(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
356 Ok(jvm.get_field::<i32>(&this, "cursor", "I").await? - 1)
357 }
358
359 async fn remove(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
360 let last_returned: i32 = jvm.get_field(&this, "lastReturned", "I").await?;
361 if last_returned < 0 {
362 return Err(jvm.exception("java/lang/IllegalStateException", "iterator state").await);
363 }
364 let list: ClassInstanceRef<Object> = jvm.get_field(&this, "list", "Ljava/util/List;").await?;
365 let _: ClassInstanceRef<Object> = jvm
366 .invoke_virtual(
367 &list,
368 &list.class_definition().name(),
369 "remove",
370 "(I)Ljava/lang/Object;",
371 (last_returned,),
372 )
373 .await?;
374 let cursor: i32 = jvm.get_field(&this, "cursor", "I").await?;
375 if last_returned < cursor {
376 jvm.put_field(&mut this, "cursor", "I", cursor - 1).await?;
377 }
378 jvm.put_field(&mut this, "lastReturned", "I", -1).await
379 }
380
381 async fn set(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<()> {
382 let last_returned: i32 = jvm.get_field(&this, "lastReturned", "I").await?;
383 if last_returned < 0 {
384 return Err(jvm.exception("java/lang/IllegalStateException", "iterator state").await);
385 }
386 let list: ClassInstanceRef<Object> = jvm.get_field(&this, "list", "Ljava/util/List;").await?;
387 let _: ClassInstanceRef<Object> = jvm
388 .invoke_virtual(
389 &list,
390 &list.class_definition().name(),
391 "set",
392 "(ILjava/lang/Object;)Ljava/lang/Object;",
393 (last_returned, element),
394 )
395 .await?;
396 Ok(())
397 }
398
399 async fn add(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<()> {
400 let cursor: i32 = jvm.get_field(&this, "cursor", "I").await?;
401 let list: ClassInstanceRef<Object> = jvm.get_field(&this, "list", "Ljava/util/List;").await?;
402 let _: () = jvm
403 .invoke_virtual(&list, &list.class_definition().name(), "add", "(ILjava/lang/Object;)V", (cursor, element))
404 .await?;
405 jvm.put_field(&mut this, "cursor", "I", cursor + 1).await?;
406 jvm.put_field(&mut this, "lastReturned", "I", -1).await
407 }
408}