Skip to main content

rustjava_runtime/classes/java/util/
collections.rs

1use alloc::vec;
2
3use jvm::{Array, ClassInstanceRef, Jvm, Result};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{RuntimeClassProto, RuntimeContext, classes::java::lang::Object};
8
9// class java.util.Collections
10pub struct Collections;
11
12impl Collections {
13    pub fn as_proto() -> RuntimeClassProto {
14        RuntimeClassProto {
15            name: "java/util/Collections",
16            parent_class: Some("java/lang/Object"),
17            interfaces: vec![],
18            methods: vec![
19                JavaMethodProto::new("<clinit>", "()V", Self::clinit, MethodAccessFlags::STATIC),
20                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PRIVATE),
21                JavaMethodProto::new(
22                    "sort",
23                    "(Ljava/util/List;)V",
24                    Self::sort,
25                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
26                ),
27                JavaMethodProto::new(
28                    "sort",
29                    "(Ljava/util/List;Ljava/util/Comparator;)V",
30                    Self::sort_comparator,
31                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
32                ),
33                JavaMethodProto::new(
34                    "binarySearch",
35                    "(Ljava/util/List;Ljava/lang/Object;)I",
36                    Self::binary_search,
37                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
38                ),
39                JavaMethodProto::new(
40                    "binarySearch",
41                    "(Ljava/util/List;Ljava/lang/Object;Ljava/util/Comparator;)I",
42                    Self::binary_search_comparator,
43                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
44                ),
45                JavaMethodProto::new(
46                    "reverse",
47                    "(Ljava/util/List;)V",
48                    Self::reverse,
49                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
50                ),
51                JavaMethodProto::new(
52                    "fill",
53                    "(Ljava/util/List;Ljava/lang/Object;)V",
54                    Self::fill,
55                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
56                ),
57                JavaMethodProto::new(
58                    "copy",
59                    "(Ljava/util/List;Ljava/util/List;)V",
60                    Self::copy,
61                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
62                ),
63                JavaMethodProto::new(
64                    "shuffle",
65                    "(Ljava/util/List;)V",
66                    Self::shuffle,
67                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
68                ),
69                JavaMethodProto::new(
70                    "shuffle",
71                    "(Ljava/util/List;Ljava/util/Random;)V",
72                    Self::shuffle_random,
73                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
74                ),
75                JavaMethodProto::new(
76                    "min",
77                    "(Ljava/util/Collection;)Ljava/lang/Object;",
78                    Self::min,
79                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
80                ),
81                JavaMethodProto::new(
82                    "min",
83                    "(Ljava/util/Collection;Ljava/util/Comparator;)Ljava/lang/Object;",
84                    Self::min_comparator,
85                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
86                ),
87                JavaMethodProto::new(
88                    "max",
89                    "(Ljava/util/Collection;)Ljava/lang/Object;",
90                    Self::max,
91                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
92                ),
93                JavaMethodProto::new(
94                    "max",
95                    "(Ljava/util/Collection;Ljava/util/Comparator;)Ljava/lang/Object;",
96                    Self::max_comparator,
97                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
98                ),
99                JavaMethodProto::new(
100                    "nCopies",
101                    "(ILjava/lang/Object;)Ljava/util/List;",
102                    Self::n_copies,
103                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
104                ),
105                JavaMethodProto::new(
106                    "singleton",
107                    "(Ljava/lang/Object;)Ljava/util/Set;",
108                    Self::singleton,
109                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
110                ),
111                JavaMethodProto::new(
112                    "unmodifiableCollection",
113                    "(Ljava/util/Collection;)Ljava/util/Collection;",
114                    Self::unmodifiable_collection,
115                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
116                ),
117                JavaMethodProto::new(
118                    "unmodifiableList",
119                    "(Ljava/util/List;)Ljava/util/List;",
120                    Self::unmodifiable_list,
121                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
122                ),
123                JavaMethodProto::new(
124                    "unmodifiableSet",
125                    "(Ljava/util/Set;)Ljava/util/Set;",
126                    Self::unmodifiable_set,
127                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
128                ),
129                JavaMethodProto::new(
130                    "unmodifiableMap",
131                    "(Ljava/util/Map;)Ljava/util/Map;",
132                    Self::unmodifiable_map,
133                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
134                ),
135                JavaMethodProto::new(
136                    "unmodifiableSortedSet",
137                    "(Ljava/util/SortedSet;)Ljava/util/SortedSet;",
138                    Self::unmodifiable_sorted_set,
139                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
140                ),
141                JavaMethodProto::new(
142                    "unmodifiableSortedMap",
143                    "(Ljava/util/SortedMap;)Ljava/util/SortedMap;",
144                    Self::unmodifiable_sorted_map,
145                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
146                ),
147            ],
148            fields: vec![
149                JavaFieldProto::new(
150                    "EMPTY_LIST",
151                    "Ljava/util/List;",
152                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
153                ),
154                JavaFieldProto::new(
155                    "EMPTY_SET",
156                    "Ljava/util/Set;",
157                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
158                ),
159                JavaFieldProto::new("r", "Ljava/util/Random;", FieldAccessFlags::PRIVATE | FieldAccessFlags::STATIC),
160            ],
161            access_flags: ClassAccessFlags::PUBLIC,
162        }
163    }
164
165    async fn clinit(jvm: &Jvm, _: &mut RuntimeContext) -> Result<()> {
166        let empty_list = jvm.new_class("java/util/Collections$EmptyList", "()V", ()).await?;
167        jvm.put_static_field("java/util/Collections", "EMPTY_LIST", "Ljava/util/List;", empty_list)
168            .await?;
169
170        let empty_set = jvm.new_class("java/util/Collections$EmptySet", "()V", ()).await?;
171        jvm.put_static_field("java/util/Collections", "EMPTY_SET", "Ljava/util/Set;", empty_set)
172            .await?;
173
174        let random = jvm.new_class("java/util/Random", "()V", ()).await?;
175        jvm.put_static_field("java/util/Collections", "r", "Ljava/util/Random;", random).await
176    }
177
178    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
179        jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await
180    }
181
182    async fn compare(
183        jvm: &Jvm,
184        comparator: &ClassInstanceRef<Object>,
185        left: &ClassInstanceRef<Object>,
186        right: &ClassInstanceRef<Object>,
187    ) -> Result<i32> {
188        if comparator.is_null() {
189            if left.is_null() {
190                return Err(jvm.exception("java/lang/NullPointerException", "collection element").await);
191            }
192            if !jvm.is_instance(left.as_ref(), "java/lang/Comparable") {
193                return Err(jvm.exception("java/lang/ClassCastException", &left.class_definition().name()).await);
194            }
195            jvm.invoke_virtual(
196                left,
197                &left.class_definition().name(),
198                "compareTo",
199                "(Ljava/lang/Object;)I",
200                (right.clone(),),
201            )
202            .await
203        } else {
204            jvm.invoke_virtual(
205                comparator,
206                &comparator.class_definition().name(),
207                "compare",
208                "(Ljava/lang/Object;Ljava/lang/Object;)I",
209                (left.clone(), right.clone()),
210            )
211            .await
212        }
213    }
214
215    async fn write_list(jvm: &Jvm, list: &ClassInstanceRef<Object>, elements: ClassInstanceRef<Array<Object>>) -> Result<()> {
216        let length = jvm.array_length(&elements).await?;
217        let iterator: ClassInstanceRef<Object> = jvm
218            .invoke_virtual(list, &list.class_definition().name(), "listIterator", "()Ljava/util/ListIterator;", ())
219            .await?;
220        for element in jvm.load_array::<ClassInstanceRef<Object>>(&elements, 0, length).await? {
221            let _: ClassInstanceRef<Object> = jvm
222                .invoke_virtual(&iterator, &iterator.class_definition().name(), "next", "()Ljava/lang/Object;", ())
223                .await?;
224            let _: () = jvm
225                .invoke_virtual(&iterator, &iterator.class_definition().name(), "set", "(Ljava/lang/Object;)V", (element,))
226                .await?;
227        }
228        Ok(())
229    }
230
231    async fn sort_values(jvm: &Jvm, list: ClassInstanceRef<Object>, comparator: ClassInstanceRef<Object>) -> Result<()> {
232        if list.is_null() {
233            return Err(jvm.exception("java/lang/NullPointerException", "list").await);
234        }
235
236        let elements: ClassInstanceRef<Array<Object>> = jvm
237            .invoke_virtual(&list, &list.class_definition().name(), "toArray", "()[Ljava/lang/Object;", ())
238            .await?;
239        if comparator.is_null() {
240            let _: () = jvm
241                .invoke_static("java/util/Arrays", "sort", "([Ljava/lang/Object;)V", (elements.clone(),))
242                .await?;
243        } else {
244            let _: () = jvm
245                .invoke_static(
246                    "java/util/Arrays",
247                    "sort",
248                    "([Ljava/lang/Object;Ljava/util/Comparator;)V",
249                    (elements.clone(), comparator),
250                )
251                .await?;
252        }
253
254        Self::write_list(jvm, &list, elements).await
255    }
256
257    async fn sort(jvm: &Jvm, _: &mut RuntimeContext, list: ClassInstanceRef<Object>) -> Result<()> {
258        Self::sort_values(jvm, list, None.into()).await
259    }
260
261    async fn sort_comparator(jvm: &Jvm, _: &mut RuntimeContext, list: ClassInstanceRef<Object>, comparator: ClassInstanceRef<Object>) -> Result<()> {
262        Self::sort_values(jvm, list, comparator).await
263    }
264
265    async fn search(jvm: &Jvm, list: ClassInstanceRef<Object>, key: ClassInstanceRef<Object>, comparator: ClassInstanceRef<Object>) -> Result<i32> {
266        if list.is_null() {
267            return Err(jvm.exception("java/lang/NullPointerException", "list").await);
268        }
269
270        let mut low = 0i32;
271        let mut high: i32 = jvm.invoke_virtual(&list, &list.class_definition().name(), "size", "()I", ()).await?;
272        while low < high {
273            let middle = low + (high - low) / 2;
274            let value: ClassInstanceRef<Object> = jvm
275                .invoke_virtual(&list, &list.class_definition().name(), "get", "(I)Ljava/lang/Object;", (middle,))
276                .await?;
277            let comparison = Self::compare(jvm, &comparator, &value, &key).await?;
278            if comparison < 0 {
279                low = middle + 1;
280            } else if comparison > 0 {
281                high = middle;
282            } else {
283                return Ok(middle);
284            }
285        }
286        Ok(-low - 1)
287    }
288
289    async fn binary_search(jvm: &Jvm, _: &mut RuntimeContext, list: ClassInstanceRef<Object>, key: ClassInstanceRef<Object>) -> Result<i32> {
290        Self::search(jvm, list, key, None.into()).await
291    }
292
293    async fn binary_search_comparator(
294        jvm: &Jvm,
295        _: &mut RuntimeContext,
296        list: ClassInstanceRef<Object>,
297        key: ClassInstanceRef<Object>,
298        comparator: ClassInstanceRef<Object>,
299    ) -> Result<i32> {
300        Self::search(jvm, list, key, comparator).await
301    }
302
303    async fn reverse(jvm: &Jvm, _: &mut RuntimeContext, list: ClassInstanceRef<Object>) -> Result<()> {
304        if list.is_null() {
305            return Err(jvm.exception("java/lang/NullPointerException", "list").await);
306        }
307
308        let size: i32 = jvm.invoke_virtual(&list, &list.class_definition().name(), "size", "()I", ()).await?;
309        if size < 2 {
310            return Ok(());
311        }
312        let forward: ClassInstanceRef<Object> = jvm
313            .invoke_virtual(&list, &list.class_definition().name(), "listIterator", "()Ljava/util/ListIterator;", ())
314            .await?;
315        let backward: ClassInstanceRef<Object> = jvm
316            .invoke_virtual(
317                &list,
318                &list.class_definition().name(),
319                "listIterator",
320                "(I)Ljava/util/ListIterator;",
321                (size,),
322            )
323            .await?;
324        for _ in 0..size / 2 {
325            let left: ClassInstanceRef<Object> = jvm
326                .invoke_virtual(&forward, &forward.class_definition().name(), "next", "()Ljava/lang/Object;", ())
327                .await?;
328            let right: ClassInstanceRef<Object> = jvm
329                .invoke_virtual(&backward, &backward.class_definition().name(), "previous", "()Ljava/lang/Object;", ())
330                .await?;
331            let _: () = jvm
332                .invoke_virtual(&forward, &forward.class_definition().name(), "set", "(Ljava/lang/Object;)V", (right,))
333                .await?;
334            let _: () = jvm
335                .invoke_virtual(&backward, &backward.class_definition().name(), "set", "(Ljava/lang/Object;)V", (left,))
336                .await?;
337        }
338        Ok(())
339    }
340
341    async fn fill(jvm: &Jvm, _: &mut RuntimeContext, list: ClassInstanceRef<Object>, element: ClassInstanceRef<Object>) -> Result<()> {
342        if list.is_null() {
343            return Err(jvm.exception("java/lang/NullPointerException", "list").await);
344        }
345
346        let iterator: ClassInstanceRef<Object> = jvm
347            .invoke_virtual(&list, &list.class_definition().name(), "listIterator", "()Ljava/util/ListIterator;", ())
348            .await?;
349        while jvm
350            .invoke_virtual::<_, bool>(&iterator, &iterator.class_definition().name(), "hasNext", "()Z", ())
351            .await?
352        {
353            let _: ClassInstanceRef<Object> = jvm
354                .invoke_virtual(&iterator, &iterator.class_definition().name(), "next", "()Ljava/lang/Object;", ())
355                .await?;
356            let _: () = jvm
357                .invoke_virtual(
358                    &iterator,
359                    &iterator.class_definition().name(),
360                    "set",
361                    "(Ljava/lang/Object;)V",
362                    (element.clone(),),
363                )
364                .await?;
365        }
366        Ok(())
367    }
368
369    async fn copy(jvm: &Jvm, _: &mut RuntimeContext, destination: ClassInstanceRef<Object>, source: ClassInstanceRef<Object>) -> Result<()> {
370        if source.is_null() {
371            return Err(jvm.exception("java/lang/NullPointerException", "source").await);
372        }
373        let source_size: i32 = jvm.invoke_virtual(&source, &source.class_definition().name(), "size", "()I", ()).await?;
374        if destination.is_null() {
375            return Err(jvm.exception("java/lang/NullPointerException", "destination").await);
376        }
377        let destination_size: i32 = jvm
378            .invoke_virtual(&destination, &destination.class_definition().name(), "size", "()I", ())
379            .await?;
380        if source_size > destination_size {
381            return Err(jvm
382                .exception("java/lang/IndexOutOfBoundsException", "source does not fit in destination")
383                .await);
384        }
385
386        let elements: ClassInstanceRef<Array<Object>> = jvm
387            .invoke_virtual(&source, &source.class_definition().name(), "toArray", "()[Ljava/lang/Object;", ())
388            .await?;
389        let iterator: ClassInstanceRef<Object> = jvm
390            .invoke_virtual(
391                &destination,
392                &destination.class_definition().name(),
393                "listIterator",
394                "()Ljava/util/ListIterator;",
395                (),
396            )
397            .await?;
398        for element in jvm.load_array::<ClassInstanceRef<Object>>(&elements, 0, source_size as usize).await? {
399            let _: ClassInstanceRef<Object> = jvm
400                .invoke_virtual(&iterator, &iterator.class_definition().name(), "next", "()Ljava/lang/Object;", ())
401                .await?;
402            let _: () = jvm
403                .invoke_virtual(&iterator, &iterator.class_definition().name(), "set", "(Ljava/lang/Object;)V", (element,))
404                .await?;
405        }
406        Ok(())
407    }
408
409    async fn shuffle_values(jvm: &Jvm, list: ClassInstanceRef<Object>, random: ClassInstanceRef<Object>) -> Result<()> {
410        if list.is_null() {
411            return Err(jvm.exception("java/lang/NullPointerException", "list").await);
412        }
413        let elements: ClassInstanceRef<Array<Object>> = jvm
414            .invoke_virtual(&list, &list.class_definition().name(), "toArray", "()[Ljava/lang/Object;", ())
415            .await?;
416        let length = jvm.array_length(&elements).await?;
417        if length < 2 {
418            return Ok(());
419        }
420        if random.is_null() {
421            return Err(jvm.exception("java/lang/NullPointerException", "random").await);
422        }
423        let mut values = jvm.load_array::<ClassInstanceRef<Object>>(&elements, 0, length).await?;
424        for index in (1..length).rev() {
425            let swap_index: i32 = jvm
426                .invoke_virtual(&random, "java/util/Random", "nextInt", "(I)I", ((index + 1) as i32,))
427                .await?;
428            if swap_index < 0 || swap_index as usize > index {
429                return Err(jvm.exception("java/lang/ArrayIndexOutOfBoundsException", "random index").await);
430            }
431            values.swap(index, swap_index as usize);
432        }
433
434        let mut shuffled: ClassInstanceRef<Array<Object>> = jvm.instantiate_array("Ljava/lang/Object;", length).await?.into();
435        if !values.is_empty() {
436            jvm.store_array(&mut shuffled, 0, values).await?;
437        }
438        Self::write_list(jvm, &list, shuffled).await
439    }
440
441    async fn shuffle(jvm: &Jvm, _: &mut RuntimeContext, list: ClassInstanceRef<Object>) -> Result<()> {
442        let random: ClassInstanceRef<Object> = jvm.get_static_field("java/util/Collections", "r", "Ljava/util/Random;").await?;
443        Self::shuffle_values(jvm, list, random).await
444    }
445
446    async fn shuffle_random(jvm: &Jvm, _: &mut RuntimeContext, list: ClassInstanceRef<Object>, random: ClassInstanceRef<Object>) -> Result<()> {
447        Self::shuffle_values(jvm, list, random).await
448    }
449
450    async fn extreme(
451        jvm: &Jvm,
452        collection: ClassInstanceRef<Object>,
453        comparator: ClassInstanceRef<Object>,
454        find_minimum: bool,
455    ) -> Result<ClassInstanceRef<Object>> {
456        if collection.is_null() {
457            return Err(jvm.exception("java/lang/NullPointerException", "collection").await);
458        }
459
460        let iterator: ClassInstanceRef<Object> = jvm
461            .invoke_virtual(
462                &collection,
463                &collection.class_definition().name(),
464                "iterator",
465                "()Ljava/util/Iterator;",
466                (),
467            )
468            .await?;
469        if !jvm
470            .invoke_virtual::<_, bool>(&iterator, &iterator.class_definition().name(), "hasNext", "()Z", ())
471            .await?
472        {
473            return Err(jvm.exception("java/util/NoSuchElementException", "empty collection").await);
474        }
475        let mut candidate: ClassInstanceRef<Object> = jvm
476            .invoke_virtual(&iterator, &iterator.class_definition().name(), "next", "()Ljava/lang/Object;", ())
477            .await?;
478
479        while jvm
480            .invoke_virtual::<_, bool>(&iterator, &iterator.class_definition().name(), "hasNext", "()Z", ())
481            .await?
482        {
483            let next: ClassInstanceRef<Object> = jvm
484                .invoke_virtual(&iterator, &iterator.class_definition().name(), "next", "()Ljava/lang/Object;", ())
485                .await?;
486            let comparison = Self::compare(jvm, &comparator, &next, &candidate).await?;
487            if (find_minimum && comparison < 0) || (!find_minimum && comparison > 0) {
488                candidate = next;
489            }
490        }
491        Ok(candidate)
492    }
493
494    async fn min(jvm: &Jvm, _: &mut RuntimeContext, collection: ClassInstanceRef<Object>) -> Result<ClassInstanceRef<Object>> {
495        Self::extreme(jvm, collection, None.into(), true).await
496    }
497
498    async fn min_comparator(
499        jvm: &Jvm,
500        _: &mut RuntimeContext,
501        collection: ClassInstanceRef<Object>,
502        comparator: ClassInstanceRef<Object>,
503    ) -> Result<ClassInstanceRef<Object>> {
504        Self::extreme(jvm, collection, comparator, true).await
505    }
506
507    async fn max(jvm: &Jvm, _: &mut RuntimeContext, collection: ClassInstanceRef<Object>) -> Result<ClassInstanceRef<Object>> {
508        Self::extreme(jvm, collection, None.into(), false).await
509    }
510
511    async fn max_comparator(
512        jvm: &Jvm,
513        _: &mut RuntimeContext,
514        collection: ClassInstanceRef<Object>,
515        comparator: ClassInstanceRef<Object>,
516    ) -> Result<ClassInstanceRef<Object>> {
517        Self::extreme(jvm, collection, comparator, false).await
518    }
519
520    async fn n_copies(jvm: &Jvm, _: &mut RuntimeContext, count: i32, element: ClassInstanceRef<Object>) -> Result<ClassInstanceRef<Object>> {
521        if count < 0 {
522            return Err(jvm.exception("java/lang/IllegalArgumentException", "List length = negative").await);
523        }
524        Ok(jvm
525            .new_class("java/util/Collections$CopiesList", "(ILjava/lang/Object;)V", (count, element))
526            .await?
527            .into())
528    }
529
530    async fn singleton(jvm: &Jvm, _: &mut RuntimeContext, element: ClassInstanceRef<Object>) -> Result<ClassInstanceRef<Object>> {
531        Ok(jvm
532            .new_class("java/util/Collections$SingletonSet", "(Ljava/lang/Object;)V", (element,))
533            .await?
534            .into())
535    }
536
537    async fn unmodifiable_collection(jvm: &Jvm, _: &mut RuntimeContext, collection: ClassInstanceRef<Object>) -> Result<ClassInstanceRef<Object>> {
538        Ok(jvm
539            .new_class("java/util/Collections$UnmodifiableCollection", "(Ljava/util/Collection;)V", (collection,))
540            .await?
541            .into())
542    }
543
544    async fn unmodifiable_list(jvm: &Jvm, _: &mut RuntimeContext, list: ClassInstanceRef<Object>) -> Result<ClassInstanceRef<Object>> {
545        Ok(jvm
546            .new_class("java/util/Collections$UnmodifiableList", "(Ljava/util/List;)V", (list,))
547            .await?
548            .into())
549    }
550
551    async fn unmodifiable_set(jvm: &Jvm, _: &mut RuntimeContext, set: ClassInstanceRef<Object>) -> Result<ClassInstanceRef<Object>> {
552        Ok(jvm
553            .new_class("java/util/Collections$UnmodifiableSet", "(Ljava/util/Set;)V", (set,))
554            .await?
555            .into())
556    }
557
558    async fn unmodifiable_map(jvm: &Jvm, _: &mut RuntimeContext, map: ClassInstanceRef<Object>) -> Result<ClassInstanceRef<Object>> {
559        Ok(jvm
560            .new_class("java/util/Collections$UnmodifiableMap", "(Ljava/util/Map;)V", (map,))
561            .await?
562            .into())
563    }
564
565    async fn unmodifiable_sorted_set(jvm: &Jvm, _: &mut RuntimeContext, set: ClassInstanceRef<Object>) -> Result<ClassInstanceRef<Object>> {
566        Ok(jvm
567            .new_class("java/util/Collections$UnmodifiableSortedSet", "(Ljava/util/SortedSet;)V", (set,))
568            .await?
569            .into())
570    }
571
572    async fn unmodifiable_sorted_map(jvm: &Jvm, _: &mut RuntimeContext, map: ClassInstanceRef<Object>) -> Result<ClassInstanceRef<Object>> {
573        Ok(jvm
574            .new_class("java/util/Collections$UnmodifiableSortedMap", "(Ljava/util/SortedMap;)V", (map,))
575            .await?
576            .into())
577    }
578}