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, "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}