Skip to main content

rustjava_runtime/classes/java/util/
array_list.rs

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