Skip to main content

rustjava_runtime/classes/java/util/
vector.rs

1use alloc::{
2    format,
3    string::{String as RustString, ToString},
4    vec,
5    vec::Vec,
6};
7
8use jvm::{Array, ClassInstanceRef, Jvm, Result, runtime::JavaLangString};
9use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
10use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
11
12use crate::{
13    RuntimeClassProto, RuntimeContext,
14    classes::java::lang::{Object, String},
15};
16
17// class java.util.Vector
18pub struct Vector;
19
20impl Vector {
21    pub fn as_proto() -> RuntimeClassProto {
22        RuntimeClassProto {
23            name: "java/util/Vector",
24            parent_class: Some("java/util/AbstractList"),
25            interfaces: vec!["java/util/List", "java/lang/Cloneable", "java/io/Serializable"],
26            methods: vec![
27                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
28                JavaMethodProto::new("<init>", "(I)V", Self::init_with_capacity, MethodAccessFlags::PUBLIC),
29                JavaMethodProto::new("<init>", "(II)V", Self::init_with_capacity_increment, MethodAccessFlags::PUBLIC),
30                JavaMethodProto::new(
31                    "<init>",
32                    "(Ljava/util/Collection;)V",
33                    Self::init_from_collection,
34                    MethodAccessFlags::PUBLIC,
35                ),
36                JavaMethodProto::new(
37                    "capacity",
38                    "()I",
39                    Self::capacity,
40                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
41                ),
42                JavaMethodProto::new(
43                    "copyInto",
44                    "([Ljava/lang/Object;)V",
45                    Self::copy_into,
46                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
47                ),
48                JavaMethodProto::new("elements", "()Ljava/util/Enumeration;", Self::elements, MethodAccessFlags::PUBLIC),
49                JavaMethodProto::new(
50                    "ensureCapacity",
51                    "(I)V",
52                    Self::ensure_capacity_api,
53                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
54                ),
55                JavaMethodProto::new(
56                    "add",
57                    "(Ljava/lang/Object;)Z",
58                    Self::add,
59                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
60                ),
61                JavaMethodProto::new(
62                    "add",
63                    "(ILjava/lang/Object;)V",
64                    Self::add_at,
65                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
66                ),
67                JavaMethodProto::new(
68                    "addElement",
69                    "(Ljava/lang/Object;)V",
70                    Self::add_element,
71                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
72                ),
73                JavaMethodProto::new(
74                    "insertElementAt",
75                    "(Ljava/lang/Object;I)V",
76                    Self::insert_element_at,
77                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
78                ),
79                JavaMethodProto::new(
80                    "elementAt",
81                    "(I)Ljava/lang/Object;",
82                    Self::element_at,
83                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
84                ),
85                JavaMethodProto::new(
86                    "get",
87                    "(I)Ljava/lang/Object;",
88                    Self::get,
89                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
90                ),
91                JavaMethodProto::new(
92                    "set",
93                    "(ILjava/lang/Object;)Ljava/lang/Object;",
94                    Self::set,
95                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
96                ),
97                JavaMethodProto::new("size", "()I", Self::size, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
98                JavaMethodProto::new(
99                    "isEmpty",
100                    "()Z",
101                    Self::is_empty,
102                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
103                ),
104                JavaMethodProto::new(
105                    "remove",
106                    "(I)Ljava/lang/Object;",
107                    Self::remove,
108                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
109                ),
110                JavaMethodProto::new("remove", "(Ljava/lang/Object;)Z", Self::remove_object, MethodAccessFlags::PUBLIC),
111                JavaMethodProto::new(
112                    "removeAllElements",
113                    "()V",
114                    Self::remove_all_elements,
115                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
116                ),
117                JavaMethodProto::new(
118                    "removeElementAt",
119                    "(I)V",
120                    Self::remove_element_at,
121                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
122                ),
123                JavaMethodProto::new("indexOf", "(Ljava/lang/Object;)I", Self::index_of, MethodAccessFlags::PUBLIC),
124                JavaMethodProto::new(
125                    "indexOf",
126                    "(Ljava/lang/Object;I)I",
127                    Self::index_of_from,
128                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
129                ),
130                JavaMethodProto::new("contains", "(Ljava/lang/Object;)Z", Self::contains, MethodAccessFlags::PUBLIC),
131                JavaMethodProto::new(
132                    "lastIndexOf",
133                    "(Ljava/lang/Object;)I",
134                    Self::last_index_of,
135                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
136                ),
137                JavaMethodProto::new(
138                    "lastIndexOf",
139                    "(Ljava/lang/Object;I)I",
140                    Self::last_index_of_index,
141                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
142                ),
143                JavaMethodProto::new(
144                    "firstElement",
145                    "()Ljava/lang/Object;",
146                    Self::first_element,
147                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
148                ),
149                JavaMethodProto::new(
150                    "lastElement",
151                    "()Ljava/lang/Object;",
152                    Self::last_element,
153                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
154                ),
155                JavaMethodProto::new(
156                    "setElementAt",
157                    "(Ljava/lang/Object;I)V",
158                    Self::set_element_at,
159                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
160                ),
161                JavaMethodProto::new(
162                    "setSize",
163                    "(I)V",
164                    Self::set_size,
165                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
166                ),
167                JavaMethodProto::new(
168                    "removeElement",
169                    "(Ljava/lang/Object;)Z",
170                    Self::remove_element,
171                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
172                ),
173                JavaMethodProto::new("clear", "()V", Self::clear, MethodAccessFlags::PUBLIC),
174                JavaMethodProto::new(
175                    "toArray",
176                    "()[Ljava/lang/Object;",
177                    Self::to_array,
178                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
179                ),
180                JavaMethodProto::new(
181                    "toArray",
182                    "([Ljava/lang/Object;)[Ljava/lang/Object;",
183                    Self::to_typed_array,
184                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
185                ),
186                JavaMethodProto::new(
187                    "addAll",
188                    "(Ljava/util/Collection;)Z",
189                    Self::add_all,
190                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
191                ),
192                JavaMethodProto::new(
193                    "addAll",
194                    "(ILjava/util/Collection;)Z",
195                    Self::add_all_at,
196                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
197                ),
198                JavaMethodProto::new(
199                    "containsAll",
200                    "(Ljava/util/Collection;)Z",
201                    Self::contains_all,
202                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
203                ),
204                JavaMethodProto::new(
205                    "removeAll",
206                    "(Ljava/util/Collection;)Z",
207                    Self::remove_all,
208                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
209                ),
210                JavaMethodProto::new(
211                    "retainAll",
212                    "(Ljava/util/Collection;)Z",
213                    Self::retain_all,
214                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
215                ),
216                JavaMethodProto::new(
217                    "iterator",
218                    "()Ljava/util/Iterator;",
219                    Self::iterator,
220                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
221                ),
222                JavaMethodProto::new(
223                    "listIterator",
224                    "()Ljava/util/ListIterator;",
225                    Self::list_iterator,
226                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
227                ),
228                JavaMethodProto::new(
229                    "listIterator",
230                    "(I)Ljava/util/ListIterator;",
231                    Self::list_iterator_at,
232                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
233                ),
234                JavaMethodProto::new(
235                    "trimToSize",
236                    "()V",
237                    Self::trim_to_size,
238                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
239                ),
240                JavaMethodProto::new(
241                    "toString",
242                    "()Ljava/lang/String;",
243                    Self::to_string,
244                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
245                ),
246            ],
247            fields: vec![
248                JavaFieldProto::new("elementData", "[Ljava/lang/Object;", FieldAccessFlags::PROTECTED),
249                JavaFieldProto::new("elementCount", "I", FieldAccessFlags::PROTECTED),
250                JavaFieldProto::new("capacityIncrement", "I", FieldAccessFlags::PROTECTED),
251            ],
252            access_flags: ClassAccessFlags::PUBLIC,
253        }
254    }
255
256    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
257        tracing::debug!("java.util.Vector::<init>({this:?})");
258
259        let _: () = jvm.invoke_special(&this, "java/util/Vector", "<init>", "(I)V", (10,)).await?;
260
261        Ok(())
262    }
263
264    async fn init_with_capacity(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, capacity: i32) -> Result<()> {
265        tracing::debug!("java.util.Vector::<init>({this:?}, {capacity:?})");
266
267        let _: () = jvm.invoke_special(&this, "java/util/Vector", "<init>", "(II)V", (capacity, 0)).await?;
268
269        Ok(())
270    }
271
272    async fn init_with_capacity_increment(
273        jvm: &Jvm,
274        _: &mut RuntimeContext,
275        mut this: ClassInstanceRef<Self>,
276        capacity: i32,
277        capacity_increment: i32,
278    ) -> Result<()> {
279        tracing::debug!("java.util.Vector::<init>({this:?}, {capacity:?}, {capacity_increment:?})");
280
281        if capacity < 0 {
282            return Err(jvm
283                .exception("java/lang/IllegalArgumentException", &format!("Illegal Capacity: {capacity}"))
284                .await);
285        }
286
287        let _: () = jvm.invoke_special(&this, "java/util/AbstractList", "<init>", "()V", ()).await?;
288
289        let element_data = jvm.instantiate_array("Ljava/lang/Object;", capacity as _).await?;
290        jvm.put_field(&mut this, "java/util/Vector", "elementData", "[Ljava/lang/Object;", element_data)
291            .await?;
292        jvm.put_field(&mut this, "java/util/Vector", "elementCount", "I", 0).await?;
293        jvm.put_field(&mut this, "java/util/Vector", "capacityIncrement", "I", capacity_increment)
294            .await?;
295
296        Ok(())
297    }
298
299    async fn init_from_collection(
300        jvm: &Jvm,
301        _: &mut RuntimeContext,
302        this: ClassInstanceRef<Self>,
303        collection: ClassInstanceRef<Object>,
304    ) -> Result<()> {
305        tracing::debug!("java.util.Vector::<init>({this:?}, {collection:?})");
306
307        if collection.is_null() {
308            return Err(jvm.exception("java/lang/NullPointerException", "collection").await);
309        }
310        let size: i32 = jvm
311            .invoke_virtual(&collection, &collection.class_definition().name(), "size", "()I", ())
312            .await?;
313        let _: () = jvm.invoke_special(&this, "java/util/Vector", "<init>", "(I)V", (size,)).await?;
314        let _: bool = jvm
315            .invoke_virtual(&this, "java/util/Vector", "addAll", "(Ljava/util/Collection;)Z", (collection,))
316            .await?;
317
318        Ok(())
319    }
320
321    async fn capacity(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
322        let element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
323        Ok(jvm.array_length(&element_data).await? as i32)
324    }
325
326    async fn copy_into(
327        jvm: &Jvm,
328        _: &mut RuntimeContext,
329        this: ClassInstanceRef<Self>,
330        mut destination: ClassInstanceRef<Array<Object>>,
331    ) -> Result<()> {
332        tracing::debug!("java.util.Vector::copyInto({this:?}, {destination:?})");
333
334        if destination.is_null() {
335            return Err(jvm.exception("java/lang/NullPointerException", "destination").await);
336        }
337
338        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
339        let element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
340        let elements: Vec<ClassInstanceRef<Object>> = jvm.load_array(&element_data, 0, element_count as usize).await?;
341        jvm.store_array(&mut destination, 0, elements).await
342    }
343
344    async fn elements(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
345        tracing::debug!("java.util.Vector::elements({this:?})");
346
347        let snapshot: ClassInstanceRef<Array<Object>> = jvm
348            .invoke_virtual(&this, "java/util/Vector", "toArray", "()[Ljava/lang/Object;", ())
349            .await?;
350        Ok(jvm
351            .new_class("java/util/Hashtable$Enumerator", "([Ljava/lang/Object;)V", (snapshot,))
352            .await?
353            .into())
354    }
355
356    async fn ensure_capacity_api(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, min_capacity: i32) -> Result<()> {
357        tracing::debug!("java.util.Vector::ensureCapacity({this:?}, {min_capacity:?})");
358
359        if min_capacity > 0 {
360            Self::ensure_capacity(jvm, &mut this, min_capacity as usize).await?;
361        }
362
363        Ok(())
364    }
365
366    async fn add(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<bool> {
367        tracing::debug!("java.util.Vector::add({this:?}, {element:?})");
368
369        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
370        let mut element_data = Self::ensure_capacity(jvm, &mut this, (element_count + 1) as _).await?;
371        jvm.store_array(&mut element_data, element_count as _, core::iter::once(element)).await?;
372        jvm.put_field(&mut this, "java/util/Vector", "elementCount", "I", element_count + 1)
373            .await?;
374
375        Ok(true)
376    }
377
378    async fn add_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32, element: ClassInstanceRef<Object>) -> Result<()> {
379        tracing::debug!("java.util.Vector::add({this:?}, {index:?}, {element:?})");
380
381        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
382        if index < 0 || index > element_count {
383            return Err(jvm
384                .exception("java/lang/IndexOutOfBoundsException", &format!("Index: {index}, Size: {element_count}"))
385                .await);
386        }
387
388        jvm.invoke_virtual(&this, "java/util/Vector", "insertElementAt", "(Ljava/lang/Object;I)V", (element, index))
389            .await
390    }
391
392    async fn add_element(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<()> {
393        tracing::debug!("java.util.Vector::addElement({this:?}, {element:?})");
394
395        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
396        let mut element_data = Self::ensure_capacity(jvm, &mut this, (element_count + 1) as _).await?;
397        jvm.store_array(&mut element_data, element_count as _, core::iter::once(element)).await?;
398        jvm.put_field(&mut this, "java/util/Vector", "elementCount", "I", element_count + 1)
399            .await?;
400
401        Ok(())
402    }
403
404    async fn insert_element_at(
405        jvm: &Jvm,
406        _: &mut RuntimeContext,
407        mut this: ClassInstanceRef<Self>,
408        element: ClassInstanceRef<Object>,
409        index: i32,
410    ) -> Result<()> {
411        tracing::debug!("java.util.Vector::insertElementAt({this:?}, {element:?}, {index:?})");
412
413        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
414        if index < 0 || index > element_count {
415            return Err(jvm
416                .exception("java/lang/ArrayIndexOutOfBoundsException", &format!("{index} > {element_count}"))
417                .await);
418        }
419        let mut element_data = Self::ensure_capacity(jvm, &mut this, (element_count + 1) as _).await?;
420
421        let num_to_move = element_count - index;
422        if num_to_move > 0 {
423            let to_shift: Vec<ClassInstanceRef<Object>> = jvm.load_array(&element_data, index as _, num_to_move as _).await?;
424            jvm.store_array(&mut element_data, (index + 1) as _, to_shift).await?;
425        }
426
427        jvm.store_array(&mut element_data, index as _, core::iter::once(element)).await?;
428        jvm.put_field(&mut this, "java/util/Vector", "elementCount", "I", element_count + 1)
429            .await?;
430
431        Ok(())
432    }
433
434    async fn element_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<Object>> {
435        tracing::debug!("java.util.Vector::elementAt({this:?}, {index:?})");
436
437        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
438        if index < 0 || index >= element_count {
439            return Err(jvm
440                .exception("java/lang/ArrayIndexOutOfBoundsException", &format!("{index} >= {element_count}"))
441                .await);
442        }
443
444        let element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
445        let element: ClassInstanceRef<Object> = jvm.load_array(&element_data, index as _, 1).await?.into_iter().next().unwrap();
446
447        Ok(element)
448    }
449
450    async fn get(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<Object>> {
451        tracing::debug!("java.util.Vector::get({this:?}, {index:?})");
452
453        jvm.invoke_virtual(&this, "java/util/Vector", "elementAt", "(I)Ljava/lang/Object;", (index,))
454            .await
455    }
456
457    async fn set(
458        jvm: &Jvm,
459        _: &mut RuntimeContext,
460        this: ClassInstanceRef<Self>,
461        index: i32,
462        element: ClassInstanceRef<Object>,
463    ) -> Result<ClassInstanceRef<Object>> {
464        tracing::debug!("java.util.Vector::set({this:?}, {index:?}, {element:?})");
465
466        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
467        if index < 0 || index >= element_count {
468            return Err(jvm
469                .exception("java/lang/ArrayIndexOutOfBoundsException", &format!("{index} >= {element_count}"))
470                .await);
471        }
472
473        let mut element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
474        let old_element: ClassInstanceRef<Object> = jvm.load_array(&element_data, index as _, 1).await?.into_iter().next().unwrap();
475        jvm.store_array(&mut element_data, index as _, core::iter::once(element)).await?;
476
477        Ok(old_element)
478    }
479
480    async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
481        tracing::debug!("java.util.Vector::size({this:?})");
482
483        jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await
484    }
485
486    async fn is_empty(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
487        tracing::debug!("java.util.Vector::isEmpty({this:?})");
488
489        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
490
491        Ok(element_count == 0)
492    }
493
494    async fn remove(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<Object>> {
495        tracing::debug!("java.util.Vector::remove({this:?}, {index:?})");
496
497        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
498        if index < 0 || index >= element_count {
499            return Err(jvm
500                .exception("java/lang/ArrayIndexOutOfBoundsException", &format!("{index} >= {element_count}"))
501                .await);
502        }
503
504        let mut element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
505        let removed: ClassInstanceRef<Object> = jvm.load_array(&element_data, index as _, 1).await?.into_iter().next().unwrap();
506
507        let num_to_move = element_count - index - 1;
508        if num_to_move > 0 {
509            let to_shift: Vec<ClassInstanceRef<Object>> = jvm.load_array(&element_data, (index + 1) as _, num_to_move as _).await?;
510            jvm.store_array(&mut element_data, index as _, to_shift).await?;
511        }
512
513        let null_ref: ClassInstanceRef<Object> = None.into();
514        jvm.store_array(&mut element_data, (element_count - 1) as _, core::iter::once(null_ref))
515            .await?;
516        jvm.put_field(&mut this, "java/util/Vector", "elementCount", "I", element_count - 1)
517            .await?;
518
519        Ok(removed)
520    }
521
522    async fn remove_object(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<bool> {
523        tracing::debug!("java.util.Vector::remove({this:?}, {element:?})");
524
525        jvm.invoke_virtual(&this, "java/util/Vector", "removeElement", "(Ljava/lang/Object;)Z", (element,))
526            .await
527    }
528
529    async fn remove_all_elements(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
530        tracing::debug!("java.util.Vector::removeAllElements({this:?})");
531
532        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
533        let mut element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
534
535        let nulls: Vec<ClassInstanceRef<Object>> = (0..element_count).map(|_| None.into()).collect();
536        if !nulls.is_empty() {
537            jvm.store_array(&mut element_data, 0, nulls).await?;
538        }
539
540        jvm.put_field(&mut this, "java/util/Vector", "elementCount", "I", 0).await?;
541
542        Ok(())
543    }
544
545    async fn remove_element_at(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, index: i32) -> Result<()> {
546        tracing::debug!("java.util.Vector::removeElementAt({this:?}, {index:?})");
547
548        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
549        if index < 0 || index >= element_count {
550            return Err(jvm
551                .exception("java/lang/ArrayIndexOutOfBoundsException", &format!("{index} >= {element_count}"))
552                .await);
553        }
554
555        let mut element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
556
557        let num_to_move = element_count - index - 1;
558        if num_to_move > 0 {
559            let to_shift: Vec<ClassInstanceRef<Object>> = jvm.load_array(&element_data, (index + 1) as _, num_to_move as _).await?;
560            jvm.store_array(&mut element_data, index as _, to_shift).await?;
561        }
562
563        let null_ref: ClassInstanceRef<Object> = None.into();
564        jvm.store_array(&mut element_data, (element_count - 1) as _, core::iter::once(null_ref))
565            .await?;
566        jvm.put_field(&mut this, "java/util/Vector", "elementCount", "I", element_count - 1)
567            .await?;
568
569        Ok(())
570    }
571
572    async fn index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<i32> {
573        tracing::debug!("java.util.Vector::indexOf({this:?}, {element:?})");
574
575        jvm.invoke_virtual(&this, "java/util/Vector", "indexOf", "(Ljava/lang/Object;I)I", (element, 0))
576            .await
577    }
578
579    async fn index_of_from(
580        jvm: &Jvm,
581        _: &mut RuntimeContext,
582        this: ClassInstanceRef<Self>,
583        element: ClassInstanceRef<Object>,
584        index: i32,
585    ) -> Result<i32> {
586        tracing::debug!("java.util.Vector::indexOf({this:?}, {element:?}, {index:?})");
587
588        if index < 0 {
589            return Err(jvm.exception("java/lang/ArrayIndexOutOfBoundsException", &index.to_string()).await);
590        }
591
592        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
593        let element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
594
595        for i in index..element_count {
596            let item: ClassInstanceRef<Object> = jvm.load_array(&element_data, i as _, 1).await?.into_iter().next().unwrap();
597
598            if item.is_null() && element.is_null() {
599                return Ok(i);
600            }
601
602            if item.is_null() || element.is_null() {
603                continue;
604            }
605
606            if Self::object_equals(jvm, &element, &item).await? {
607                return Ok(i);
608            }
609        }
610
611        Ok(-1)
612    }
613
614    async fn contains(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<bool> {
615        tracing::debug!("java.util.Vector::contains({this:?}, {element:?})");
616
617        let index: i32 = jvm
618            .invoke_virtual(&this, "java/util/Vector", "indexOf", "(Ljava/lang/Object;)I", (element,))
619            .await?;
620
621        Ok(index >= 0)
622    }
623
624    async fn last_index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<i32> {
625        tracing::debug!("java.util.Vector::lastIndexOf({this:?}, {element:?})");
626
627        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
628
629        let index: i32 = jvm
630            .invoke_virtual(
631                &this,
632                "java/util/Vector",
633                "lastIndexOf",
634                "(Ljava/lang/Object;I)I",
635                (element, element_count - 1),
636            )
637            .await?;
638
639        Ok(index)
640    }
641
642    async fn last_index_of_index(
643        jvm: &Jvm,
644        _: &mut RuntimeContext,
645        this: ClassInstanceRef<Self>,
646        element: ClassInstanceRef<Object>,
647        index: i32,
648    ) -> Result<i32> {
649        tracing::debug!("java.util.Vector::lastIndexOf({this:?}, {element:?}, {index:?})");
650
651        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
652
653        if index >= element_count {
654            return Err(jvm
655                .exception("java/lang/IndexOutOfBoundsException", &format!("{index} >= {element_count}"))
656                .await);
657        }
658
659        let element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
660
661        for i in (0..=index).rev() {
662            let item: ClassInstanceRef<Object> = jvm.load_array(&element_data, i as _, 1).await?.into_iter().next().unwrap();
663
664            if item.is_null() && element.is_null() {
665                return Ok(i);
666            }
667
668            if item.is_null() || element.is_null() {
669                continue;
670            }
671
672            if Self::object_equals(jvm, &element, &item).await? {
673                return Ok(i);
674            }
675        }
676
677        Ok(-1)
678    }
679
680    async fn first_element(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
681        tracing::debug!("java.util.Vector::firstElement({this:?})");
682
683        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
684
685        if element_count == 0 {
686            return Err(jvm.exception("java/util/NoSuchElementException", "Vector is empty").await);
687        }
688
689        let element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
690        let element: ClassInstanceRef<Object> = jvm.load_array(&element_data, 0, 1).await?.into_iter().next().unwrap();
691
692        Ok(element)
693    }
694
695    async fn last_element(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
696        tracing::debug!("java.util.Vector::lastElement({this:?})");
697
698        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
699        if element_count == 0 {
700            return Err(jvm.exception("java/util/NoSuchElementException", "Vector is empty").await);
701        }
702
703        let element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
704        Ok(jvm
705            .load_array::<ClassInstanceRef<Object>>(&element_data, (element_count - 1) as usize, 1)
706            .await?
707            .pop()
708            .unwrap())
709    }
710
711    async fn set_element_at(
712        jvm: &Jvm,
713        _: &mut RuntimeContext,
714        this: ClassInstanceRef<Self>,
715        element: ClassInstanceRef<Object>,
716        index: i32,
717    ) -> Result<()> {
718        tracing::debug!("java.util.Vector::setElementAt({this:?}, {element:?}, {index:?})");
719        let _: ClassInstanceRef<Object> = jvm
720            .invoke_virtual(
721                &this,
722                "java/util/Vector",
723                "set",
724                "(ILjava/lang/Object;)Ljava/lang/Object;",
725                (index, element),
726            )
727            .await?;
728        Ok(())
729    }
730
731    async fn set_size(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, new_size: i32) -> Result<()> {
732        tracing::debug!("java.util.Vector::setSize({this:?}, {new_size:?})");
733
734        if new_size < 0 {
735            return Err(jvm.exception("java/lang/ArrayIndexOutOfBoundsException", &new_size.to_string()).await);
736        }
737
738        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
739        if new_size > element_count {
740            Self::ensure_capacity(jvm, &mut this, new_size as usize).await?;
741        } else if new_size < element_count {
742            let mut element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
743            let nulls: Vec<ClassInstanceRef<Object>> = (new_size..element_count).map(|_| None.into()).collect();
744            jvm.store_array(&mut element_data, new_size as usize, nulls).await?;
745        }
746        jvm.put_field(&mut this, "java/util/Vector", "elementCount", "I", new_size).await
747    }
748
749    async fn remove_element(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<bool> {
750        tracing::debug!("java.util.Vector::removeElement({this:?}, {element:?})");
751
752        let index: i32 = jvm
753            .invoke_virtual(&this, "java/util/Vector", "indexOf", "(Ljava/lang/Object;)I", (element,))
754            .await?;
755
756        if index >= 0 {
757            let _: () = jvm.invoke_virtual(&this, "java/util/Vector", "removeElementAt", "(I)V", (index,)).await?;
758            Ok(true)
759        } else {
760            Ok(false)
761        }
762    }
763
764    async fn clear(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
765        tracing::debug!("java.util.Vector::clear({this:?})");
766
767        jvm.invoke_virtual(&this, "java/util/Vector", "removeAllElements", "()V", ()).await
768    }
769
770    async fn to_array(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<Object>>> {
771        tracing::debug!("java.util.Vector::toArray({this:?})");
772
773        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
774        let element_data: ClassInstanceRef<Array<Object>> = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
775
776        Self::copy_to_array(jvm, &element_data, element_count).await
777    }
778
779    async fn to_typed_array(
780        jvm: &Jvm,
781        _: &mut RuntimeContext,
782        this: ClassInstanceRef<Self>,
783        destination: ClassInstanceRef<Array<Object>>,
784    ) -> Result<ClassInstanceRef<Array<Object>>> {
785        tracing::debug!("java.util.Vector::toArray({this:?}, {destination:?})");
786
787        jvm.invoke_special(
788            &this,
789            "java/util/AbstractCollection",
790            "toArray",
791            "([Ljava/lang/Object;)[Ljava/lang/Object;",
792            (destination,),
793        )
794        .await
795    }
796
797    async fn add_all(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, collection: ClassInstanceRef<Object>) -> Result<bool> {
798        tracing::debug!("java.util.Vector::addAll({this:?}, {collection:?})");
799
800        jvm.invoke_special(
801            &this,
802            "java/util/AbstractCollection",
803            "addAll",
804            "(Ljava/util/Collection;)Z",
805            (collection,),
806        )
807        .await
808    }
809
810    async fn add_all_at(
811        jvm: &Jvm,
812        _: &mut RuntimeContext,
813        this: ClassInstanceRef<Self>,
814        index: i32,
815        collection: ClassInstanceRef<Object>,
816    ) -> Result<bool> {
817        tracing::debug!("java.util.Vector::addAll({this:?}, {index:?}, {collection:?})");
818
819        jvm.invoke_special(
820            &this,
821            "java/util/AbstractList",
822            "addAll",
823            "(ILjava/util/Collection;)Z",
824            (index, collection),
825        )
826        .await
827    }
828
829    async fn contains_all(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, collection: ClassInstanceRef<Object>) -> Result<bool> {
830        tracing::debug!("java.util.Vector::containsAll({this:?}, {collection:?})");
831
832        jvm.invoke_special(
833            &this,
834            "java/util/AbstractCollection",
835            "containsAll",
836            "(Ljava/util/Collection;)Z",
837            (collection,),
838        )
839        .await
840    }
841
842    async fn remove_all(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, collection: ClassInstanceRef<Object>) -> Result<bool> {
843        tracing::debug!("java.util.Vector::removeAll({this:?}, {collection:?})");
844
845        jvm.invoke_special(
846            &this,
847            "java/util/AbstractCollection",
848            "removeAll",
849            "(Ljava/util/Collection;)Z",
850            (collection,),
851        )
852        .await
853    }
854
855    async fn retain_all(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, collection: ClassInstanceRef<Object>) -> Result<bool> {
856        tracing::debug!("java.util.Vector::retainAll({this:?}, {collection:?})");
857
858        jvm.invoke_special(
859            &this,
860            "java/util/AbstractCollection",
861            "retainAll",
862            "(Ljava/util/Collection;)Z",
863            (collection,),
864        )
865        .await
866    }
867
868    async fn iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
869        tracing::debug!("java.util.Vector::iterator({this:?})");
870
871        let iterator = jvm.new_class("java/util/Vector$Itr", "(Ljava/util/Vector;I)V", (this, 0)).await?;
872
873        Ok(iterator.into())
874    }
875
876    async fn list_iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
877        let iterator = jvm.new_class("java/util/Vector$ListItr", "(Ljava/util/Vector;I)V", (this, 0)).await?;
878        Ok(iterator.into())
879    }
880
881    async fn list_iterator_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<Object>> {
882        let iterator = jvm.new_class("java/util/Vector$ListItr", "(Ljava/util/Vector;I)V", (this, index)).await?;
883        Ok(iterator.into())
884    }
885
886    async fn trim_to_size(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
887        tracing::debug!("java.util.Vector::trimToSize({this:?})");
888
889        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
890        let element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
891        let current_capacity = jvm.array_length(&element_data).await?;
892
893        if (element_count as usize) < current_capacity {
894            let elements: Vec<ClassInstanceRef<Object>> = jvm.load_array(&element_data, 0, element_count as _).await?;
895            let mut new_element_data = jvm.instantiate_array("Ljava/lang/Object;", element_count as _).await?;
896            jvm.store_array(&mut new_element_data, 0, elements).await?;
897            jvm.put_field(&mut this, "java/util/Vector", "elementData", "[Ljava/lang/Object;", new_element_data)
898                .await?;
899        }
900
901        Ok(())
902    }
903
904    async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
905        tracing::debug!("java.util.Vector::toString({this:?})");
906
907        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
908        let element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
909        let elements: Vec<ClassInstanceRef<Object>> = jvm.load_array(&element_data, 0, element_count as usize).await?;
910        let mut result = RustString::from("[");
911        for (index, element) in elements.into_iter().enumerate() {
912            if index > 0 {
913                result.push_str(", ");
914            }
915
916            if element.is_null() {
917                result.push_str("null");
918            } else if element.instance.as_ref().unwrap().equals(&**this)? {
919                result.push_str("(this Collection)");
920            } else {
921                let text: ClassInstanceRef<String> = jvm
922                    .invoke_virtual(&element, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
923                    .await?;
924                result.push_str(&JavaLangString::to_rust_string(jvm, &text).await?);
925            }
926        }
927        result.push(']');
928
929        Ok(JavaLangString::from_rust_string(jvm, &result).await?.into())
930    }
931
932    async fn ensure_capacity(jvm: &Jvm, this: &mut ClassInstanceRef<Self>, min_capacity: usize) -> Result<ClassInstanceRef<Array<Object>>> {
933        let element_data: ClassInstanceRef<Array<Object>> = jvm.get_field(this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
934        let current_capacity = jvm.array_length(&element_data).await?;
935
936        if min_capacity > current_capacity {
937            let capacity_increment: i32 = jvm.get_field(this, "java/util/Vector", "capacityIncrement", "I").await?;
938            let new_capacity = if capacity_increment > 0 {
939                current_capacity + capacity_increment as usize
940            } else {
941                current_capacity * 2
942            };
943            let new_capacity = new_capacity.max(min_capacity);
944
945            let element_count: i32 = jvm.get_field(this, "java/util/Vector", "elementCount", "I").await?;
946            let old_elements: Vec<ClassInstanceRef<Object>> = jvm.load_array(&element_data, 0, element_count as _).await?;
947
948            let mut new_element_data = jvm.instantiate_array("Ljava/lang/Object;", new_capacity).await?;
949            jvm.store_array(&mut new_element_data, 0, old_elements).await?;
950            jvm.put_field(this, "java/util/Vector", "elementData", "[Ljava/lang/Object;", new_element_data.clone())
951                .await?;
952            return Ok(new_element_data.into());
953        }
954
955        Ok(element_data)
956    }
957
958    async fn object_equals(jvm: &Jvm, left: &ClassInstanceRef<Object>, right: &ClassInstanceRef<Object>) -> Result<bool> {
959        if left.is_null() {
960            return Ok(right.is_null());
961        }
962
963        if right.is_null() {
964            return Ok(false);
965        }
966
967        jvm.invoke_virtual(left, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (right.clone(),))
968            .await
969    }
970
971    async fn copy_to_array(jvm: &Jvm, source: &ClassInstanceRef<Array<Object>>, len: i32) -> Result<ClassInstanceRef<Array<Object>>> {
972        if source.is_null() {
973            return Err(jvm.exception("java/lang/NullPointerException", "source").await);
974        }
975
976        if len < 0 {
977            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "negative length").await);
978        }
979
980        let len = len as usize;
981        let elements: Vec<ClassInstanceRef<Object>> = if len == 0 { Vec::new() } else { jvm.load_array(source, 0, len).await? };
982        let mut copy: ClassInstanceRef<Array<Object>> = jvm.instantiate_array("Ljava/lang/Object;", len).await?.into();
983        if !elements.is_empty() {
984            jvm.store_array(&mut copy, 0, elements).await?;
985        }
986
987        Ok(copy)
988    }
989}