Skip to main content

rustjava_runtime/classes/java/util/
arrays.rs

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
85// public final class java.util.Arrays
86pub 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}