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