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        Self::ensure_capacity(jvm, &mut this, (element_count + 1) as _).await?;
371
372        let mut element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
373        jvm.store_array(&mut element_data, element_count as _, core::iter::once(element)).await?;
374        jvm.put_field(&mut this, "java/util/Vector", "elementCount", "I", element_count + 1)
375            .await?;
376
377        Ok(true)
378    }
379
380    async fn add_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32, element: ClassInstanceRef<Object>) -> Result<()> {
381        tracing::debug!("java.util.Vector::add({this:?}, {index:?}, {element:?})");
382
383        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
384        if index < 0 || index > element_count {
385            return Err(jvm
386                .exception("java/lang/IndexOutOfBoundsException", &format!("Index: {index}, Size: {element_count}"))
387                .await);
388        }
389
390        jvm.invoke_virtual(&this, "java/util/Vector", "insertElementAt", "(Ljava/lang/Object;I)V", (element, index))
391            .await
392    }
393
394    async fn add_element(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<()> {
395        tracing::debug!("java.util.Vector::addElement({this:?}, {element:?})");
396
397        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
398        Self::ensure_capacity(jvm, &mut this, (element_count + 1) as _).await?;
399
400        let mut element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
401        jvm.store_array(&mut element_data, element_count as _, core::iter::once(element)).await?;
402        jvm.put_field(&mut this, "java/util/Vector", "elementCount", "I", element_count + 1)
403            .await?;
404
405        Ok(())
406    }
407
408    async fn insert_element_at(
409        jvm: &Jvm,
410        _: &mut RuntimeContext,
411        mut this: ClassInstanceRef<Self>,
412        element: ClassInstanceRef<Object>,
413        index: i32,
414    ) -> Result<()> {
415        tracing::debug!("java.util.Vector::insertElementAt({this:?}, {element:?}, {index:?})");
416
417        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
418        if index < 0 || index > element_count {
419            return Err(jvm
420                .exception("java/lang/ArrayIndexOutOfBoundsException", &format!("{index} > {element_count}"))
421                .await);
422        }
423        Self::ensure_capacity(jvm, &mut this, (element_count + 1) as _).await?;
424
425        let mut element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
426
427        let num_to_move = element_count - index;
428        if num_to_move > 0 {
429            let to_shift: Vec<ClassInstanceRef<Object>> = jvm.load_array(&element_data, index as _, num_to_move as _).await?;
430            jvm.store_array(&mut element_data, (index + 1) as _, to_shift).await?;
431        }
432
433        jvm.store_array(&mut element_data, index as _, core::iter::once(element)).await?;
434        jvm.put_field(&mut this, "java/util/Vector", "elementCount", "I", element_count + 1)
435            .await?;
436
437        Ok(())
438    }
439
440    async fn element_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<Object>> {
441        tracing::debug!("java.util.Vector::elementAt({this:?}, {index:?})");
442
443        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
444        if index < 0 || index >= element_count {
445            return Err(jvm
446                .exception("java/lang/ArrayIndexOutOfBoundsException", &format!("{index} >= {element_count}"))
447                .await);
448        }
449
450        let element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
451        let element: ClassInstanceRef<Object> = jvm.load_array(&element_data, index as _, 1).await?.into_iter().next().unwrap();
452
453        Ok(element)
454    }
455
456    async fn get(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<Object>> {
457        tracing::debug!("java.util.Vector::get({this:?}, {index:?})");
458
459        jvm.invoke_virtual(&this, "java/util/Vector", "elementAt", "(I)Ljava/lang/Object;", (index,))
460            .await
461    }
462
463    async fn set(
464        jvm: &Jvm,
465        _: &mut RuntimeContext,
466        this: ClassInstanceRef<Self>,
467        index: i32,
468        element: ClassInstanceRef<Object>,
469    ) -> Result<ClassInstanceRef<Object>> {
470        tracing::debug!("java.util.Vector::set({this:?}, {index:?}, {element:?})");
471
472        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
473        if index < 0 || index >= element_count {
474            return Err(jvm
475                .exception("java/lang/ArrayIndexOutOfBoundsException", &format!("{index} >= {element_count}"))
476                .await);
477        }
478
479        let mut element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
480        let old_element: ClassInstanceRef<Object> = jvm.load_array(&element_data, index as _, 1).await?.into_iter().next().unwrap();
481        jvm.store_array(&mut element_data, index as _, core::iter::once(element)).await?;
482
483        Ok(old_element)
484    }
485
486    async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
487        tracing::debug!("java.util.Vector::size({this:?})");
488
489        jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await
490    }
491
492    async fn is_empty(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
493        tracing::debug!("java.util.Vector::isEmpty({this:?})");
494
495        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
496
497        Ok(element_count == 0)
498    }
499
500    async fn remove(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<Object>> {
501        tracing::debug!("java.util.Vector::remove({this:?}, {index:?})");
502
503        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
504        if index < 0 || index >= element_count {
505            return Err(jvm
506                .exception("java/lang/ArrayIndexOutOfBoundsException", &format!("{index} >= {element_count}"))
507                .await);
508        }
509
510        let mut element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
511        let removed: ClassInstanceRef<Object> = jvm.load_array(&element_data, index as _, 1).await?.into_iter().next().unwrap();
512
513        let num_to_move = element_count - index - 1;
514        if num_to_move > 0 {
515            let to_shift: Vec<ClassInstanceRef<Object>> = jvm.load_array(&element_data, (index + 1) as _, num_to_move as _).await?;
516            jvm.store_array(&mut element_data, index as _, to_shift).await?;
517        }
518
519        let null_ref: ClassInstanceRef<Object> = None.into();
520        jvm.store_array(&mut element_data, (element_count - 1) as _, core::iter::once(null_ref))
521            .await?;
522        jvm.put_field(&mut this, "java/util/Vector", "elementCount", "I", element_count - 1)
523            .await?;
524
525        Ok(removed)
526    }
527
528    async fn remove_object(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<bool> {
529        tracing::debug!("java.util.Vector::remove({this:?}, {element:?})");
530
531        jvm.invoke_virtual(&this, "java/util/Vector", "removeElement", "(Ljava/lang/Object;)Z", (element,))
532            .await
533    }
534
535    async fn remove_all_elements(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
536        tracing::debug!("java.util.Vector::removeAllElements({this:?})");
537
538        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
539        let mut element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
540
541        let nulls: Vec<ClassInstanceRef<Object>> = (0..element_count).map(|_| None.into()).collect();
542        if !nulls.is_empty() {
543            jvm.store_array(&mut element_data, 0, nulls).await?;
544        }
545
546        jvm.put_field(&mut this, "java/util/Vector", "elementCount", "I", 0).await?;
547
548        Ok(())
549    }
550
551    async fn remove_element_at(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, index: i32) -> Result<()> {
552        tracing::debug!("java.util.Vector::removeElementAt({this:?}, {index:?})");
553
554        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
555        if index < 0 || index >= element_count {
556            return Err(jvm
557                .exception("java/lang/ArrayIndexOutOfBoundsException", &format!("{index} >= {element_count}"))
558                .await);
559        }
560
561        let mut element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
562
563        let num_to_move = element_count - index - 1;
564        if num_to_move > 0 {
565            let to_shift: Vec<ClassInstanceRef<Object>> = jvm.load_array(&element_data, (index + 1) as _, num_to_move as _).await?;
566            jvm.store_array(&mut element_data, index as _, to_shift).await?;
567        }
568
569        let null_ref: ClassInstanceRef<Object> = None.into();
570        jvm.store_array(&mut element_data, (element_count - 1) as _, core::iter::once(null_ref))
571            .await?;
572        jvm.put_field(&mut this, "java/util/Vector", "elementCount", "I", element_count - 1)
573            .await?;
574
575        Ok(())
576    }
577
578    async fn index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<i32> {
579        tracing::debug!("java.util.Vector::indexOf({this:?}, {element:?})");
580
581        jvm.invoke_virtual(&this, "java/util/Vector", "indexOf", "(Ljava/lang/Object;I)I", (element, 0))
582            .await
583    }
584
585    async fn index_of_from(
586        jvm: &Jvm,
587        _: &mut RuntimeContext,
588        this: ClassInstanceRef<Self>,
589        element: ClassInstanceRef<Object>,
590        index: i32,
591    ) -> Result<i32> {
592        tracing::debug!("java.util.Vector::indexOf({this:?}, {element:?}, {index:?})");
593
594        if index < 0 {
595            return Err(jvm.exception("java/lang/ArrayIndexOutOfBoundsException", &index.to_string()).await);
596        }
597
598        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
599        let element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
600
601        for i in index..element_count {
602            let item: ClassInstanceRef<Object> = jvm.load_array(&element_data, i as _, 1).await?.into_iter().next().unwrap();
603
604            if item.is_null() && element.is_null() {
605                return Ok(i);
606            }
607
608            if item.is_null() || element.is_null() {
609                continue;
610            }
611
612            if Self::object_equals(jvm, &element, &item).await? {
613                return Ok(i);
614            }
615        }
616
617        Ok(-1)
618    }
619
620    async fn contains(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<bool> {
621        tracing::debug!("java.util.Vector::contains({this:?}, {element:?})");
622
623        let index: i32 = jvm
624            .invoke_virtual(&this, "java/util/Vector", "indexOf", "(Ljava/lang/Object;)I", (element,))
625            .await?;
626
627        Ok(index >= 0)
628    }
629
630    async fn last_index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<i32> {
631        tracing::debug!("java.util.Vector::lastIndexOf({this:?}, {element:?})");
632
633        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
634
635        let index: i32 = jvm
636            .invoke_virtual(
637                &this,
638                "java/util/Vector",
639                "lastIndexOf",
640                "(Ljava/lang/Object;I)I",
641                (element, element_count - 1),
642            )
643            .await?;
644
645        Ok(index)
646    }
647
648    async fn last_index_of_index(
649        jvm: &Jvm,
650        _: &mut RuntimeContext,
651        this: ClassInstanceRef<Self>,
652        element: ClassInstanceRef<Object>,
653        index: i32,
654    ) -> Result<i32> {
655        tracing::debug!("java.util.Vector::lastIndexOf({this:?}, {element:?}, {index:?})");
656
657        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
658
659        if index >= element_count {
660            return Err(jvm
661                .exception("java/lang/IndexOutOfBoundsException", &format!("{index} >= {element_count}"))
662                .await);
663        }
664
665        let element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
666
667        for i in (0..=index).rev() {
668            let item: ClassInstanceRef<Object> = jvm.load_array(&element_data, i as _, 1).await?.into_iter().next().unwrap();
669
670            if item.is_null() && element.is_null() {
671                return Ok(i);
672            }
673
674            if item.is_null() || element.is_null() {
675                continue;
676            }
677
678            if Self::object_equals(jvm, &element, &item).await? {
679                return Ok(i);
680            }
681        }
682
683        Ok(-1)
684    }
685
686    async fn first_element(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
687        tracing::debug!("java.util.Vector::firstElement({this:?})");
688
689        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
690
691        if element_count == 0 {
692            return Err(jvm.exception("java/util/NoSuchElementException", "Vector is empty").await);
693        }
694
695        let element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
696        let element: ClassInstanceRef<Object> = jvm.load_array(&element_data, 0, 1).await?.into_iter().next().unwrap();
697
698        Ok(element)
699    }
700
701    async fn last_element(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
702        tracing::debug!("java.util.Vector::lastElement({this:?})");
703
704        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
705        if element_count == 0 {
706            return Err(jvm.exception("java/util/NoSuchElementException", "Vector is empty").await);
707        }
708
709        let element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
710        Ok(jvm
711            .load_array::<ClassInstanceRef<Object>>(&element_data, (element_count - 1) as usize, 1)
712            .await?
713            .pop()
714            .unwrap())
715    }
716
717    async fn set_element_at(
718        jvm: &Jvm,
719        _: &mut RuntimeContext,
720        this: ClassInstanceRef<Self>,
721        element: ClassInstanceRef<Object>,
722        index: i32,
723    ) -> Result<()> {
724        tracing::debug!("java.util.Vector::setElementAt({this:?}, {element:?}, {index:?})");
725        let _: ClassInstanceRef<Object> = jvm
726            .invoke_virtual(
727                &this,
728                "java/util/Vector",
729                "set",
730                "(ILjava/lang/Object;)Ljava/lang/Object;",
731                (index, element),
732            )
733            .await?;
734        Ok(())
735    }
736
737    async fn set_size(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, new_size: i32) -> Result<()> {
738        tracing::debug!("java.util.Vector::setSize({this:?}, {new_size:?})");
739
740        if new_size < 0 {
741            return Err(jvm.exception("java/lang/ArrayIndexOutOfBoundsException", &new_size.to_string()).await);
742        }
743
744        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
745        if new_size > element_count {
746            Self::ensure_capacity(jvm, &mut this, new_size as usize).await?;
747        } else if new_size < element_count {
748            let mut element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
749            let nulls: Vec<ClassInstanceRef<Object>> = (new_size..element_count).map(|_| None.into()).collect();
750            jvm.store_array(&mut element_data, new_size as usize, nulls).await?;
751        }
752        jvm.put_field(&mut this, "java/util/Vector", "elementCount", "I", new_size).await
753    }
754
755    async fn remove_element(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<bool> {
756        tracing::debug!("java.util.Vector::removeElement({this:?}, {element:?})");
757
758        let index: i32 = jvm
759            .invoke_virtual(&this, "java/util/Vector", "indexOf", "(Ljava/lang/Object;)I", (element,))
760            .await?;
761
762        if index >= 0 {
763            let _: () = jvm.invoke_virtual(&this, "java/util/Vector", "removeElementAt", "(I)V", (index,)).await?;
764            Ok(true)
765        } else {
766            Ok(false)
767        }
768    }
769
770    async fn clear(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
771        tracing::debug!("java.util.Vector::clear({this:?})");
772
773        jvm.invoke_virtual(&this, "java/util/Vector", "removeAllElements", "()V", ()).await
774    }
775
776    async fn to_array(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<Object>>> {
777        tracing::debug!("java.util.Vector::toArray({this:?})");
778
779        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
780        let element_data: ClassInstanceRef<Array<Object>> = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
781
782        Self::copy_to_array(jvm, &element_data, element_count).await
783    }
784
785    async fn to_typed_array(
786        jvm: &Jvm,
787        _: &mut RuntimeContext,
788        this: ClassInstanceRef<Self>,
789        destination: ClassInstanceRef<Array<Object>>,
790    ) -> Result<ClassInstanceRef<Array<Object>>> {
791        tracing::debug!("java.util.Vector::toArray({this:?}, {destination:?})");
792
793        jvm.invoke_special(
794            &this,
795            "java/util/AbstractCollection",
796            "toArray",
797            "([Ljava/lang/Object;)[Ljava/lang/Object;",
798            (destination,),
799        )
800        .await
801    }
802
803    async fn add_all(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, collection: ClassInstanceRef<Object>) -> Result<bool> {
804        tracing::debug!("java.util.Vector::addAll({this:?}, {collection:?})");
805
806        jvm.invoke_special(
807            &this,
808            "java/util/AbstractCollection",
809            "addAll",
810            "(Ljava/util/Collection;)Z",
811            (collection,),
812        )
813        .await
814    }
815
816    async fn add_all_at(
817        jvm: &Jvm,
818        _: &mut RuntimeContext,
819        this: ClassInstanceRef<Self>,
820        index: i32,
821        collection: ClassInstanceRef<Object>,
822    ) -> Result<bool> {
823        tracing::debug!("java.util.Vector::addAll({this:?}, {index:?}, {collection:?})");
824
825        jvm.invoke_special(
826            &this,
827            "java/util/AbstractList",
828            "addAll",
829            "(ILjava/util/Collection;)Z",
830            (index, collection),
831        )
832        .await
833    }
834
835    async fn contains_all(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, collection: ClassInstanceRef<Object>) -> Result<bool> {
836        tracing::debug!("java.util.Vector::containsAll({this:?}, {collection:?})");
837
838        jvm.invoke_special(
839            &this,
840            "java/util/AbstractCollection",
841            "containsAll",
842            "(Ljava/util/Collection;)Z",
843            (collection,),
844        )
845        .await
846    }
847
848    async fn remove_all(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, collection: ClassInstanceRef<Object>) -> Result<bool> {
849        tracing::debug!("java.util.Vector::removeAll({this:?}, {collection:?})");
850
851        jvm.invoke_special(
852            &this,
853            "java/util/AbstractCollection",
854            "removeAll",
855            "(Ljava/util/Collection;)Z",
856            (collection,),
857        )
858        .await
859    }
860
861    async fn retain_all(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, collection: ClassInstanceRef<Object>) -> Result<bool> {
862        tracing::debug!("java.util.Vector::retainAll({this:?}, {collection:?})");
863
864        jvm.invoke_special(
865            &this,
866            "java/util/AbstractCollection",
867            "retainAll",
868            "(Ljava/util/Collection;)Z",
869            (collection,),
870        )
871        .await
872    }
873
874    async fn iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
875        tracing::debug!("java.util.Vector::iterator({this:?})");
876
877        let iterator = jvm.new_class("java/util/Vector$Itr", "(Ljava/util/Vector;I)V", (this, 0)).await?;
878
879        Ok(iterator.into())
880    }
881
882    async fn list_iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
883        let iterator = jvm.new_class("java/util/Vector$ListItr", "(Ljava/util/Vector;I)V", (this, 0)).await?;
884        Ok(iterator.into())
885    }
886
887    async fn list_iterator_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<Object>> {
888        let iterator = jvm.new_class("java/util/Vector$ListItr", "(Ljava/util/Vector;I)V", (this, index)).await?;
889        Ok(iterator.into())
890    }
891
892    async fn trim_to_size(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
893        tracing::debug!("java.util.Vector::trimToSize({this:?})");
894
895        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
896        let element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
897        let current_capacity = jvm.array_length(&element_data).await?;
898
899        if (element_count as usize) < current_capacity {
900            let elements: Vec<ClassInstanceRef<Object>> = jvm.load_array(&element_data, 0, element_count as _).await?;
901            let mut new_element_data = jvm.instantiate_array("Ljava/lang/Object;", element_count as _).await?;
902            jvm.store_array(&mut new_element_data, 0, elements).await?;
903            jvm.put_field(&mut this, "java/util/Vector", "elementData", "[Ljava/lang/Object;", new_element_data)
904                .await?;
905        }
906
907        Ok(())
908    }
909
910    async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
911        tracing::debug!("java.util.Vector::toString({this:?})");
912
913        let element_count: i32 = jvm.get_field(&this, "java/util/Vector", "elementCount", "I").await?;
914        let element_data = jvm.get_field(&this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
915        let elements: Vec<ClassInstanceRef<Object>> = jvm.load_array(&element_data, 0, element_count as usize).await?;
916        let mut result = RustString::from("[");
917        for (index, element) in elements.into_iter().enumerate() {
918            if index > 0 {
919                result.push_str(", ");
920            }
921
922            if element.is_null() {
923                result.push_str("null");
924            } else if element.instance.as_ref().unwrap().equals(&**this)? {
925                result.push_str("(this Collection)");
926            } else {
927                let text: ClassInstanceRef<String> = jvm
928                    .invoke_virtual(&element, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
929                    .await?;
930                result.push_str(&JavaLangString::to_rust_string(jvm, &text).await?);
931            }
932        }
933        result.push(']');
934
935        Ok(JavaLangString::from_rust_string(jvm, &result).await?.into())
936    }
937
938    async fn ensure_capacity(jvm: &Jvm, this: &mut ClassInstanceRef<Self>, min_capacity: usize) -> Result<()> {
939        let element_data = jvm.get_field(this, "java/util/Vector", "elementData", "[Ljava/lang/Object;").await?;
940        let current_capacity = jvm.array_length(&element_data).await?;
941
942        if min_capacity > current_capacity {
943            let capacity_increment: i32 = jvm.get_field(this, "java/util/Vector", "capacityIncrement", "I").await?;
944            let new_capacity = if capacity_increment > 0 {
945                current_capacity + capacity_increment as usize
946            } else {
947                current_capacity * 2
948            };
949            let new_capacity = new_capacity.max(min_capacity);
950
951            let element_count: i32 = jvm.get_field(this, "java/util/Vector", "elementCount", "I").await?;
952            let old_elements: Vec<ClassInstanceRef<Object>> = jvm.load_array(&element_data, 0, element_count as _).await?;
953
954            let mut new_element_data = jvm.instantiate_array("Ljava/lang/Object;", new_capacity).await?;
955            jvm.store_array(&mut new_element_data, 0, old_elements).await?;
956            jvm.put_field(this, "java/util/Vector", "elementData", "[Ljava/lang/Object;", new_element_data)
957                .await?;
958        }
959
960        Ok(())
961    }
962
963    async fn object_equals(jvm: &Jvm, left: &ClassInstanceRef<Object>, right: &ClassInstanceRef<Object>) -> Result<bool> {
964        if left.is_null() {
965            return Ok(right.is_null());
966        }
967
968        if right.is_null() {
969            return Ok(false);
970        }
971
972        jvm.invoke_virtual(left, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (right.clone(),))
973            .await
974    }
975
976    async fn copy_to_array(jvm: &Jvm, source: &ClassInstanceRef<Array<Object>>, len: i32) -> Result<ClassInstanceRef<Array<Object>>> {
977        if source.is_null() {
978            return Err(jvm.exception("java/lang/NullPointerException", "source").await);
979        }
980
981        if len < 0 {
982            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "negative length").await);
983        }
984
985        let len = len as usize;
986        let elements: Vec<ClassInstanceRef<Object>> = if len == 0 { Vec::new() } else { jvm.load_array(source, 0, len).await? };
987        let mut copy: ClassInstanceRef<Array<Object>> = jvm.instantiate_array("Ljava/lang/Object;", len).await?.into();
988        if !elements.is_empty() {
989            jvm.store_array(&mut copy, 0, elements).await?;
990        }
991
992        Ok(copy)
993    }
994}