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
17pub 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}