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