1use alloc::{format, vec, vec::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 ArrayList;
11
12impl ArrayList {
13 pub fn as_proto() -> RuntimeClassProto {
14 RuntimeClassProto {
15 name: "java/util/ArrayList",
16 parent_class: Some("java/util/AbstractList"),
17 interfaces: vec!["java/lang/Cloneable", "java/io/Serializable"],
18 methods: vec![
19 JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
20 JavaMethodProto::new("<init>", "(I)V", Self::init_with_capacity, MethodAccessFlags::PUBLIC),
21 JavaMethodProto::new(
22 "<init>",
23 "(Ljava/util/Collection;)V",
24 Self::init_from_collection,
25 MethodAccessFlags::PUBLIC,
26 ),
27 JavaMethodProto::new("add", "(Ljava/lang/Object;)Z", Self::add, MethodAccessFlags::PUBLIC),
28 JavaMethodProto::new("add", "(ILjava/lang/Object;)V", Self::add_at, MethodAccessFlags::PUBLIC),
29 JavaMethodProto::new("get", "(I)Ljava/lang/Object;", Self::get, MethodAccessFlags::PUBLIC),
30 JavaMethodProto::new("set", "(ILjava/lang/Object;)Ljava/lang/Object;", Self::set, MethodAccessFlags::PUBLIC),
31 JavaMethodProto::new("remove", "(I)Ljava/lang/Object;", Self::remove, MethodAccessFlags::PUBLIC),
32 JavaMethodProto::new("remove", "(Ljava/lang/Object;)Z", Self::remove_object, MethodAccessFlags::PUBLIC),
33 JavaMethodProto::new("size", "()I", Self::size, MethodAccessFlags::PUBLIC),
34 JavaMethodProto::new("isEmpty", "()Z", Self::is_empty, MethodAccessFlags::PUBLIC),
35 JavaMethodProto::new("contains", "(Ljava/lang/Object;)Z", Self::contains, MethodAccessFlags::PUBLIC),
36 JavaMethodProto::new("indexOf", "(Ljava/lang/Object;)I", Self::index_of, MethodAccessFlags::PUBLIC),
37 JavaMethodProto::new("clear", "()V", Self::clear, MethodAccessFlags::PUBLIC),
38 JavaMethodProto::new("toArray", "()[Ljava/lang/Object;", Self::to_array, MethodAccessFlags::PUBLIC),
39 JavaMethodProto::new("iterator", "()Ljava/util/Iterator;", Self::iterator, MethodAccessFlags::PUBLIC),
40 JavaMethodProto::new(
41 "listIterator",
42 "()Ljava/util/ListIterator;",
43 Self::list_iterator,
44 MethodAccessFlags::PUBLIC,
45 ),
46 JavaMethodProto::new(
47 "listIterator",
48 "(I)Ljava/util/ListIterator;",
49 Self::list_iterator_at,
50 MethodAccessFlags::PUBLIC,
51 ),
52 ],
53 fields: vec![
54 JavaFieldProto::new("elementData", "[Ljava/lang/Object;", FieldAccessFlags::TRANSIENT),
55 JavaFieldProto::new("size", "I", FieldAccessFlags::PRIVATE),
56 ],
57 access_flags: ClassAccessFlags::PUBLIC,
58 }
59 }
60
61 async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
62 tracing::debug!("java.util.ArrayList::<init>({this:?})");
63
64 let _: () = jvm.invoke_special(&this, "java/util/ArrayList", "<init>", "(I)V", (10,)).await?;
65
66 Ok(())
67 }
68
69 async fn init_with_capacity(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, capacity: i32) -> Result<()> {
70 tracing::debug!("java.util.ArrayList::<init>({this:?}, {capacity:?})");
71
72 if capacity < 0 {
73 return Err(jvm
74 .exception("java/lang/IllegalArgumentException", &format!("Illegal Capacity: {capacity}"))
75 .await);
76 }
77
78 let _: () = jvm.invoke_special(&this, "java/util/AbstractList", "<init>", "()V", ()).await?;
79
80 let element_data = jvm.instantiate_array("Ljava/lang/Object;", capacity as usize).await?;
81 jvm.put_field(&mut this, "elementData", "[Ljava/lang/Object;", element_data).await?;
82 jvm.put_field(&mut this, "size", "I", 0).await?;
83
84 Ok(())
85 }
86
87 async fn init_from_collection(
88 jvm: &Jvm,
89 _: &mut RuntimeContext,
90 this: ClassInstanceRef<Self>,
91 collection: ClassInstanceRef<Object>,
92 ) -> Result<()> {
93 tracing::debug!("java.util.ArrayList::<init>({this:?}, {collection:?})");
94
95 if collection.is_null() {
96 return Err(jvm.exception("java/lang/NullPointerException", "collection").await);
97 }
98 let size: i32 = jvm
99 .invoke_virtual(&collection, &collection.class_definition().name(), "size", "()I", ())
100 .await?;
101 let _: () = jvm.invoke_special(&this, "java/util/ArrayList", "<init>", "(I)V", (size,)).await?;
102 let _: bool = jvm
103 .invoke_virtual(&this, "java/util/ArrayList", "addAll", "(Ljava/util/Collection;)Z", (collection,))
104 .await?;
105
106 Ok(())
107 }
108
109 async fn add(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<bool> {
110 tracing::debug!("java.util.ArrayList::add({this:?}, {element:?})");
111
112 let size: i32 = jvm.get_field(&this, "size", "I").await?;
113 Self::ensure_capacity(jvm, &mut this, (size + 1) as usize).await?;
114
115 let mut element_data = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?;
116 jvm.store_array(&mut element_data, size as usize, core::iter::once(element)).await?;
117 jvm.put_field(&mut this, "size", "I", size + 1).await?;
118
119 Ok(true)
120 }
121
122 async fn add_at(
123 jvm: &Jvm,
124 _: &mut RuntimeContext,
125 mut this: ClassInstanceRef<Self>,
126 index: i32,
127 element: ClassInstanceRef<Object>,
128 ) -> Result<()> {
129 tracing::debug!("java.util.ArrayList::add({this:?}, {index:?}, {element:?})");
130
131 let size: i32 = jvm.get_field(&this, "size", "I").await?;
132 if index < 0 || index > size {
133 return Err(Self::index_out_of_bounds(jvm, index, size).await);
134 }
135
136 Self::ensure_capacity(jvm, &mut this, (size + 1) as usize).await?;
137
138 let mut element_data = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?;
139 let num_to_move = size - index;
140 if num_to_move > 0 {
141 let to_shift: Vec<ClassInstanceRef<Object>> = jvm.load_array(&element_data, index as usize, num_to_move as usize).await?;
142 jvm.store_array(&mut element_data, (index + 1) as usize, to_shift).await?;
143 }
144
145 jvm.store_array(&mut element_data, index as usize, core::iter::once(element)).await?;
146 jvm.put_field(&mut this, "size", "I", size + 1).await?;
147
148 Ok(())
149 }
150
151 async fn get(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<Object>> {
152 tracing::debug!("java.util.ArrayList::get({this:?}, {index:?})");
153
154 let size: i32 = jvm.get_field(&this, "size", "I").await?;
155 if index < 0 || index >= size {
156 return Err(Self::index_out_of_bounds(jvm, index, size).await);
157 }
158
159 let element_data = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?;
160 let element: ClassInstanceRef<Object> = jvm.load_array(&element_data, index as usize, 1).await?.into_iter().next().unwrap();
161
162 Ok(element)
163 }
164
165 async fn set(
166 jvm: &Jvm,
167 _: &mut RuntimeContext,
168 this: ClassInstanceRef<Self>,
169 index: i32,
170 element: ClassInstanceRef<Object>,
171 ) -> Result<ClassInstanceRef<Object>> {
172 tracing::debug!("java.util.ArrayList::set({this:?}, {index:?}, {element:?})");
173
174 let size: i32 = jvm.get_field(&this, "size", "I").await?;
175 if index < 0 || index >= size {
176 return Err(Self::index_out_of_bounds(jvm, index, size).await);
177 }
178
179 let mut element_data = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?;
180 let old_element: ClassInstanceRef<Object> = jvm.load_array(&element_data, index as usize, 1).await?.into_iter().next().unwrap();
181 jvm.store_array(&mut element_data, index as usize, core::iter::once(element)).await?;
182
183 Ok(old_element)
184 }
185
186 async fn remove(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<Object>> {
187 tracing::debug!("java.util.ArrayList::remove({this:?}, {index:?})");
188
189 let size: i32 = jvm.get_field(&this, "size", "I").await?;
190 if index < 0 || index >= size {
191 return Err(Self::index_out_of_bounds(jvm, index, size).await);
192 }
193
194 let mut element_data = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?;
195 let removed: ClassInstanceRef<Object> = jvm.load_array(&element_data, index as usize, 1).await?.into_iter().next().unwrap();
196
197 let num_to_move = size - index - 1;
198 if num_to_move > 0 {
199 let to_shift: Vec<ClassInstanceRef<Object>> = jvm.load_array(&element_data, (index + 1) as usize, num_to_move as usize).await?;
200 jvm.store_array(&mut element_data, index as usize, to_shift).await?;
201 }
202
203 let null_ref: ClassInstanceRef<Object> = None.into();
204 jvm.store_array(&mut element_data, (size - 1) as usize, core::iter::once(null_ref))
205 .await?;
206 jvm.put_field(&mut this, "size", "I", size - 1).await?;
207
208 Ok(removed)
209 }
210
211 async fn remove_object(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<bool> {
212 tracing::debug!("java.util.ArrayList::remove({this:?}, {element:?})");
213
214 let index: i32 = jvm
215 .invoke_virtual(&this, "java/util/ArrayList", "indexOf", "(Ljava/lang/Object;)I", (element,))
216 .await?;
217 if index < 0 {
218 return Ok(false);
219 }
220
221 let _: ClassInstanceRef<Object> = jvm
222 .invoke_virtual(&this, "java/util/ArrayList", "remove", "(I)Ljava/lang/Object;", (index,))
223 .await?;
224
225 Ok(true)
226 }
227
228 async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
229 tracing::debug!("java.util.ArrayList::size({this:?})");
230
231 jvm.get_field(&this, "size", "I").await
232 }
233
234 async fn is_empty(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
235 tracing::debug!("java.util.ArrayList::isEmpty({this:?})");
236
237 let size: i32 = jvm.get_field(&this, "size", "I").await?;
238
239 Ok(size == 0)
240 }
241
242 async fn contains(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<bool> {
243 tracing::debug!("java.util.ArrayList::contains({this:?}, {element:?})");
244
245 let index: i32 = jvm
246 .invoke_virtual(&this, "java/util/ArrayList", "indexOf", "(Ljava/lang/Object;)I", (element,))
247 .await?;
248
249 Ok(index >= 0)
250 }
251
252 async fn index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<i32> {
253 tracing::debug!("java.util.ArrayList::indexOf({this:?}, {element:?})");
254
255 let size: i32 = jvm.get_field(&this, "size", "I").await?;
256 let element_data = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?;
257
258 for index in 0..size {
259 let item: ClassInstanceRef<Object> = jvm.load_array(&element_data, index as usize, 1).await?.into_iter().next().unwrap();
260 if Self::object_equals(jvm, &element, &item).await? {
261 return Ok(index);
262 }
263 }
264
265 Ok(-1)
266 }
267
268 async fn clear(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
269 tracing::debug!("java.util.ArrayList::clear({this:?})");
270
271 let size: i32 = jvm.get_field(&this, "size", "I").await?;
272 if size > 0 {
273 let mut element_data = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?;
274 let nulls: Vec<ClassInstanceRef<Object>> = (0..size).map(|_| None.into()).collect();
275 jvm.store_array(&mut element_data, 0, nulls).await?;
276 }
277
278 jvm.put_field(&mut this, "size", "I", 0).await?;
279
280 Ok(())
281 }
282
283 async fn to_array(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<Object>>> {
284 tracing::debug!("java.util.ArrayList::toArray({this:?})");
285
286 let size: i32 = jvm.get_field(&this, "size", "I").await?;
287 let element_data: ClassInstanceRef<Array<Object>> = jvm.get_field(&this, "elementData", "[Ljava/lang/Object;").await?;
288
289 Self::copy_to_array(jvm, &element_data, size).await
290 }
291
292 async fn iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
293 tracing::debug!("java.util.ArrayList::iterator({this:?})");
294
295 let iterator = jvm.new_class("java/util/ArrayList$Itr", "(Ljava/util/List;I)V", (this, 0)).await?;
296
297 Ok(iterator.into())
298 }
299
300 async fn list_iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
301 let iterator = jvm.new_class("java/util/ArrayList$ListItr", "(Ljava/util/List;I)V", (this, 0)).await?;
302 Ok(iterator.into())
303 }
304
305 async fn list_iterator_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<Object>> {
306 let iterator = jvm
307 .new_class("java/util/ArrayList$ListItr", "(Ljava/util/List;I)V", (this, index))
308 .await?;
309 Ok(iterator.into())
310 }
311
312 async fn ensure_capacity(jvm: &Jvm, this: &mut ClassInstanceRef<Self>, min_capacity: usize) -> Result<()> {
313 let element_data = jvm.get_field(this, "elementData", "[Ljava/lang/Object;").await?;
314 let current_capacity = jvm.array_length(&element_data).await?;
315
316 if min_capacity <= current_capacity {
317 return Ok(());
318 }
319
320 let new_capacity = if current_capacity == 0 { 1 } else { current_capacity * 2 }.max(min_capacity);
321 let size: i32 = jvm.get_field(this, "size", "I").await?;
322 let old_elements: Vec<ClassInstanceRef<Object>> = jvm.load_array(&element_data, 0, size as usize).await?;
323
324 let mut new_element_data = jvm.instantiate_array("Ljava/lang/Object;", new_capacity).await?;
325 if !old_elements.is_empty() {
326 jvm.store_array(&mut new_element_data, 0, old_elements).await?;
327 }
328 jvm.put_field(this, "elementData", "[Ljava/lang/Object;", new_element_data).await?;
329
330 Ok(())
331 }
332
333 async fn index_out_of_bounds(jvm: &Jvm, index: i32, size: i32) -> jvm::JavaError {
334 jvm.exception("java/lang/IndexOutOfBoundsException", &format!("Index: {index}, Size: {size}"))
335 .await
336 }
337
338 async fn object_equals(jvm: &Jvm, left: &ClassInstanceRef<Object>, right: &ClassInstanceRef<Object>) -> Result<bool> {
339 if left.is_null() {
340 return Ok(right.is_null());
341 }
342
343 if right.is_null() {
344 return Ok(false);
345 }
346
347 jvm.invoke_virtual(left, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (right.clone(),))
348 .await
349 }
350
351 async fn copy_to_array(jvm: &Jvm, source: &ClassInstanceRef<Array<Object>>, len: i32) -> Result<ClassInstanceRef<Array<Object>>> {
352 if source.is_null() {
353 return Err(jvm.exception("java/lang/NullPointerException", "source").await);
354 }
355
356 if len < 0 {
357 return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "negative length").await);
358 }
359
360 let len = len as usize;
361 let elements: Vec<ClassInstanceRef<Object>> = if len == 0 { Vec::new() } else { jvm.load_array(source, 0, len).await? };
362 let mut copy: ClassInstanceRef<Array<Object>> = jvm.instantiate_array("Ljava/lang/Object;", len).await?.into();
363 if !elements.is_empty() {
364 jvm.store_array(&mut copy, 0, elements).await?;
365 }
366
367 Ok(copy)
368 }
369}