Skip to main content

rustjava_runtime/classes/java/util/
tree_map_sub_map.rs

1use alloc::vec;
2
3use jvm::{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
9use super::{TreeMap, TreeMapEntry};
10
11// class java.util.TreeMap$SubMap
12pub struct TreeMapSubMap;
13
14impl TreeMapSubMap {
15    pub fn as_proto() -> RuntimeClassProto {
16        RuntimeClassProto {
17            name: "java/util/TreeMap$SubMap",
18            parent_class: Some("java/util/AbstractMap"),
19            interfaces: vec!["java/util/SortedMap"],
20            methods: vec![
21                JavaMethodProto::new(
22                    "<init>",
23                    "(Ljava/util/TreeMap;ZLjava/lang/Object;ZLjava/lang/Object;)V",
24                    Self::init,
25                    MethodAccessFlags::empty(),
26                ),
27                JavaMethodProto::new("size", "()I", Self::size, MethodAccessFlags::PUBLIC),
28                JavaMethodProto::new("containsKey", "(Ljava/lang/Object;)Z", Self::contains_key, MethodAccessFlags::PUBLIC),
29                JavaMethodProto::new("containsValue", "(Ljava/lang/Object;)Z", Self::contains_value, MethodAccessFlags::PUBLIC),
30                JavaMethodProto::new("get", "(Ljava/lang/Object;)Ljava/lang/Object;", Self::get, MethodAccessFlags::PUBLIC),
31                JavaMethodProto::new(
32                    "put",
33                    "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
34                    Self::put,
35                    MethodAccessFlags::PUBLIC,
36                ),
37                JavaMethodProto::new(
38                    "remove",
39                    "(Ljava/lang/Object;)Ljava/lang/Object;",
40                    Self::remove,
41                    MethodAccessFlags::PUBLIC,
42                ),
43                JavaMethodProto::new("clear", "()V", Self::clear, MethodAccessFlags::PUBLIC),
44                JavaMethodProto::new("comparator", "()Ljava/util/Comparator;", Self::comparator, MethodAccessFlags::PUBLIC),
45                JavaMethodProto::new("firstKey", "()Ljava/lang/Object;", Self::first_key, MethodAccessFlags::PUBLIC),
46                JavaMethodProto::new("lastKey", "()Ljava/lang/Object;", Self::last_key, MethodAccessFlags::PUBLIC),
47                JavaMethodProto::new(
48                    "subMap",
49                    "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/SortedMap;",
50                    Self::sub_map,
51                    MethodAccessFlags::PUBLIC,
52                ),
53                JavaMethodProto::new(
54                    "headMap",
55                    "(Ljava/lang/Object;)Ljava/util/SortedMap;",
56                    Self::head_map,
57                    MethodAccessFlags::PUBLIC,
58                ),
59                JavaMethodProto::new(
60                    "tailMap",
61                    "(Ljava/lang/Object;)Ljava/util/SortedMap;",
62                    Self::tail_map,
63                    MethodAccessFlags::PUBLIC,
64                ),
65                JavaMethodProto::new("keySet", "()Ljava/util/Set;", Self::key_set, MethodAccessFlags::PUBLIC),
66                JavaMethodProto::new("values", "()Ljava/util/Collection;", Self::values, MethodAccessFlags::PUBLIC),
67                JavaMethodProto::new("entrySet", "()Ljava/util/Set;", Self::entry_set, MethodAccessFlags::PUBLIC),
68                JavaMethodProto::new("keyIterator", "()Ljava/util/Iterator;", Self::key_iterator, MethodAccessFlags::empty()),
69                JavaMethodProto::new(
70                    "valueIterator",
71                    "()Ljava/util/Iterator;",
72                    Self::value_iterator,
73                    MethodAccessFlags::empty(),
74                ),
75                JavaMethodProto::new(
76                    "entryIterator",
77                    "()Ljava/util/Iterator;",
78                    Self::entry_iterator,
79                    MethodAccessFlags::empty(),
80                ),
81            ],
82            fields: vec![
83                JavaFieldProto::new("m", "Ljava/util/TreeMap;", FieldAccessFlags::PRIVATE),
84                JavaFieldProto::new("fromStart", "Z", FieldAccessFlags::PRIVATE),
85                JavaFieldProto::new("fromKey", "Ljava/lang/Object;", FieldAccessFlags::PRIVATE),
86                JavaFieldProto::new("toEnd", "Z", FieldAccessFlags::PRIVATE),
87                JavaFieldProto::new("toKey", "Ljava/lang/Object;", FieldAccessFlags::PRIVATE),
88            ],
89            access_flags: ClassAccessFlags::empty(),
90        }
91    }
92
93    #[allow(clippy::too_many_arguments)]
94    async fn init(
95        jvm: &Jvm,
96        _: &mut RuntimeContext,
97        mut this: ClassInstanceRef<Self>,
98        map: ClassInstanceRef<TreeMap>,
99        from_start: bool,
100        from_key: ClassInstanceRef<Object>,
101        to_end: bool,
102        to_key: ClassInstanceRef<Object>,
103    ) -> Result<()> {
104        if map.is_null() {
105            return Err(jvm.exception("java/lang/NullPointerException", "map").await);
106        }
107        if !from_start {
108            let _ = TreeMap::compare(jvm, &map, &from_key, &from_key).await?;
109        }
110        if !to_end {
111            let _ = TreeMap::compare(jvm, &map, &to_key, &to_key).await?;
112        }
113        if !from_start && !to_end && TreeMap::compare(jvm, &map, &from_key, &to_key).await? > 0 {
114            return Err(jvm.exception("java/lang/IllegalArgumentException", "fromKey > toKey").await);
115        }
116        let _: () = jvm.invoke_special(&this, "java/util/AbstractMap", "<init>", "()V", ()).await?;
117        jvm.put_field(&mut this, "java/util/TreeMap$SubMap", "m", "Ljava/util/TreeMap;", map)
118            .await?;
119        jvm.put_field(&mut this, "java/util/TreeMap$SubMap", "fromStart", "Z", from_start).await?;
120        jvm.put_field(&mut this, "java/util/TreeMap$SubMap", "fromKey", "Ljava/lang/Object;", from_key)
121            .await?;
122        jvm.put_field(&mut this, "java/util/TreeMap$SubMap", "toEnd", "Z", to_end).await?;
123        jvm.put_field(&mut this, "java/util/TreeMap$SubMap", "toKey", "Ljava/lang/Object;", to_key)
124            .await
125    }
126
127    async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
128        let iterator: ClassInstanceRef<Object> = jvm
129            .invoke_virtual(&this, "java/util/TreeMap$SubMap", "entryIterator", "()Ljava/util/Iterator;", ())
130            .await?;
131        let mut size = 0;
132        while jvm
133            .invoke_virtual::<_, bool>(&iterator, &iterator.class_definition().name(), "hasNext", "()Z", ())
134            .await?
135        {
136            let _: ClassInstanceRef<Object> = jvm
137                .invoke_virtual(&iterator, &iterator.class_definition().name(), "next", "()Ljava/lang/Object;", ())
138                .await?;
139            size += 1;
140        }
141        Ok(size)
142    }
143
144    async fn contains_key(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, key: ClassInstanceRef<Object>) -> Result<bool> {
145        if !Self::in_range(jvm, &this, &key, false).await? {
146            return Ok(false);
147        }
148        let map: ClassInstanceRef<TreeMap> = jvm.get_field(&this, "java/util/TreeMap$SubMap", "m", "Ljava/util/TreeMap;").await?;
149        Ok(!TreeMap::find_entry(jvm, &map, &key).await?.is_null())
150    }
151
152    async fn contains_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Object>) -> Result<bool> {
153        let iterator: ClassInstanceRef<Object> = jvm
154            .invoke_virtual(&this, "java/util/TreeMap$SubMap", "valueIterator", "()Ljava/util/Iterator;", ())
155            .await?;
156        while jvm
157            .invoke_virtual::<_, bool>(&iterator, &iterator.class_definition().name(), "hasNext", "()Z", ())
158            .await?
159        {
160            let current: ClassInstanceRef<Object> = jvm
161                .invoke_virtual(&iterator, &iterator.class_definition().name(), "next", "()Ljava/lang/Object;", ())
162                .await?;
163            let equal = if value.is_null() {
164                current.is_null()
165            } else {
166                jvm.invoke_virtual(&value, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (current,))
167                    .await?
168            };
169            if equal {
170                return Ok(true);
171            }
172        }
173        Ok(false)
174    }
175
176    async fn get(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, key: ClassInstanceRef<Object>) -> Result<ClassInstanceRef<Object>> {
177        if !Self::in_range(jvm, &this, &key, false).await? {
178            return Ok(None.into());
179        }
180        let map: ClassInstanceRef<TreeMap> = jvm.get_field(&this, "java/util/TreeMap$SubMap", "m", "Ljava/util/TreeMap;").await?;
181        let entry = TreeMap::find_entry(jvm, &map, &key).await?;
182        if entry.is_null() {
183            return Ok(None.into());
184        }
185        jvm.get_field(&entry, "java/util/TreeMap$Entry", "value", "Ljava/lang/Object;").await
186    }
187
188    async fn put(
189        jvm: &Jvm,
190        _: &mut RuntimeContext,
191        this: ClassInstanceRef<Self>,
192        key: ClassInstanceRef<Object>,
193        value: ClassInstanceRef<Object>,
194    ) -> Result<ClassInstanceRef<Object>> {
195        if !Self::in_range(jvm, &this, &key, false).await? {
196            return Err(jvm.exception("java/lang/IllegalArgumentException", "key outside range").await);
197        }
198        let map: ClassInstanceRef<TreeMap> = jvm.get_field(&this, "java/util/TreeMap$SubMap", "m", "Ljava/util/TreeMap;").await?;
199        jvm.invoke_virtual(
200            &map,
201            "java/util/TreeMap",
202            "put",
203            "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
204            (key, value),
205        )
206        .await
207    }
208
209    async fn remove(
210        jvm: &Jvm,
211        _: &mut RuntimeContext,
212        this: ClassInstanceRef<Self>,
213        key: ClassInstanceRef<Object>,
214    ) -> Result<ClassInstanceRef<Object>> {
215        if !Self::in_range(jvm, &this, &key, false).await? {
216            return Ok(None.into());
217        }
218        let map: ClassInstanceRef<TreeMap> = jvm.get_field(&this, "java/util/TreeMap$SubMap", "m", "Ljava/util/TreeMap;").await?;
219        jvm.invoke_virtual(&map, "java/util/TreeMap", "remove", "(Ljava/lang/Object;)Ljava/lang/Object;", (key,))
220            .await
221    }
222
223    async fn clear(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
224        let iterator: ClassInstanceRef<Object> = jvm
225            .invoke_virtual(&this, "java/util/TreeMap$SubMap", "entryIterator", "()Ljava/util/Iterator;", ())
226            .await?;
227        while jvm
228            .invoke_virtual::<_, bool>(&iterator, &iterator.class_definition().name(), "hasNext", "()Z", ())
229            .await?
230        {
231            let _: ClassInstanceRef<Object> = jvm
232                .invoke_virtual(&iterator, &iterator.class_definition().name(), "next", "()Ljava/lang/Object;", ())
233                .await?;
234            let _: () = jvm
235                .invoke_virtual(&iterator, &iterator.class_definition().name(), "remove", "()V", ())
236                .await?;
237        }
238        Ok(())
239    }
240
241    async fn comparator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
242        let map: ClassInstanceRef<TreeMap> = jvm.get_field(&this, "java/util/TreeMap$SubMap", "m", "Ljava/util/TreeMap;").await?;
243        jvm.invoke_virtual(&map, "java/util/TreeMap", "comparator", "()Ljava/util/Comparator;", ())
244            .await
245    }
246
247    async fn first_key(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
248        let entry = Self::first_entry(jvm, &this).await?;
249        if entry.is_null() {
250            return Err(jvm.exception("java/util/NoSuchElementException", "empty subMap").await);
251        }
252        jvm.get_field(&entry, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;").await
253    }
254
255    async fn last_key(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
256        let entry = Self::last_entry(jvm, &this).await?;
257        if entry.is_null() {
258            return Err(jvm.exception("java/util/NoSuchElementException", "empty subMap").await);
259        }
260        jvm.get_field(&entry, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;").await
261    }
262
263    async fn sub_map(
264        jvm: &Jvm,
265        _: &mut RuntimeContext,
266        this: ClassInstanceRef<Self>,
267        from_key: ClassInstanceRef<Object>,
268        to_key: ClassInstanceRef<Object>,
269    ) -> Result<ClassInstanceRef<Object>> {
270        let map: ClassInstanceRef<TreeMap> = jvm.get_field(&this, "java/util/TreeMap$SubMap", "m", "Ljava/util/TreeMap;").await?;
271        if !Self::in_range(jvm, &this, &from_key, false).await? {
272            return Err(jvm.exception("java/lang/IllegalArgumentException", "fromKey outside range").await);
273        }
274        if !Self::in_range(jvm, &this, &to_key, true).await? {
275            return Err(jvm.exception("java/lang/IllegalArgumentException", "toKey outside range").await);
276        }
277        if TreeMap::compare(jvm, &map, &from_key, &to_key).await? > 0 {
278            return Err(jvm.exception("java/lang/IllegalArgumentException", "fromKey > toKey").await);
279        }
280        Ok(jvm
281            .new_class(
282                "java/util/TreeMap$SubMap",
283                "(Ljava/util/TreeMap;ZLjava/lang/Object;ZLjava/lang/Object;)V",
284                (map, false, from_key, false, to_key),
285            )
286            .await?
287            .into())
288    }
289
290    async fn head_map(
291        jvm: &Jvm,
292        _: &mut RuntimeContext,
293        this: ClassInstanceRef<Self>,
294        to_key: ClassInstanceRef<Object>,
295    ) -> Result<ClassInstanceRef<Object>> {
296        if !Self::in_range(jvm, &this, &to_key, true).await? {
297            return Err(jvm.exception("java/lang/IllegalArgumentException", "endpoint outside range").await);
298        }
299        let map: ClassInstanceRef<TreeMap> = jvm.get_field(&this, "java/util/TreeMap$SubMap", "m", "Ljava/util/TreeMap;").await?;
300        let from_start: bool = jvm.get_field(&this, "java/util/TreeMap$SubMap", "fromStart", "Z").await?;
301        let from_key: ClassInstanceRef<Object> = jvm.get_field(&this, "java/util/TreeMap$SubMap", "fromKey", "Ljava/lang/Object;").await?;
302        Ok(jvm
303            .new_class(
304                "java/util/TreeMap$SubMap",
305                "(Ljava/util/TreeMap;ZLjava/lang/Object;ZLjava/lang/Object;)V",
306                (map, from_start, from_key, false, to_key),
307            )
308            .await?
309            .into())
310    }
311
312    async fn tail_map(
313        jvm: &Jvm,
314        _: &mut RuntimeContext,
315        this: ClassInstanceRef<Self>,
316        from_key: ClassInstanceRef<Object>,
317    ) -> Result<ClassInstanceRef<Object>> {
318        if !Self::in_range(jvm, &this, &from_key, false).await? {
319            return Err(jvm.exception("java/lang/IllegalArgumentException", "endpoint outside range").await);
320        }
321        let map: ClassInstanceRef<TreeMap> = jvm.get_field(&this, "java/util/TreeMap$SubMap", "m", "Ljava/util/TreeMap;").await?;
322        let to_end: bool = jvm.get_field(&this, "java/util/TreeMap$SubMap", "toEnd", "Z").await?;
323        let to_key: ClassInstanceRef<Object> = jvm.get_field(&this, "java/util/TreeMap$SubMap", "toKey", "Ljava/lang/Object;").await?;
324        Ok(jvm
325            .new_class(
326                "java/util/TreeMap$SubMap",
327                "(Ljava/util/TreeMap;ZLjava/lang/Object;ZLjava/lang/Object;)V",
328                (map, false, from_key, to_end, to_key),
329            )
330            .await?
331            .into())
332    }
333
334    async fn key_set(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
335        Ok(jvm
336            .new_class("java/util/TreeMap$KeySet", "(Ljava/util/SortedMap;)V", (this,))
337            .await?
338            .into())
339    }
340
341    async fn values(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
342        Ok(jvm
343            .new_class("java/util/TreeMap$Values", "(Ljava/util/SortedMap;)V", (this,))
344            .await?
345            .into())
346    }
347
348    async fn entry_set(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
349        Ok(jvm
350            .new_class("java/util/TreeMap$EntrySet", "(Ljava/util/SortedMap;)V", (this,))
351            .await?
352            .into())
353    }
354
355    async fn key_iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
356        let map: ClassInstanceRef<TreeMap> = jvm.get_field(&this, "java/util/TreeMap$SubMap", "m", "Ljava/util/TreeMap;").await?;
357        let first = Self::first_entry(jvm, &this).await?;
358        let to_end: bool = jvm.get_field(&this, "java/util/TreeMap$SubMap", "toEnd", "Z").await?;
359        let to_key: ClassInstanceRef<Object> = jvm.get_field(&this, "java/util/TreeMap$SubMap", "toKey", "Ljava/lang/Object;").await?;
360        Ok(jvm
361            .new_class(
362                "java/util/TreeMap$KeyIterator",
363                "(Ljava/util/TreeMap;Ljava/util/TreeMap$Entry;Ljava/lang/Object;Z)V",
364                (map, first, to_key, to_end),
365            )
366            .await?
367            .into())
368    }
369
370    async fn value_iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
371        let map: ClassInstanceRef<TreeMap> = jvm.get_field(&this, "java/util/TreeMap$SubMap", "m", "Ljava/util/TreeMap;").await?;
372        let first = Self::first_entry(jvm, &this).await?;
373        let to_end: bool = jvm.get_field(&this, "java/util/TreeMap$SubMap", "toEnd", "Z").await?;
374        let to_key: ClassInstanceRef<Object> = jvm.get_field(&this, "java/util/TreeMap$SubMap", "toKey", "Ljava/lang/Object;").await?;
375        Ok(jvm
376            .new_class(
377                "java/util/TreeMap$ValueIterator",
378                "(Ljava/util/TreeMap;Ljava/util/TreeMap$Entry;Ljava/lang/Object;Z)V",
379                (map, first, to_key, to_end),
380            )
381            .await?
382            .into())
383    }
384
385    async fn entry_iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
386        let map: ClassInstanceRef<TreeMap> = jvm.get_field(&this, "java/util/TreeMap$SubMap", "m", "Ljava/util/TreeMap;").await?;
387        let first = Self::first_entry(jvm, &this).await?;
388        let to_end: bool = jvm.get_field(&this, "java/util/TreeMap$SubMap", "toEnd", "Z").await?;
389        let to_key: ClassInstanceRef<Object> = jvm.get_field(&this, "java/util/TreeMap$SubMap", "toKey", "Ljava/lang/Object;").await?;
390        Ok(jvm
391            .new_class(
392                "java/util/TreeMap$EntryIterator",
393                "(Ljava/util/TreeMap;Ljava/util/TreeMap$Entry;Ljava/lang/Object;Z)V",
394                (map, first, to_key, to_end),
395            )
396            .await?
397            .into())
398    }
399
400    async fn in_range(jvm: &Jvm, this: &ClassInstanceRef<Self>, key: &ClassInstanceRef<Object>, allow_equal_upper: bool) -> Result<bool> {
401        let map: ClassInstanceRef<TreeMap> = jvm.get_field(this, "java/util/TreeMap$SubMap", "m", "Ljava/util/TreeMap;").await?;
402        if !jvm.get_field::<bool>(this, "java/util/TreeMap$SubMap", "fromStart", "Z").await? {
403            let from_key: ClassInstanceRef<Object> = jvm.get_field(this, "java/util/TreeMap$SubMap", "fromKey", "Ljava/lang/Object;").await?;
404            if TreeMap::compare(jvm, &map, key, &from_key).await? < 0 {
405                return Ok(false);
406            }
407        }
408        if !jvm.get_field::<bool>(this, "java/util/TreeMap$SubMap", "toEnd", "Z").await? {
409            let to_key: ClassInstanceRef<Object> = jvm.get_field(this, "java/util/TreeMap$SubMap", "toKey", "Ljava/lang/Object;").await?;
410            let comparison = TreeMap::compare(jvm, &map, key, &to_key).await?;
411            if comparison > 0 || (!allow_equal_upper && comparison == 0) {
412                return Ok(false);
413            }
414        }
415        Ok(true)
416    }
417
418    async fn first_entry(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<ClassInstanceRef<TreeMapEntry>> {
419        let map: ClassInstanceRef<TreeMap> = jvm.get_field(this, "java/util/TreeMap$SubMap", "m", "Ljava/util/TreeMap;").await?;
420        let entry = if jvm.get_field::<bool>(this, "java/util/TreeMap$SubMap", "fromStart", "Z").await? {
421            TreeMap::first_entry(jvm, &map).await?
422        } else {
423            let from_key: ClassInstanceRef<Object> = jvm.get_field(this, "java/util/TreeMap$SubMap", "fromKey", "Ljava/lang/Object;").await?;
424            TreeMap::ceiling_entry(jvm, &map, &from_key).await?
425        };
426        if entry.is_null() || jvm.get_field::<bool>(this, "java/util/TreeMap$SubMap", "toEnd", "Z").await? {
427            return Ok(entry);
428        }
429        let key: ClassInstanceRef<Object> = jvm.get_field(&entry, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;").await?;
430        let to_key: ClassInstanceRef<Object> = jvm.get_field(this, "java/util/TreeMap$SubMap", "toKey", "Ljava/lang/Object;").await?;
431        if TreeMap::compare(jvm, &map, &key, &to_key).await? >= 0 {
432            Ok(None.into())
433        } else {
434            Ok(entry)
435        }
436    }
437
438    async fn last_entry(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<ClassInstanceRef<TreeMapEntry>> {
439        let map: ClassInstanceRef<TreeMap> = jvm.get_field(this, "java/util/TreeMap$SubMap", "m", "Ljava/util/TreeMap;").await?;
440        let entry = if jvm.get_field::<bool>(this, "java/util/TreeMap$SubMap", "toEnd", "Z").await? {
441            TreeMap::last_entry(jvm, &map).await?
442        } else {
443            let to_key: ClassInstanceRef<Object> = jvm.get_field(this, "java/util/TreeMap$SubMap", "toKey", "Ljava/lang/Object;").await?;
444            TreeMap::lower_entry(jvm, &map, &to_key).await?
445        };
446        if entry.is_null() || jvm.get_field::<bool>(this, "java/util/TreeMap$SubMap", "fromStart", "Z").await? {
447            return Ok(entry);
448        }
449        let key: ClassInstanceRef<Object> = jvm.get_field(&entry, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;").await?;
450        let from_key: ClassInstanceRef<Object> = jvm.get_field(this, "java/util/TreeMap$SubMap", "fromKey", "Ljava/lang/Object;").await?;
451        if TreeMap::compare(jvm, &map, &key, &from_key).await? < 0 {
452            Ok(None.into())
453        } else {
454            Ok(entry)
455        }
456    }
457}