1use alloc::vec;
2use core::cmp::Ordering;
3
4use jvm::{Array, ClassInstanceRef, JavaChar, JavaValue, Jvm, Result};
5use jvm_class_proto::JavaMethodProto;
6use jvm_types::{ClassAccessFlags, MethodAccessFlags};
7
8use crate::{RuntimeClassProto, RuntimeContext, classes::java::lang::Object};
9
10macro_rules! primitive_sort_methods {
11 ($whole:ident, $range:ident, $ty:ty, $compare:expr) => {
12 async fn $whole(jvm: &Jvm, _: &mut RuntimeContext, array: ClassInstanceRef<Array<$ty>>) -> Result<()> {
13 if array.is_null() {
14 return Err(jvm.exception("java/lang/NullPointerException", "array").await);
15 }
16 let length = jvm.array_length(&array).await?;
17 Self::sort_primitive(jvm, array, 0, length, $compare).await
18 }
19
20 async fn $range(jvm: &Jvm, _: &mut RuntimeContext, array: ClassInstanceRef<Array<$ty>>, from_index: i32, to_index: i32) -> Result<()> {
21 let (from_index, to_index) = Self::checked_range(jvm, &array, from_index, to_index).await?;
22 Self::sort_primitive(jvm, array, from_index, to_index, $compare).await
23 }
24 };
25}
26
27macro_rules! primitive_binary_search_method {
28 ($name:ident, $ty:ty, $compare:expr) => {
29 async fn $name(jvm: &Jvm, _: &mut RuntimeContext, array: ClassInstanceRef<Array<$ty>>, key: $ty) -> Result<i32> {
30 if array.is_null() {
31 return Err(jvm.exception("java/lang/NullPointerException", "array").await);
32 }
33 let length = jvm.array_length(&array).await?;
34 let values = jvm.load_array::<$ty>(&array, 0, length).await?;
35 Ok(Self::binary_search_primitive(&values, &key, $compare))
36 }
37 };
38}
39
40macro_rules! primitive_equals_method {
41 ($name:ident, $ty:ty) => {
42 async fn $name(jvm: &Jvm, _: &mut RuntimeContext, first: ClassInstanceRef<Array<$ty>>, second: ClassInstanceRef<Array<$ty>>) -> Result<bool> {
43 if first.is_null() || second.is_null() {
44 return Ok(first.is_null() && second.is_null());
45 }
46 let first_length = jvm.array_length(&first).await?;
47 if first_length != jvm.array_length(&second).await? {
48 return Ok(false);
49 }
50 Ok(jvm.load_array::<$ty>(&first, 0, first_length).await? == jvm.load_array::<$ty>(&second, 0, first_length).await?)
51 }
52 };
53}
54
55macro_rules! primitive_fill_methods {
56 ($whole:ident, $range:ident, $ty:ty) => {
57 async fn $whole(jvm: &Jvm, _: &mut RuntimeContext, mut array: ClassInstanceRef<Array<$ty>>, value: $ty) -> Result<()> {
58 if array.is_null() {
59 return Err(jvm.exception("java/lang/NullPointerException", "array").await);
60 }
61 let length = jvm.array_length(&array).await?;
62 if length != 0 {
63 jvm.store_array(&mut array, 0, vec![value; length]).await?;
64 }
65 Ok(())
66 }
67
68 async fn $range(
69 jvm: &Jvm,
70 _: &mut RuntimeContext,
71 mut array: ClassInstanceRef<Array<$ty>>,
72 from_index: i32,
73 to_index: i32,
74 value: $ty,
75 ) -> Result<()> {
76 let (from_index, to_index) = Self::checked_range(jvm, &array, from_index, to_index).await?;
77 if from_index != to_index {
78 jvm.store_array(&mut array, from_index, vec![value; to_index - from_index]).await?;
79 }
80 Ok(())
81 }
82 };
83}
84
85pub struct Arrays;
87
88impl Arrays {
89 pub fn as_proto() -> RuntimeClassProto {
90 RuntimeClassProto {
91 name: "java/util/Arrays",
92 parent_class: Some("java/lang/Object"),
93 interfaces: vec![],
94 methods: vec![
95 JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PRIVATE),
96 JavaMethodProto::new("sort", "([B)V", Self::sort_byte, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
97 JavaMethodProto::new(
98 "sort",
99 "([BII)V",
100 Self::sort_byte_range,
101 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
102 ),
103 JavaMethodProto::new("sort", "([C)V", Self::sort_char, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
104 JavaMethodProto::new(
105 "sort",
106 "([CII)V",
107 Self::sort_char_range,
108 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
109 ),
110 JavaMethodProto::new("sort", "([S)V", Self::sort_short, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
111 JavaMethodProto::new(
112 "sort",
113 "([SII)V",
114 Self::sort_short_range,
115 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
116 ),
117 JavaMethodProto::new("sort", "([I)V", Self::sort_int, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
118 JavaMethodProto::new(
119 "sort",
120 "([III)V",
121 Self::sort_int_range,
122 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
123 ),
124 JavaMethodProto::new("sort", "([J)V", Self::sort_long, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
125 JavaMethodProto::new(
126 "sort",
127 "([JII)V",
128 Self::sort_long_range,
129 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
130 ),
131 JavaMethodProto::new("sort", "([F)V", Self::sort_float, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
132 JavaMethodProto::new(
133 "sort",
134 "([FII)V",
135 Self::sort_float_range,
136 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
137 ),
138 JavaMethodProto::new("sort", "([D)V", Self::sort_double, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
139 JavaMethodProto::new(
140 "sort",
141 "([DII)V",
142 Self::sort_double_range,
143 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
144 ),
145 JavaMethodProto::new(
146 "sort",
147 "([Ljava/lang/Object;)V",
148 Self::sort_object,
149 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
150 ),
151 JavaMethodProto::new(
152 "sort",
153 "([Ljava/lang/Object;II)V",
154 Self::sort_object_range,
155 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
156 ),
157 JavaMethodProto::new(
158 "sort",
159 "([Ljava/lang/Object;Ljava/util/Comparator;)V",
160 Self::sort_object_comparator,
161 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
162 ),
163 JavaMethodProto::new(
164 "sort",
165 "([Ljava/lang/Object;IILjava/util/Comparator;)V",
166 Self::sort_object_range_comparator,
167 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
168 ),
169 JavaMethodProto::new(
170 "binarySearch",
171 "([BB)I",
172 Self::binary_search_byte,
173 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
174 ),
175 JavaMethodProto::new(
176 "binarySearch",
177 "([CC)I",
178 Self::binary_search_char,
179 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
180 ),
181 JavaMethodProto::new(
182 "binarySearch",
183 "([SS)I",
184 Self::binary_search_short,
185 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
186 ),
187 JavaMethodProto::new(
188 "binarySearch",
189 "([II)I",
190 Self::binary_search_int,
191 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
192 ),
193 JavaMethodProto::new(
194 "binarySearch",
195 "([JJ)I",
196 Self::binary_search_long,
197 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
198 ),
199 JavaMethodProto::new(
200 "binarySearch",
201 "([FF)I",
202 Self::binary_search_float,
203 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
204 ),
205 JavaMethodProto::new(
206 "binarySearch",
207 "([DD)I",
208 Self::binary_search_double,
209 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
210 ),
211 JavaMethodProto::new(
212 "binarySearch",
213 "([Ljava/lang/Object;Ljava/lang/Object;)I",
214 Self::binary_search_object,
215 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
216 ),
217 JavaMethodProto::new(
218 "binarySearch",
219 "([Ljava/lang/Object;Ljava/lang/Object;Ljava/util/Comparator;)I",
220 Self::binary_search_object_comparator,
221 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
222 ),
223 JavaMethodProto::new(
224 "equals",
225 "([Z[Z)Z",
226 Self::equals_boolean,
227 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
228 ),
229 JavaMethodProto::new(
230 "equals",
231 "([B[B)Z",
232 Self::equals_byte,
233 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
234 ),
235 JavaMethodProto::new(
236 "equals",
237 "([C[C)Z",
238 Self::equals_char,
239 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
240 ),
241 JavaMethodProto::new(
242 "equals",
243 "([S[S)Z",
244 Self::equals_short,
245 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
246 ),
247 JavaMethodProto::new(
248 "equals",
249 "([I[I)Z",
250 Self::equals_int,
251 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
252 ),
253 JavaMethodProto::new(
254 "equals",
255 "([J[J)Z",
256 Self::equals_long,
257 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
258 ),
259 JavaMethodProto::new(
260 "equals",
261 "([F[F)Z",
262 Self::equals_float,
263 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
264 ),
265 JavaMethodProto::new(
266 "equals",
267 "([D[D)Z",
268 Self::equals_double,
269 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
270 ),
271 JavaMethodProto::new(
272 "equals",
273 "([Ljava/lang/Object;[Ljava/lang/Object;)Z",
274 Self::equals_object,
275 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
276 ),
277 JavaMethodProto::new(
278 "fill",
279 "([ZZ)V",
280 Self::fill_boolean,
281 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
282 ),
283 JavaMethodProto::new(
284 "fill",
285 "([ZIIZ)V",
286 Self::fill_boolean_range,
287 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
288 ),
289 JavaMethodProto::new("fill", "([BB)V", Self::fill_byte, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
290 JavaMethodProto::new(
291 "fill",
292 "([BIIB)V",
293 Self::fill_byte_range,
294 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
295 ),
296 JavaMethodProto::new("fill", "([CC)V", Self::fill_char, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
297 JavaMethodProto::new(
298 "fill",
299 "([CIIC)V",
300 Self::fill_char_range,
301 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
302 ),
303 JavaMethodProto::new("fill", "([SS)V", Self::fill_short, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
304 JavaMethodProto::new(
305 "fill",
306 "([SIIS)V",
307 Self::fill_short_range,
308 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
309 ),
310 JavaMethodProto::new("fill", "([II)V", Self::fill_int, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
311 JavaMethodProto::new(
312 "fill",
313 "([IIII)V",
314 Self::fill_int_range,
315 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
316 ),
317 JavaMethodProto::new("fill", "([JJ)V", Self::fill_long, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
318 JavaMethodProto::new(
319 "fill",
320 "([JIIJ)V",
321 Self::fill_long_range,
322 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
323 ),
324 JavaMethodProto::new("fill", "([FF)V", Self::fill_float, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
325 JavaMethodProto::new(
326 "fill",
327 "([FIIF)V",
328 Self::fill_float_range,
329 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
330 ),
331 JavaMethodProto::new("fill", "([DD)V", Self::fill_double, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
332 JavaMethodProto::new(
333 "fill",
334 "([DIID)V",
335 Self::fill_double_range,
336 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
337 ),
338 JavaMethodProto::new(
339 "fill",
340 "([Ljava/lang/Object;Ljava/lang/Object;)V",
341 Self::fill_object,
342 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
343 ),
344 JavaMethodProto::new(
345 "fill",
346 "([Ljava/lang/Object;IILjava/lang/Object;)V",
347 Self::fill_object_range,
348 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
349 ),
350 JavaMethodProto::new(
351 "asList",
352 "([Ljava/lang/Object;)Ljava/util/List;",
353 Self::as_list,
354 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
355 ),
356 ],
357 fields: vec![],
358 access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::FINAL,
359 }
360 }
361
362 async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
363 jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await
364 }
365
366 async fn checked_range<T>(jvm: &Jvm, array: &ClassInstanceRef<Array<T>>, from_index: i32, to_index: i32) -> Result<(usize, usize)> {
367 if array.is_null() {
368 return Err(jvm.exception("java/lang/NullPointerException", "array").await);
369 }
370 if from_index > to_index {
371 return Err(jvm.exception("java/lang/IllegalArgumentException", "fromIndex > toIndex").await);
372 }
373 let length = jvm.array_length(array).await?;
374 if from_index < 0 || to_index < 0 || to_index as usize > length {
375 return Err(jvm.exception("java/lang/ArrayIndexOutOfBoundsException", "array range").await);
376 }
377 Ok((from_index as usize, to_index as usize))
378 }
379
380 async fn sort_primitive<T, F>(jvm: &Jvm, mut array: ClassInstanceRef<Array<T>>, from_index: usize, to_index: usize, mut compare: F) -> Result<()>
381 where
382 T: From<JavaValue> + Into<JavaValue> + Send,
383 F: FnMut(&T, &T) -> Ordering + Send,
384 {
385 let mut values = jvm.load_array::<T>(&array, from_index, to_index - from_index).await?;
386 values.sort_by(|left, right| compare(left, right));
387 if !values.is_empty() {
388 jvm.store_array(&mut array, from_index, values).await?;
389 }
390 Ok(())
391 }
392
393 fn float_order(left: &f32, right: &f32) -> Ordering {
394 if left < right {
395 Ordering::Less
396 } else if left > right {
397 Ordering::Greater
398 } else {
399 let left_bits = if left.is_nan() { 0x7fc0_0000 } else { left.to_bits() } as i32;
400 let right_bits = if right.is_nan() { 0x7fc0_0000 } else { right.to_bits() } as i32;
401 left_bits.cmp(&right_bits)
402 }
403 }
404
405 fn double_order(left: &f64, right: &f64) -> Ordering {
406 if left < right {
407 Ordering::Less
408 } else if left > right {
409 Ordering::Greater
410 } else {
411 let left_bits = if left.is_nan() { 0x7ff8_0000_0000_0000 } else { left.to_bits() } as i64;
412 let right_bits = if right.is_nan() { 0x7ff8_0000_0000_0000 } else { right.to_bits() } as i64;
413 left_bits.cmp(&right_bits)
414 }
415 }
416
417 primitive_sort_methods!(sort_byte, sort_byte_range, i8, Ord::cmp);
418 primitive_sort_methods!(sort_char, sort_char_range, JavaChar, Ord::cmp);
419 primitive_sort_methods!(sort_short, sort_short_range, i16, Ord::cmp);
420 primitive_sort_methods!(sort_int, sort_int_range, i32, Ord::cmp);
421 primitive_sort_methods!(sort_long, sort_long_range, i64, Ord::cmp);
422 primitive_sort_methods!(sort_float, sort_float_range, f32, Self::float_order);
423 primitive_sort_methods!(sort_double, sort_double_range, f64, Self::double_order);
424
425 async fn compare_objects(
426 jvm: &Jvm,
427 comparator: &ClassInstanceRef<Object>,
428 left: &ClassInstanceRef<Object>,
429 right: &ClassInstanceRef<Object>,
430 ) -> Result<i32> {
431 if comparator.is_null() {
432 if left.is_null() {
433 return Err(jvm.exception("java/lang/NullPointerException", "array element").await);
434 }
435 if !jvm.is_instance(left.as_ref(), "java/lang/Comparable") {
436 return Err(jvm.exception("java/lang/ClassCastException", &left.class_definition().name()).await);
437 }
438 jvm.invoke_virtual(
439 left,
440 &left.class_definition().name(),
441 "compareTo",
442 "(Ljava/lang/Object;)I",
443 (right.clone(),),
444 )
445 .await
446 } else {
447 jvm.invoke_virtual(
448 comparator,
449 &comparator.class_definition().name(),
450 "compare",
451 "(Ljava/lang/Object;Ljava/lang/Object;)I",
452 (left.clone(), right.clone()),
453 )
454 .await
455 }
456 }
457
458 async fn sort_objects(
459 jvm: &Jvm,
460 mut array: ClassInstanceRef<Array<Object>>,
461 from_index: usize,
462 to_index: usize,
463 comparator: ClassInstanceRef<Object>,
464 ) -> Result<()> {
465 let mut source = jvm
466 .load_array::<ClassInstanceRef<Object>>(&array, from_index, to_index - from_index)
467 .await?;
468 let length = source.len();
469 let mut target = source.clone();
470 let mut width = 1usize;
471
472 while width < length {
473 let mut start = 0usize;
474 while start < length {
475 let middle = core::cmp::min(start + width, length);
476 let end = core::cmp::min(start + width.saturating_mul(2), length);
477 let mut left = start;
478 let mut right = middle;
479 let mut output = start;
480
481 while left < middle && right < end {
482 if Self::compare_objects(jvm, &comparator, &source[left], &source[right]).await? <= 0 {
483 target[output] = source[left].clone();
484 left += 1;
485 } else {
486 target[output] = source[right].clone();
487 right += 1;
488 }
489 output += 1;
490 }
491 while left < middle {
492 target[output] = source[left].clone();
493 left += 1;
494 output += 1;
495 }
496 while right < end {
497 target[output] = source[right].clone();
498 right += 1;
499 output += 1;
500 }
501 start = end;
502 }
503 core::mem::swap(&mut source, &mut target);
504 width = width.saturating_mul(2);
505 }
506
507 if !source.is_empty() {
508 jvm.store_array(&mut array, from_index, source).await?;
509 }
510 Ok(())
511 }
512
513 async fn sort_object(jvm: &Jvm, _: &mut RuntimeContext, array: ClassInstanceRef<Array<Object>>) -> Result<()> {
514 if array.is_null() {
515 return Err(jvm.exception("java/lang/NullPointerException", "array").await);
516 }
517 let length = jvm.array_length(&array).await?;
518 Self::sort_objects(jvm, array, 0, length, None.into()).await
519 }
520
521 async fn sort_object_range(
522 jvm: &Jvm,
523 _: &mut RuntimeContext,
524 array: ClassInstanceRef<Array<Object>>,
525 from_index: i32,
526 to_index: i32,
527 ) -> Result<()> {
528 let (from_index, to_index) = Self::checked_range(jvm, &array, from_index, to_index).await?;
529 Self::sort_objects(jvm, array, from_index, to_index, None.into()).await
530 }
531
532 async fn sort_object_comparator(
533 jvm: &Jvm,
534 _: &mut RuntimeContext,
535 array: ClassInstanceRef<Array<Object>>,
536 comparator: ClassInstanceRef<Object>,
537 ) -> Result<()> {
538 if array.is_null() {
539 return Err(jvm.exception("java/lang/NullPointerException", "array").await);
540 }
541 let length = jvm.array_length(&array).await?;
542 Self::sort_objects(jvm, array, 0, length, comparator).await
543 }
544
545 async fn sort_object_range_comparator(
546 jvm: &Jvm,
547 _: &mut RuntimeContext,
548 array: ClassInstanceRef<Array<Object>>,
549 from_index: i32,
550 to_index: i32,
551 comparator: ClassInstanceRef<Object>,
552 ) -> Result<()> {
553 let (from_index, to_index) = Self::checked_range(jvm, &array, from_index, to_index).await?;
554 Self::sort_objects(jvm, array, from_index, to_index, comparator).await
555 }
556
557 fn binary_search_primitive<T, F>(values: &[T], key: &T, mut compare: F) -> i32
558 where
559 F: FnMut(&T, &T) -> Ordering,
560 {
561 let mut low = 0usize;
562 let mut high = values.len();
563 while low < high {
564 let middle = low + (high - low) / 2;
565 match compare(&values[middle], key) {
566 Ordering::Less => low = middle + 1,
567 Ordering::Greater => high = middle,
568 Ordering::Equal => return middle as i32,
569 }
570 }
571 -(low as i32) - 1
572 }
573
574 primitive_binary_search_method!(binary_search_byte, i8, Ord::cmp);
575 primitive_binary_search_method!(binary_search_char, JavaChar, Ord::cmp);
576 primitive_binary_search_method!(binary_search_short, i16, Ord::cmp);
577 primitive_binary_search_method!(binary_search_int, i32, Ord::cmp);
578 primitive_binary_search_method!(binary_search_long, i64, Ord::cmp);
579 primitive_binary_search_method!(binary_search_float, f32, Self::float_order);
580 primitive_binary_search_method!(binary_search_double, f64, Self::double_order);
581
582 async fn binary_search_objects(
583 jvm: &Jvm,
584 array: ClassInstanceRef<Array<Object>>,
585 key: ClassInstanceRef<Object>,
586 comparator: ClassInstanceRef<Object>,
587 ) -> Result<i32> {
588 if array.is_null() {
589 return Err(jvm.exception("java/lang/NullPointerException", "array").await);
590 }
591 let length = jvm.array_length(&array).await?;
592 let values = jvm.load_array::<ClassInstanceRef<Object>>(&array, 0, length).await?;
593 let mut low = 0usize;
594 let mut high = length;
595 while low < high {
596 let middle = low + (high - low) / 2;
597 let comparison = Self::compare_objects(jvm, &comparator, &values[middle], &key).await?;
598 if comparison < 0 {
599 low = middle + 1;
600 } else if comparison > 0 {
601 high = middle;
602 } else {
603 return Ok(middle as i32);
604 }
605 }
606 Ok(-(low as i32) - 1)
607 }
608
609 async fn binary_search_object(
610 jvm: &Jvm,
611 _: &mut RuntimeContext,
612 array: ClassInstanceRef<Array<Object>>,
613 key: ClassInstanceRef<Object>,
614 ) -> Result<i32> {
615 Self::binary_search_objects(jvm, array, key, None.into()).await
616 }
617
618 async fn binary_search_object_comparator(
619 jvm: &Jvm,
620 _: &mut RuntimeContext,
621 array: ClassInstanceRef<Array<Object>>,
622 key: ClassInstanceRef<Object>,
623 comparator: ClassInstanceRef<Object>,
624 ) -> Result<i32> {
625 Self::binary_search_objects(jvm, array, key, comparator).await
626 }
627
628 primitive_equals_method!(equals_boolean, bool);
629 primitive_equals_method!(equals_byte, i8);
630 primitive_equals_method!(equals_char, JavaChar);
631 primitive_equals_method!(equals_short, i16);
632 primitive_equals_method!(equals_int, i32);
633 primitive_equals_method!(equals_long, i64);
634
635 async fn equals_float(
636 jvm: &Jvm,
637 _: &mut RuntimeContext,
638 first: ClassInstanceRef<Array<f32>>,
639 second: ClassInstanceRef<Array<f32>>,
640 ) -> Result<bool> {
641 if first.is_null() || second.is_null() {
642 return Ok(first.is_null() && second.is_null());
643 }
644 let length = jvm.array_length(&first).await?;
645 if length != jvm.array_length(&second).await? {
646 return Ok(false);
647 }
648 let first_values = jvm.load_array::<f32>(&first, 0, length).await?;
649 let second_values = jvm.load_array::<f32>(&second, 0, length).await?;
650 Ok(first_values.iter().zip(second_values).all(|(left, right)| {
651 let left_bits = if left.is_nan() { 0x7fc0_0000 } else { left.to_bits() };
652 let right_bits = if right.is_nan() { 0x7fc0_0000 } else { right.to_bits() };
653 left_bits == right_bits
654 }))
655 }
656
657 async fn equals_double(
658 jvm: &Jvm,
659 _: &mut RuntimeContext,
660 first: ClassInstanceRef<Array<f64>>,
661 second: ClassInstanceRef<Array<f64>>,
662 ) -> Result<bool> {
663 if first.is_null() || second.is_null() {
664 return Ok(first.is_null() && second.is_null());
665 }
666 let length = jvm.array_length(&first).await?;
667 if length != jvm.array_length(&second).await? {
668 return Ok(false);
669 }
670 let first_values = jvm.load_array::<f64>(&first, 0, length).await?;
671 let second_values = jvm.load_array::<f64>(&second, 0, length).await?;
672 Ok(first_values.iter().zip(second_values).all(|(left, right)| {
673 let left_bits = if left.is_nan() { 0x7ff8_0000_0000_0000 } else { left.to_bits() };
674 let right_bits = if right.is_nan() { 0x7ff8_0000_0000_0000 } else { right.to_bits() };
675 left_bits == right_bits
676 }))
677 }
678
679 async fn equals_object(
680 jvm: &Jvm,
681 _: &mut RuntimeContext,
682 first: ClassInstanceRef<Array<Object>>,
683 second: ClassInstanceRef<Array<Object>>,
684 ) -> Result<bool> {
685 if first.is_null() || second.is_null() {
686 return Ok(first.is_null() && second.is_null());
687 }
688 let length = jvm.array_length(&first).await?;
689 if length != jvm.array_length(&second).await? {
690 return Ok(false);
691 }
692 let first_values = jvm.load_array::<ClassInstanceRef<Object>>(&first, 0, length).await?;
693 let second_values = jvm.load_array::<ClassInstanceRef<Object>>(&second, 0, length).await?;
694 for (left, right) in first_values.into_iter().zip(second_values) {
695 if left.is_null() {
696 if !right.is_null() {
697 return Ok(false);
698 }
699 } else if !jvm
700 .invoke_virtual::<_, bool>(&left, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (right,))
701 .await?
702 {
703 return Ok(false);
704 }
705 }
706 Ok(true)
707 }
708
709 primitive_fill_methods!(fill_boolean, fill_boolean_range, bool);
710 primitive_fill_methods!(fill_byte, fill_byte_range, i8);
711 primitive_fill_methods!(fill_char, fill_char_range, JavaChar);
712 primitive_fill_methods!(fill_short, fill_short_range, i16);
713 primitive_fill_methods!(fill_int, fill_int_range, i32);
714 primitive_fill_methods!(fill_long, fill_long_range, i64);
715 primitive_fill_methods!(fill_float, fill_float_range, f32);
716 primitive_fill_methods!(fill_double, fill_double_range, f64);
717
718 async fn fill_object(jvm: &Jvm, _: &mut RuntimeContext, array: ClassInstanceRef<Array<Object>>, value: ClassInstanceRef<Object>) -> Result<()> {
719 if array.is_null() {
720 return Err(jvm.exception("java/lang/NullPointerException", "array").await);
721 }
722 let length = jvm.array_length(&array).await?;
723 Self::fill_objects(jvm, array, 0, length, value).await
724 }
725
726 async fn fill_object_range(
727 jvm: &Jvm,
728 _: &mut RuntimeContext,
729 array: ClassInstanceRef<Array<Object>>,
730 from_index: i32,
731 to_index: i32,
732 value: ClassInstanceRef<Object>,
733 ) -> Result<()> {
734 let (from_index, to_index) = Self::checked_range(jvm, &array, from_index, to_index).await?;
735 Self::fill_objects(jvm, array, from_index, to_index, value).await
736 }
737
738 async fn fill_objects(
739 jvm: &Jvm,
740 mut array: ClassInstanceRef<Array<Object>>,
741 from_index: usize,
742 to_index: usize,
743 value: ClassInstanceRef<Object>,
744 ) -> Result<()> {
745 for index in from_index..to_index {
746 if !value.is_null() && !jvm.array_store_allowed(array.as_ref(), value.as_ref()) {
747 return Err(jvm.exception("java/lang/ArrayStoreException", &value.class_definition().name()).await);
748 }
749 jvm.store_array(&mut array, index, core::iter::once(value.clone())).await?;
750 }
751 Ok(())
752 }
753
754 async fn as_list(jvm: &Jvm, _: &mut RuntimeContext, array: ClassInstanceRef<Array<Object>>) -> Result<ClassInstanceRef<Object>> {
755 if array.is_null() {
756 return Err(jvm.exception("java/lang/NullPointerException", "array").await);
757 }
758 Ok(jvm
759 .new_class("java/util/Arrays$ArrayList", "([Ljava/lang/Object;)V", (array,))
760 .await?
761 .into())
762 }
763}