Skip to main content

rustjava_runtime/classes/java/util/
tree_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::TreeMapEntry;
10
11// public class java.util.TreeMap
12pub struct TreeMap;
13
14impl TreeMap {
15    pub fn as_proto() -> RuntimeClassProto {
16        RuntimeClassProto {
17            name: "java/util/TreeMap",
18            parent_class: Some("java/util/AbstractMap"),
19            interfaces: vec!["java/util/SortedMap", "java/lang/Cloneable", "java/io/Serializable"],
20            methods: vec![
21                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
22                JavaMethodProto::new("<init>", "(Ljava/util/Comparator;)V", Self::init_comparator, MethodAccessFlags::PUBLIC),
23                JavaMethodProto::new("<init>", "(Ljava/util/Map;)V", Self::init_map, MethodAccessFlags::PUBLIC),
24                JavaMethodProto::new("<init>", "(Ljava/util/SortedMap;)V", Self::init_sorted_map, MethodAccessFlags::PUBLIC),
25                JavaMethodProto::new("size", "()I", Self::size, MethodAccessFlags::PUBLIC),
26                JavaMethodProto::new("containsKey", "(Ljava/lang/Object;)Z", Self::contains_key, MethodAccessFlags::PUBLIC),
27                JavaMethodProto::new("containsValue", "(Ljava/lang/Object;)Z", Self::contains_value, MethodAccessFlags::PUBLIC),
28                JavaMethodProto::new("get", "(Ljava/lang/Object;)Ljava/lang/Object;", Self::get, MethodAccessFlags::PUBLIC),
29                JavaMethodProto::new(
30                    "put",
31                    "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
32                    Self::put,
33                    MethodAccessFlags::PUBLIC,
34                ),
35                JavaMethodProto::new("putAll", "(Ljava/util/Map;)V", Self::put_all, MethodAccessFlags::PUBLIC),
36                JavaMethodProto::new(
37                    "remove",
38                    "(Ljava/lang/Object;)Ljava/lang/Object;",
39                    Self::remove,
40                    MethodAccessFlags::PUBLIC,
41                ),
42                JavaMethodProto::new("clear", "()V", Self::clear, MethodAccessFlags::PUBLIC),
43                JavaMethodProto::new("comparator", "()Ljava/util/Comparator;", Self::comparator, MethodAccessFlags::PUBLIC),
44                JavaMethodProto::new("firstKey", "()Ljava/lang/Object;", Self::first_key, MethodAccessFlags::PUBLIC),
45                JavaMethodProto::new("lastKey", "()Ljava/lang/Object;", Self::last_key, MethodAccessFlags::PUBLIC),
46                JavaMethodProto::new(
47                    "subMap",
48                    "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/SortedMap;",
49                    Self::sub_map,
50                    MethodAccessFlags::PUBLIC,
51                ),
52                JavaMethodProto::new(
53                    "headMap",
54                    "(Ljava/lang/Object;)Ljava/util/SortedMap;",
55                    Self::head_map,
56                    MethodAccessFlags::PUBLIC,
57                ),
58                JavaMethodProto::new(
59                    "tailMap",
60                    "(Ljava/lang/Object;)Ljava/util/SortedMap;",
61                    Self::tail_map,
62                    MethodAccessFlags::PUBLIC,
63                ),
64                JavaMethodProto::new("keySet", "()Ljava/util/Set;", Self::key_set, MethodAccessFlags::PUBLIC),
65                JavaMethodProto::new("values", "()Ljava/util/Collection;", Self::values, MethodAccessFlags::PUBLIC),
66                JavaMethodProto::new("entrySet", "()Ljava/util/Set;", Self::entry_set, MethodAccessFlags::PUBLIC),
67                JavaMethodProto::new("keyIterator", "()Ljava/util/Iterator;", Self::key_iterator, MethodAccessFlags::empty()),
68                JavaMethodProto::new(
69                    "valueIterator",
70                    "()Ljava/util/Iterator;",
71                    Self::value_iterator,
72                    MethodAccessFlags::empty(),
73                ),
74                JavaMethodProto::new(
75                    "entryIterator",
76                    "()Ljava/util/Iterator;",
77                    Self::entry_iterator,
78                    MethodAccessFlags::empty(),
79                ),
80            ],
81            fields: vec![
82                JavaFieldProto::new(
83                    "root",
84                    "Ljava/util/TreeMap$Entry;",
85                    FieldAccessFlags::PRIVATE | FieldAccessFlags::TRANSIENT,
86                ),
87                JavaFieldProto::new("size", "I", FieldAccessFlags::PRIVATE | FieldAccessFlags::TRANSIENT),
88                JavaFieldProto::new("comparator", "Ljava/util/Comparator;", FieldAccessFlags::PRIVATE),
89            ],
90            access_flags: ClassAccessFlags::PUBLIC,
91        }
92    }
93
94    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
95        let _: () = jvm.invoke_special(&this, "java/util/AbstractMap", "<init>", "()V", ()).await?;
96        Ok(())
97    }
98
99    async fn init_comparator(
100        jvm: &Jvm,
101        _: &mut RuntimeContext,
102        mut this: ClassInstanceRef<Self>,
103        comparator: ClassInstanceRef<Object>,
104    ) -> Result<()> {
105        let _: () = jvm.invoke_special(&this, "java/util/AbstractMap", "<init>", "()V", ()).await?;
106        jvm.put_field(&mut this, "java/util/TreeMap", "comparator", "Ljava/util/Comparator;", comparator)
107            .await
108    }
109
110    async fn init_map(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, map: ClassInstanceRef<Object>) -> Result<()> {
111        if map.is_null() {
112            return Err(jvm.exception("java/lang/NullPointerException", "map").await);
113        }
114        let _: () = jvm.invoke_special(&this, "java/util/TreeMap", "<init>", "()V", ()).await?;
115        Self::copy_from_map(jvm, this, map).await
116    }
117
118    async fn init_sorted_map(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, map: ClassInstanceRef<Object>) -> Result<()> {
119        if map.is_null() {
120            return Err(jvm.exception("java/lang/NullPointerException", "map").await);
121        }
122        let comparator: ClassInstanceRef<Object> = jvm
123            .invoke_virtual(&map, &map.class_definition().name(), "comparator", "()Ljava/util/Comparator;", ())
124            .await?;
125        let _: () = jvm
126            .invoke_special(&this, "java/util/TreeMap", "<init>", "(Ljava/util/Comparator;)V", (comparator,))
127            .await?;
128        Self::copy_from_map(jvm, this, map).await
129    }
130
131    async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
132        jvm.get_field(&this, "java/util/TreeMap", "size", "I").await
133    }
134
135    async fn contains_key(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, key: ClassInstanceRef<Object>) -> Result<bool> {
136        Ok(!Self::find_entry(jvm, &this, &key).await?.is_null())
137    }
138
139    async fn contains_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Object>) -> Result<bool> {
140        let mut entry = Self::first_entry(jvm, &this).await?;
141        while !entry.is_null() {
142            let current: ClassInstanceRef<Object> = jvm.get_field(&entry, "java/util/TreeMap$Entry", "value", "Ljava/lang/Object;").await?;
143            let equal = if value.is_null() {
144                current.is_null()
145            } else {
146                jvm.invoke_virtual(&value, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (current,))
147                    .await?
148            };
149            if equal {
150                return Ok(true);
151            }
152            entry = Self::successor(jvm, entry).await?;
153        }
154        Ok(false)
155    }
156
157    async fn get(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, key: ClassInstanceRef<Object>) -> Result<ClassInstanceRef<Object>> {
158        let entry = Self::find_entry(jvm, &this, &key).await?;
159        if entry.is_null() {
160            return Ok(None.into());
161        }
162        jvm.get_field(&entry, "java/util/TreeMap$Entry", "value", "Ljava/lang/Object;").await
163    }
164
165    async fn put(
166        jvm: &Jvm,
167        _: &mut RuntimeContext,
168        mut this: ClassInstanceRef<Self>,
169        key: ClassInstanceRef<Object>,
170        value: ClassInstanceRef<Object>,
171    ) -> Result<ClassInstanceRef<Object>> {
172        let root: ClassInstanceRef<TreeMapEntry> = jvm.get_field(&this, "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;").await?;
173        if root.is_null() {
174            let _ = Self::compare(jvm, &this, &key, &key).await?;
175            let entry: ClassInstanceRef<TreeMapEntry> = jvm
176                .new_class(
177                    "java/util/TreeMap$Entry",
178                    "(Ljava/lang/Object;Ljava/lang/Object;Ljava/util/TreeMap$Entry;)V",
179                    (key, value, ClassInstanceRef::<TreeMapEntry>::from(None)),
180                )
181                .await?
182                .into();
183            jvm.put_field(&mut this, "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;", entry)
184                .await?;
185            jvm.put_field(&mut this, "java/util/TreeMap", "size", "I", 1).await?;
186            return Ok(None.into());
187        }
188
189        let mut parent = root;
190        let comparison;
191        loop {
192            let stored_key: ClassInstanceRef<Object> = jvm.get_field(&parent, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;").await?;
193            let current_comparison = Self::compare(jvm, &this, &key, &stored_key).await?;
194            if current_comparison == 0 {
195                let old_value: ClassInstanceRef<Object> = jvm.get_field(&parent, "java/util/TreeMap$Entry", "value", "Ljava/lang/Object;").await?;
196                let mut parent = parent;
197                jvm.put_field(&mut parent, "java/util/TreeMap$Entry", "value", "Ljava/lang/Object;", value)
198                    .await?;
199                return Ok(old_value);
200            }
201            let child: ClassInstanceRef<TreeMapEntry> = if current_comparison < 0 {
202                jvm.get_field(&parent, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;")
203                    .await?
204            } else {
205                jvm.get_field(&parent, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;")
206                    .await?
207            };
208            if child.is_null() {
209                comparison = current_comparison;
210                break;
211            }
212            parent = child;
213        }
214
215        let mut entry: ClassInstanceRef<TreeMapEntry> = jvm
216            .new_class(
217                "java/util/TreeMap$Entry",
218                "(Ljava/lang/Object;Ljava/lang/Object;Ljava/util/TreeMap$Entry;)V",
219                (key, value, parent.clone()),
220            )
221            .await?
222            .into();
223        jvm.put_field(&mut entry, "java/util/TreeMap$Entry", "color", "Z", false).await?;
224        let mut parent = parent;
225        if comparison < 0 {
226            jvm.put_field(&mut parent, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;", entry.clone())
227                .await?;
228        } else {
229            jvm.put_field(
230                &mut parent,
231                "java/util/TreeMap$Entry",
232                "right",
233                "Ljava/util/TreeMap$Entry;",
234                entry.clone(),
235            )
236            .await?;
237        }
238        let size: i32 = jvm.get_field(&this, "java/util/TreeMap", "size", "I").await?;
239        jvm.put_field(&mut this, "java/util/TreeMap", "size", "I", size + 1).await?;
240        Self::fix_after_insertion(jvm, &mut this, entry).await?;
241        Ok(None.into())
242    }
243
244    async fn put_all(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, map: ClassInstanceRef<Object>) -> Result<()> {
245        if map.is_null() {
246            return Err(jvm.exception("java/lang/NullPointerException", "map").await);
247        }
248        if this.identity() == map.identity() {
249            return Ok(());
250        }
251        Self::copy_from_map(jvm, this, map).await
252    }
253
254    async fn remove(
255        jvm: &Jvm,
256        _: &mut RuntimeContext,
257        mut this: ClassInstanceRef<Self>,
258        key: ClassInstanceRef<Object>,
259    ) -> Result<ClassInstanceRef<Object>> {
260        let entry = Self::find_entry(jvm, &this, &key).await?;
261        if entry.is_null() {
262            return Ok(None.into());
263        }
264        let old_value: ClassInstanceRef<Object> = jvm.get_field(&entry, "java/util/TreeMap$Entry", "value", "Ljava/lang/Object;").await?;
265        Self::delete_entry(jvm, &mut this, entry).await?;
266        Ok(old_value)
267    }
268
269    async fn clear(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
270        jvm.put_field(
271            &mut this,
272            "java/util/TreeMap",
273            "root",
274            "Ljava/util/TreeMap$Entry;",
275            ClassInstanceRef::<TreeMapEntry>::from(None),
276        )
277        .await?;
278        jvm.put_field(&mut this, "java/util/TreeMap", "size", "I", 0).await
279    }
280
281    async fn comparator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
282        jvm.get_field(&this, "java/util/TreeMap", "comparator", "Ljava/util/Comparator;").await
283    }
284
285    async fn first_key(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
286        let entry = Self::first_entry(jvm, &this).await?;
287        if entry.is_null() {
288            return Err(jvm.exception("java/util/NoSuchElementException", "empty TreeMap").await);
289        }
290        jvm.get_field(&entry, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;").await
291    }
292
293    async fn last_key(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
294        let entry = Self::last_entry(jvm, &this).await?;
295        if entry.is_null() {
296            return Err(jvm.exception("java/util/NoSuchElementException", "empty TreeMap").await);
297        }
298        jvm.get_field(&entry, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;").await
299    }
300
301    async fn sub_map(
302        jvm: &Jvm,
303        _: &mut RuntimeContext,
304        this: ClassInstanceRef<Self>,
305        from_key: ClassInstanceRef<Object>,
306        to_key: ClassInstanceRef<Object>,
307    ) -> Result<ClassInstanceRef<Object>> {
308        if Self::compare(jvm, &this, &from_key, &to_key).await? > 0 {
309            return Err(jvm.exception("java/lang/IllegalArgumentException", "fromKey > toKey").await);
310        }
311        Ok(jvm
312            .new_class(
313                "java/util/TreeMap$SubMap",
314                "(Ljava/util/TreeMap;ZLjava/lang/Object;ZLjava/lang/Object;)V",
315                (this, false, from_key, false, to_key),
316            )
317            .await?
318            .into())
319    }
320
321    async fn head_map(
322        jvm: &Jvm,
323        _: &mut RuntimeContext,
324        this: ClassInstanceRef<Self>,
325        to_key: ClassInstanceRef<Object>,
326    ) -> Result<ClassInstanceRef<Object>> {
327        let _ = Self::compare(jvm, &this, &to_key, &to_key).await?;
328        Ok(jvm
329            .new_class(
330                "java/util/TreeMap$SubMap",
331                "(Ljava/util/TreeMap;ZLjava/lang/Object;ZLjava/lang/Object;)V",
332                (this, true, ClassInstanceRef::<Object>::from(None), false, to_key),
333            )
334            .await?
335            .into())
336    }
337
338    async fn tail_map(
339        jvm: &Jvm,
340        _: &mut RuntimeContext,
341        this: ClassInstanceRef<Self>,
342        from_key: ClassInstanceRef<Object>,
343    ) -> Result<ClassInstanceRef<Object>> {
344        let _ = Self::compare(jvm, &this, &from_key, &from_key).await?;
345        Ok(jvm
346            .new_class(
347                "java/util/TreeMap$SubMap",
348                "(Ljava/util/TreeMap;ZLjava/lang/Object;ZLjava/lang/Object;)V",
349                (this, false, from_key, true, ClassInstanceRef::<Object>::from(None)),
350            )
351            .await?
352            .into())
353    }
354
355    async fn key_set(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
356        Ok(jvm
357            .new_class("java/util/TreeMap$KeySet", "(Ljava/util/SortedMap;)V", (this,))
358            .await?
359            .into())
360    }
361
362    async fn values(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
363        Ok(jvm
364            .new_class("java/util/TreeMap$Values", "(Ljava/util/SortedMap;)V", (this,))
365            .await?
366            .into())
367    }
368
369    async fn entry_set(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
370        Ok(jvm
371            .new_class("java/util/TreeMap$EntrySet", "(Ljava/util/SortedMap;)V", (this,))
372            .await?
373            .into())
374    }
375
376    async fn key_iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
377        let first = Self::first_entry(jvm, &this).await?;
378        Ok(jvm
379            .new_class(
380                "java/util/TreeMap$KeyIterator",
381                "(Ljava/util/TreeMap;Ljava/util/TreeMap$Entry;Ljava/lang/Object;Z)V",
382                (this, first, ClassInstanceRef::<Object>::from(None), true),
383            )
384            .await?
385            .into())
386    }
387
388    async fn value_iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
389        let first = Self::first_entry(jvm, &this).await?;
390        Ok(jvm
391            .new_class(
392                "java/util/TreeMap$ValueIterator",
393                "(Ljava/util/TreeMap;Ljava/util/TreeMap$Entry;Ljava/lang/Object;Z)V",
394                (this, first, ClassInstanceRef::<Object>::from(None), true),
395            )
396            .await?
397            .into())
398    }
399
400    async fn entry_iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
401        let first = Self::first_entry(jvm, &this).await?;
402        Ok(jvm
403            .new_class(
404                "java/util/TreeMap$EntryIterator",
405                "(Ljava/util/TreeMap;Ljava/util/TreeMap$Entry;Ljava/lang/Object;Z)V",
406                (this, first, ClassInstanceRef::<Object>::from(None), true),
407            )
408            .await?
409            .into())
410    }
411
412    async fn copy_from_map(jvm: &Jvm, this: ClassInstanceRef<Self>, map: ClassInstanceRef<Object>) -> Result<()> {
413        let entry_set: ClassInstanceRef<Object> = jvm
414            .invoke_virtual(&map, &map.class_definition().name(), "entrySet", "()Ljava/util/Set;", ())
415            .await?;
416        let iterator: ClassInstanceRef<Object> = jvm
417            .invoke_virtual(&entry_set, &entry_set.class_definition().name(), "iterator", "()Ljava/util/Iterator;", ())
418            .await?;
419        while jvm
420            .invoke_virtual::<_, bool>(&iterator, &iterator.class_definition().name(), "hasNext", "()Z", ())
421            .await?
422        {
423            let entry: ClassInstanceRef<Object> = jvm
424                .invoke_virtual(&iterator, &iterator.class_definition().name(), "next", "()Ljava/lang/Object;", ())
425                .await?;
426            let key: ClassInstanceRef<Object> = jvm
427                .invoke_virtual(&entry, &entry.class_definition().name(), "getKey", "()Ljava/lang/Object;", ())
428                .await?;
429            let value: ClassInstanceRef<Object> = jvm
430                .invoke_virtual(&entry, &entry.class_definition().name(), "getValue", "()Ljava/lang/Object;", ())
431                .await?;
432            let _: ClassInstanceRef<Object> = jvm
433                .invoke_virtual(
434                    &this,
435                    "java/util/TreeMap",
436                    "put",
437                    "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
438                    (key, value),
439                )
440                .await?;
441        }
442        Ok(())
443    }
444
445    pub(super) async fn compare(
446        jvm: &Jvm,
447        this: &ClassInstanceRef<Self>,
448        left: &ClassInstanceRef<Object>,
449        right: &ClassInstanceRef<Object>,
450    ) -> Result<i32> {
451        let comparator: ClassInstanceRef<Object> = jvm.get_field(this, "java/util/TreeMap", "comparator", "Ljava/util/Comparator;").await?;
452        if !comparator.is_null() {
453            return jvm
454                .invoke_virtual(
455                    &comparator,
456                    &comparator.class_definition().name(),
457                    "compare",
458                    "(Ljava/lang/Object;Ljava/lang/Object;)I",
459                    (left.clone(), right.clone()),
460                )
461                .await;
462        }
463        if left.is_null() {
464            return Err(jvm.exception("java/lang/NullPointerException", "null key").await);
465        }
466        if !jvm.is_instance(left.as_ref(), "java/lang/Comparable") {
467            return Err(jvm.exception("java/lang/ClassCastException", "key is not Comparable").await);
468        }
469        jvm.invoke_virtual(
470            left,
471            &left.class_definition().name(),
472            "compareTo",
473            "(Ljava/lang/Object;)I",
474            (right.clone(),),
475        )
476        .await
477    }
478
479    pub(super) async fn find_entry(
480        jvm: &Jvm,
481        this: &ClassInstanceRef<Self>,
482        key: &ClassInstanceRef<Object>,
483    ) -> Result<ClassInstanceRef<TreeMapEntry>> {
484        let comparator: ClassInstanceRef<Object> = jvm.get_field(this, "java/util/TreeMap", "comparator", "Ljava/util/Comparator;").await?;
485        if comparator.is_null() {
486            if key.is_null() {
487                return Err(jvm.exception("java/lang/NullPointerException", "null key").await);
488            }
489            if !jvm.is_instance(key.as_ref(), "java/lang/Comparable") {
490                return Err(jvm.exception("java/lang/ClassCastException", "key is not Comparable").await);
491            }
492        }
493
494        let mut entry: ClassInstanceRef<TreeMapEntry> = jvm.get_field(this, "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;").await?;
495        while !entry.is_null() {
496            let stored_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;").await?;
497            let comparison: i32 = if comparator.is_null() {
498                jvm.invoke_virtual(key, &key.class_definition().name(), "compareTo", "(Ljava/lang/Object;)I", (stored_key,))
499                    .await?
500            } else {
501                jvm.invoke_virtual(
502                    &comparator,
503                    &comparator.class_definition().name(),
504                    "compare",
505                    "(Ljava/lang/Object;Ljava/lang/Object;)I",
506                    (key.clone(), stored_key),
507                )
508                .await?
509            };
510            if comparison == 0 {
511                return Ok(entry);
512            }
513            entry = if comparison < 0 {
514                jvm.get_field(&entry, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;")
515                    .await?
516            } else {
517                jvm.get_field(&entry, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;")
518                    .await?
519            };
520        }
521        Ok(None.into())
522    }
523
524    pub(super) async fn first_entry(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<ClassInstanceRef<TreeMapEntry>> {
525        let mut entry: ClassInstanceRef<TreeMapEntry> = jvm.get_field(this, "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;").await?;
526        if entry.is_null() {
527            return Ok(entry);
528        }
529        loop {
530            let left: ClassInstanceRef<TreeMapEntry> = jvm
531                .get_field(&entry, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;")
532                .await?;
533            if left.is_null() {
534                return Ok(entry);
535            }
536            entry = left;
537        }
538    }
539
540    pub(super) async fn last_entry(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<ClassInstanceRef<TreeMapEntry>> {
541        let mut entry: ClassInstanceRef<TreeMapEntry> = jvm.get_field(this, "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;").await?;
542        if entry.is_null() {
543            return Ok(entry);
544        }
545        loop {
546            let right: ClassInstanceRef<TreeMapEntry> = jvm
547                .get_field(&entry, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;")
548                .await?;
549            if right.is_null() {
550                return Ok(entry);
551            }
552            entry = right;
553        }
554    }
555
556    pub(super) async fn ceiling_entry(
557        jvm: &Jvm,
558        this: &ClassInstanceRef<Self>,
559        key: &ClassInstanceRef<Object>,
560    ) -> Result<ClassInstanceRef<TreeMapEntry>> {
561        let mut entry: ClassInstanceRef<TreeMapEntry> = jvm.get_field(this, "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;").await?;
562        let mut candidate: ClassInstanceRef<TreeMapEntry> = None.into();
563        while !entry.is_null() {
564            let stored_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;").await?;
565            let comparison = Self::compare(jvm, this, key, &stored_key).await?;
566            if comparison == 0 {
567                return Ok(entry);
568            }
569            if comparison < 0 {
570                candidate = entry.clone();
571                entry = jvm
572                    .get_field(&entry, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;")
573                    .await?;
574            } else {
575                entry = jvm
576                    .get_field(&entry, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;")
577                    .await?;
578            }
579        }
580        Ok(candidate)
581    }
582
583    pub(super) async fn lower_entry(
584        jvm: &Jvm,
585        this: &ClassInstanceRef<Self>,
586        key: &ClassInstanceRef<Object>,
587    ) -> Result<ClassInstanceRef<TreeMapEntry>> {
588        let mut entry: ClassInstanceRef<TreeMapEntry> = jvm.get_field(this, "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;").await?;
589        let mut candidate: ClassInstanceRef<TreeMapEntry> = None.into();
590        while !entry.is_null() {
591            let stored_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;").await?;
592            if Self::compare(jvm, this, key, &stored_key).await? <= 0 {
593                entry = jvm
594                    .get_field(&entry, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;")
595                    .await?;
596            } else {
597                candidate = entry.clone();
598                entry = jvm
599                    .get_field(&entry, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;")
600                    .await?;
601            }
602        }
603        Ok(candidate)
604    }
605
606    pub(super) async fn successor(jvm: &Jvm, entry: ClassInstanceRef<TreeMapEntry>) -> Result<ClassInstanceRef<TreeMapEntry>> {
607        if entry.is_null() {
608            return Ok(None.into());
609        }
610        let right: ClassInstanceRef<TreeMapEntry> = jvm
611            .get_field(&entry, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;")
612            .await?;
613        if !right.is_null() {
614            let mut candidate = right;
615            loop {
616                let left: ClassInstanceRef<TreeMapEntry> = jvm
617                    .get_field(&candidate, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;")
618                    .await?;
619                if left.is_null() {
620                    return Ok(candidate);
621                }
622                candidate = left;
623            }
624        }
625
626        let mut child = entry;
627        let mut parent: ClassInstanceRef<TreeMapEntry> = jvm
628            .get_field(&child, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;")
629            .await?;
630        while !parent.is_null() {
631            let parent_right: ClassInstanceRef<TreeMapEntry> = jvm
632                .get_field(&parent, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;")
633                .await?;
634            if parent_right.is_null() || child.identity() != parent_right.identity() {
635                break;
636            }
637            child = parent;
638            parent = jvm
639                .get_field(&child, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;")
640                .await?;
641        }
642        Ok(parent)
643    }
644
645    async fn rotate_left(jvm: &Jvm, this: &mut ClassInstanceRef<Self>, mut pivot: ClassInstanceRef<TreeMapEntry>) -> Result<()> {
646        let mut right: ClassInstanceRef<TreeMapEntry> = jvm
647            .get_field(&pivot, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;")
648            .await?;
649        let right_left: ClassInstanceRef<TreeMapEntry> = jvm
650            .get_field(&right, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;")
651            .await?;
652        jvm.put_field(
653            &mut pivot,
654            "java/util/TreeMap$Entry",
655            "right",
656            "Ljava/util/TreeMap$Entry;",
657            right_left.clone(),
658        )
659        .await?;
660        if !right_left.is_null() {
661            let mut right_left = right_left;
662            jvm.put_field(
663                &mut right_left,
664                "java/util/TreeMap$Entry",
665                "parent",
666                "Ljava/util/TreeMap$Entry;",
667                pivot.clone(),
668            )
669            .await?;
670        }
671        let parent: ClassInstanceRef<TreeMapEntry> = jvm
672            .get_field(&pivot, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;")
673            .await?;
674        jvm.put_field(
675            &mut right,
676            "java/util/TreeMap$Entry",
677            "parent",
678            "Ljava/util/TreeMap$Entry;",
679            parent.clone(),
680        )
681        .await?;
682        if parent.is_null() {
683            jvm.put_field(this, "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;", right.clone())
684                .await?;
685        } else {
686            let parent_left: ClassInstanceRef<TreeMapEntry> = jvm
687                .get_field(&parent, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;")
688                .await?;
689            let mut parent = parent;
690            if !parent_left.is_null() && parent_left.identity() == pivot.identity() {
691                jvm.put_field(&mut parent, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;", right.clone())
692                    .await?;
693            } else {
694                jvm.put_field(
695                    &mut parent,
696                    "java/util/TreeMap$Entry",
697                    "right",
698                    "Ljava/util/TreeMap$Entry;",
699                    right.clone(),
700                )
701                .await?;
702            }
703        }
704        jvm.put_field(&mut right, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;", pivot.clone())
705            .await?;
706        jvm.put_field(&mut pivot, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;", right)
707            .await
708    }
709
710    async fn rotate_right(jvm: &Jvm, this: &mut ClassInstanceRef<Self>, mut pivot: ClassInstanceRef<TreeMapEntry>) -> Result<()> {
711        let mut left: ClassInstanceRef<TreeMapEntry> = jvm
712            .get_field(&pivot, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;")
713            .await?;
714        let left_right: ClassInstanceRef<TreeMapEntry> = jvm
715            .get_field(&left, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;")
716            .await?;
717        jvm.put_field(
718            &mut pivot,
719            "java/util/TreeMap$Entry",
720            "left",
721            "Ljava/util/TreeMap$Entry;",
722            left_right.clone(),
723        )
724        .await?;
725        if !left_right.is_null() {
726            let mut left_right = left_right;
727            jvm.put_field(
728                &mut left_right,
729                "java/util/TreeMap$Entry",
730                "parent",
731                "Ljava/util/TreeMap$Entry;",
732                pivot.clone(),
733            )
734            .await?;
735        }
736        let parent: ClassInstanceRef<TreeMapEntry> = jvm
737            .get_field(&pivot, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;")
738            .await?;
739        jvm.put_field(
740            &mut left,
741            "java/util/TreeMap$Entry",
742            "parent",
743            "Ljava/util/TreeMap$Entry;",
744            parent.clone(),
745        )
746        .await?;
747        if parent.is_null() {
748            jvm.put_field(this, "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;", left.clone())
749                .await?;
750        } else {
751            let parent_right: ClassInstanceRef<TreeMapEntry> = jvm
752                .get_field(&parent, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;")
753                .await?;
754            let mut parent = parent;
755            if !parent_right.is_null() && parent_right.identity() == pivot.identity() {
756                jvm.put_field(&mut parent, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;", left.clone())
757                    .await?;
758            } else {
759                jvm.put_field(&mut parent, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;", left.clone())
760                    .await?;
761            }
762        }
763        jvm.put_field(&mut left, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;", pivot.clone())
764            .await?;
765        jvm.put_field(&mut pivot, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;", left)
766            .await
767    }
768
769    async fn fix_after_insertion(jvm: &Jvm, this: &mut ClassInstanceRef<Self>, mut entry: ClassInstanceRef<TreeMapEntry>) -> Result<()> {
770        jvm.put_field(&mut entry, "java/util/TreeMap$Entry", "color", "Z", false).await?;
771        loop {
772            let root: ClassInstanceRef<TreeMapEntry> = jvm.get_field(this, "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;").await?;
773            if entry.identity() == root.identity() {
774                break;
775            }
776            let mut parent: ClassInstanceRef<TreeMapEntry> = jvm
777                .get_field(&entry, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;")
778                .await?;
779            if parent.is_null() || jvm.get_field::<bool>(&parent, "java/util/TreeMap$Entry", "color", "Z").await? {
780                break;
781            }
782            let mut grand: ClassInstanceRef<TreeMapEntry> = jvm
783                .get_field(&parent, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;")
784                .await?;
785            let grand_left: ClassInstanceRef<TreeMapEntry> = jvm
786                .get_field(&grand, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;")
787                .await?;
788            if !grand_left.is_null() && grand_left.identity() == parent.identity() {
789                let mut uncle: ClassInstanceRef<TreeMapEntry> = jvm
790                    .get_field(&grand, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;")
791                    .await?;
792                let uncle_is_red = !uncle.is_null() && !jvm.get_field::<bool>(&uncle, "java/util/TreeMap$Entry", "color", "Z").await?;
793                if uncle_is_red {
794                    jvm.put_field(&mut parent, "java/util/TreeMap$Entry", "color", "Z", true).await?;
795                    jvm.put_field(&mut uncle, "java/util/TreeMap$Entry", "color", "Z", true).await?;
796                    jvm.put_field(&mut grand, "java/util/TreeMap$Entry", "color", "Z", false).await?;
797                    entry = grand;
798                    continue;
799                }
800                let parent_right: ClassInstanceRef<TreeMapEntry> = jvm
801                    .get_field(&parent, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;")
802                    .await?;
803                if !parent_right.is_null() && parent_right.identity() == entry.identity() {
804                    entry = parent.clone();
805                    Self::rotate_left(jvm, this, entry.clone()).await?;
806                    parent = jvm
807                        .get_field(&entry, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;")
808                        .await?;
809                    grand = jvm
810                        .get_field(&parent, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;")
811                        .await?;
812                }
813                jvm.put_field(&mut parent, "java/util/TreeMap$Entry", "color", "Z", true).await?;
814                jvm.put_field(&mut grand, "java/util/TreeMap$Entry", "color", "Z", false).await?;
815                Self::rotate_right(jvm, this, grand).await?;
816            } else {
817                let mut uncle: ClassInstanceRef<TreeMapEntry> = jvm
818                    .get_field(&grand, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;")
819                    .await?;
820                let uncle_is_red = !uncle.is_null() && !jvm.get_field::<bool>(&uncle, "java/util/TreeMap$Entry", "color", "Z").await?;
821                if uncle_is_red {
822                    jvm.put_field(&mut parent, "java/util/TreeMap$Entry", "color", "Z", true).await?;
823                    jvm.put_field(&mut uncle, "java/util/TreeMap$Entry", "color", "Z", true).await?;
824                    jvm.put_field(&mut grand, "java/util/TreeMap$Entry", "color", "Z", false).await?;
825                    entry = grand;
826                    continue;
827                }
828                let parent_left: ClassInstanceRef<TreeMapEntry> = jvm
829                    .get_field(&parent, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;")
830                    .await?;
831                if !parent_left.is_null() && parent_left.identity() == entry.identity() {
832                    entry = parent.clone();
833                    Self::rotate_right(jvm, this, entry.clone()).await?;
834                    parent = jvm
835                        .get_field(&entry, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;")
836                        .await?;
837                    grand = jvm
838                        .get_field(&parent, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;")
839                        .await?;
840                }
841                jvm.put_field(&mut parent, "java/util/TreeMap$Entry", "color", "Z", true).await?;
842                jvm.put_field(&mut grand, "java/util/TreeMap$Entry", "color", "Z", false).await?;
843                Self::rotate_left(jvm, this, grand).await?;
844            }
845        }
846        let mut root: ClassInstanceRef<TreeMapEntry> = jvm.get_field(this, "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;").await?;
847        jvm.put_field(&mut root, "java/util/TreeMap$Entry", "color", "Z", true).await?;
848        Ok(())
849    }
850
851    pub(super) async fn delete_entry(jvm: &Jvm, this: &mut ClassInstanceRef<Self>, entry: ClassInstanceRef<TreeMapEntry>) -> Result<()> {
852        let size: i32 = jvm.get_field(this, "java/util/TreeMap", "size", "I").await?;
853        jvm.put_field(this, "java/util/TreeMap", "size", "I", size - 1).await?;
854
855        let mut target = entry;
856        let left: ClassInstanceRef<TreeMapEntry> = jvm
857            .get_field(&target, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;")
858            .await?;
859        let right: ClassInstanceRef<TreeMapEntry> = jvm
860            .get_field(&target, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;")
861            .await?;
862        if !left.is_null() && !right.is_null() {
863            let successor = Self::successor(jvm, target.clone()).await?;
864            let key: ClassInstanceRef<Object> = jvm.get_field(&successor, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;").await?;
865            let value: ClassInstanceRef<Object> = jvm
866                .get_field(&successor, "java/util/TreeMap$Entry", "value", "Ljava/lang/Object;")
867                .await?;
868            jvm.put_field(&mut target, "java/util/TreeMap$Entry", "key", "Ljava/lang/Object;", key)
869                .await?;
870            jvm.put_field(&mut target, "java/util/TreeMap$Entry", "value", "Ljava/lang/Object;", value)
871                .await?;
872            target = successor;
873        }
874
875        let target_left: ClassInstanceRef<TreeMapEntry> = jvm
876            .get_field(&target, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;")
877            .await?;
878        let target_right: ClassInstanceRef<TreeMapEntry> = jvm
879            .get_field(&target, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;")
880            .await?;
881        let mut replacement = if !target_left.is_null() { target_left } else { target_right };
882        if !replacement.is_null() {
883            let parent: ClassInstanceRef<TreeMapEntry> = jvm
884                .get_field(&target, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;")
885                .await?;
886            jvm.put_field(
887                &mut replacement,
888                "java/util/TreeMap$Entry",
889                "parent",
890                "Ljava/util/TreeMap$Entry;",
891                parent.clone(),
892            )
893            .await?;
894            if parent.is_null() {
895                jvm.put_field(this, "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;", replacement.clone())
896                    .await?;
897            } else {
898                let parent_left: ClassInstanceRef<TreeMapEntry> = jvm
899                    .get_field(&parent, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;")
900                    .await?;
901                let mut parent = parent;
902                if !parent_left.is_null() && parent_left.identity() == target.identity() {
903                    jvm.put_field(
904                        &mut parent,
905                        "java/util/TreeMap$Entry",
906                        "left",
907                        "Ljava/util/TreeMap$Entry;",
908                        replacement.clone(),
909                    )
910                    .await?;
911                } else {
912                    jvm.put_field(
913                        &mut parent,
914                        "java/util/TreeMap$Entry",
915                        "right",
916                        "Ljava/util/TreeMap$Entry;",
917                        replacement.clone(),
918                    )
919                    .await?;
920                }
921            }
922            jvm.put_field(
923                &mut target,
924                "java/util/TreeMap$Entry",
925                "left",
926                "Ljava/util/TreeMap$Entry;",
927                ClassInstanceRef::<TreeMapEntry>::from(None),
928            )
929            .await?;
930            jvm.put_field(
931                &mut target,
932                "java/util/TreeMap$Entry",
933                "right",
934                "Ljava/util/TreeMap$Entry;",
935                ClassInstanceRef::<TreeMapEntry>::from(None),
936            )
937            .await?;
938            jvm.put_field(
939                &mut target,
940                "java/util/TreeMap$Entry",
941                "parent",
942                "Ljava/util/TreeMap$Entry;",
943                ClassInstanceRef::<TreeMapEntry>::from(None),
944            )
945            .await?;
946            if jvm.get_field::<bool>(&target, "java/util/TreeMap$Entry", "color", "Z").await? {
947                Self::fix_after_deletion(jvm, this, replacement).await?;
948            }
949        } else {
950            let parent: ClassInstanceRef<TreeMapEntry> = jvm
951                .get_field(&target, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;")
952                .await?;
953            if parent.is_null() {
954                jvm.put_field(
955                    this,
956                    "java/util/TreeMap",
957                    "root",
958                    "Ljava/util/TreeMap$Entry;",
959                    ClassInstanceRef::<TreeMapEntry>::from(None),
960                )
961                .await?;
962            } else {
963                if jvm.get_field::<bool>(&target, "java/util/TreeMap$Entry", "color", "Z").await? {
964                    Self::fix_after_deletion(jvm, this, target.clone()).await?;
965                }
966                let parent: ClassInstanceRef<TreeMapEntry> = jvm
967                    .get_field(&target, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;")
968                    .await?;
969                if !parent.is_null() {
970                    let parent_left: ClassInstanceRef<TreeMapEntry> = jvm
971                        .get_field(&parent, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;")
972                        .await?;
973                    let parent_right: ClassInstanceRef<TreeMapEntry> = jvm
974                        .get_field(&parent, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;")
975                        .await?;
976                    let mut parent = parent;
977                    if !parent_left.is_null() && parent_left.identity() == target.identity() {
978                        jvm.put_field(
979                            &mut parent,
980                            "java/util/TreeMap$Entry",
981                            "left",
982                            "Ljava/util/TreeMap$Entry;",
983                            ClassInstanceRef::<TreeMapEntry>::from(None),
984                        )
985                        .await?;
986                    } else if !parent_right.is_null() && parent_right.identity() == target.identity() {
987                        jvm.put_field(
988                            &mut parent,
989                            "java/util/TreeMap$Entry",
990                            "right",
991                            "Ljava/util/TreeMap$Entry;",
992                            ClassInstanceRef::<TreeMapEntry>::from(None),
993                        )
994                        .await?;
995                    }
996                    jvm.put_field(
997                        &mut target,
998                        "java/util/TreeMap$Entry",
999                        "parent",
1000                        "Ljava/util/TreeMap$Entry;",
1001                        ClassInstanceRef::<TreeMapEntry>::from(None),
1002                    )
1003                    .await?;
1004                }
1005            }
1006        }
1007        Ok(())
1008    }
1009
1010    async fn fix_after_deletion(jvm: &Jvm, this: &mut ClassInstanceRef<Self>, mut entry: ClassInstanceRef<TreeMapEntry>) -> Result<()> {
1011        loop {
1012            let root: ClassInstanceRef<TreeMapEntry> = jvm.get_field(this, "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;").await?;
1013            if entry.identity() == root.identity() || !jvm.get_field::<bool>(&entry, "java/util/TreeMap$Entry", "color", "Z").await? {
1014                break;
1015            }
1016            let parent: ClassInstanceRef<TreeMapEntry> = jvm
1017                .get_field(&entry, "java/util/TreeMap$Entry", "parent", "Ljava/util/TreeMap$Entry;")
1018                .await?;
1019            let parent_left: ClassInstanceRef<TreeMapEntry> = jvm
1020                .get_field(&parent, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;")
1021                .await?;
1022            if !parent_left.is_null() && parent_left.identity() == entry.identity() {
1023                let mut sibling: ClassInstanceRef<TreeMapEntry> = jvm
1024                    .get_field(&parent, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;")
1025                    .await?;
1026                if !sibling.is_null() && !jvm.get_field::<bool>(&sibling, "java/util/TreeMap$Entry", "color", "Z").await? {
1027                    jvm.put_field(&mut sibling, "java/util/TreeMap$Entry", "color", "Z", true).await?;
1028                    let mut parent = parent.clone();
1029                    jvm.put_field(&mut parent, "java/util/TreeMap$Entry", "color", "Z", false).await?;
1030                    Self::rotate_left(jvm, this, parent.clone()).await?;
1031                    sibling = jvm
1032                        .get_field(&parent, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;")
1033                        .await?;
1034                }
1035                let sibling_left: ClassInstanceRef<TreeMapEntry> = if sibling.is_null() {
1036                    None.into()
1037                } else {
1038                    jvm.get_field(&sibling, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;")
1039                        .await?
1040                };
1041                let sibling_right: ClassInstanceRef<TreeMapEntry> = if sibling.is_null() {
1042                    None.into()
1043                } else {
1044                    jvm.get_field(&sibling, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;")
1045                        .await?
1046                };
1047                let left_black = sibling_left.is_null() || jvm.get_field::<bool>(&sibling_left, "java/util/TreeMap$Entry", "color", "Z").await?;
1048                let right_black = sibling_right.is_null() || jvm.get_field::<bool>(&sibling_right, "java/util/TreeMap$Entry", "color", "Z").await?;
1049                if left_black && right_black {
1050                    if !sibling.is_null() {
1051                        jvm.put_field(&mut sibling, "java/util/TreeMap$Entry", "color", "Z", false).await?;
1052                    }
1053                    entry = parent;
1054                } else {
1055                    if right_black {
1056                        if !sibling_left.is_null() {
1057                            let mut sibling_left = sibling_left;
1058                            jvm.put_field(&mut sibling_left, "java/util/TreeMap$Entry", "color", "Z", true).await?;
1059                        }
1060                        if !sibling.is_null() {
1061                            jvm.put_field(&mut sibling, "java/util/TreeMap$Entry", "color", "Z", false).await?;
1062                            Self::rotate_right(jvm, this, sibling.clone()).await?;
1063                        }
1064                        sibling = jvm
1065                            .get_field(&parent, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;")
1066                            .await?;
1067                    }
1068                    if !sibling.is_null() {
1069                        let parent_color: bool = jvm.get_field(&parent, "java/util/TreeMap$Entry", "color", "Z").await?;
1070                        jvm.put_field(&mut sibling, "java/util/TreeMap$Entry", "color", "Z", parent_color).await?;
1071                    }
1072                    let mut parent = parent;
1073                    jvm.put_field(&mut parent, "java/util/TreeMap$Entry", "color", "Z", true).await?;
1074                    if !sibling.is_null() {
1075                        let mut sibling_right: ClassInstanceRef<TreeMapEntry> = jvm
1076                            .get_field(&sibling, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;")
1077                            .await?;
1078                        if !sibling_right.is_null() {
1079                            jvm.put_field(&mut sibling_right, "java/util/TreeMap$Entry", "color", "Z", true).await?;
1080                        }
1081                    }
1082                    Self::rotate_left(jvm, this, parent).await?;
1083                    entry = jvm.get_field(this, "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;").await?;
1084                }
1085            } else {
1086                let mut sibling: ClassInstanceRef<TreeMapEntry> = jvm
1087                    .get_field(&parent, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;")
1088                    .await?;
1089                if !sibling.is_null() && !jvm.get_field::<bool>(&sibling, "java/util/TreeMap$Entry", "color", "Z").await? {
1090                    jvm.put_field(&mut sibling, "java/util/TreeMap$Entry", "color", "Z", true).await?;
1091                    let mut parent = parent.clone();
1092                    jvm.put_field(&mut parent, "java/util/TreeMap$Entry", "color", "Z", false).await?;
1093                    Self::rotate_right(jvm, this, parent.clone()).await?;
1094                    sibling = jvm
1095                        .get_field(&parent, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;")
1096                        .await?;
1097                }
1098                let sibling_left: ClassInstanceRef<TreeMapEntry> = if sibling.is_null() {
1099                    None.into()
1100                } else {
1101                    jvm.get_field(&sibling, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;")
1102                        .await?
1103                };
1104                let sibling_right: ClassInstanceRef<TreeMapEntry> = if sibling.is_null() {
1105                    None.into()
1106                } else {
1107                    jvm.get_field(&sibling, "java/util/TreeMap$Entry", "right", "Ljava/util/TreeMap$Entry;")
1108                        .await?
1109                };
1110                let left_black = sibling_left.is_null() || jvm.get_field::<bool>(&sibling_left, "java/util/TreeMap$Entry", "color", "Z").await?;
1111                let right_black = sibling_right.is_null() || jvm.get_field::<bool>(&sibling_right, "java/util/TreeMap$Entry", "color", "Z").await?;
1112                if left_black && right_black {
1113                    if !sibling.is_null() {
1114                        jvm.put_field(&mut sibling, "java/util/TreeMap$Entry", "color", "Z", false).await?;
1115                    }
1116                    entry = parent;
1117                } else {
1118                    if left_black {
1119                        if !sibling_right.is_null() {
1120                            let mut sibling_right = sibling_right;
1121                            jvm.put_field(&mut sibling_right, "java/util/TreeMap$Entry", "color", "Z", true).await?;
1122                        }
1123                        if !sibling.is_null() {
1124                            jvm.put_field(&mut sibling, "java/util/TreeMap$Entry", "color", "Z", false).await?;
1125                            Self::rotate_left(jvm, this, sibling.clone()).await?;
1126                        }
1127                        sibling = jvm
1128                            .get_field(&parent, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;")
1129                            .await?;
1130                    }
1131                    if !sibling.is_null() {
1132                        let parent_color: bool = jvm.get_field(&parent, "java/util/TreeMap$Entry", "color", "Z").await?;
1133                        jvm.put_field(&mut sibling, "java/util/TreeMap$Entry", "color", "Z", parent_color).await?;
1134                    }
1135                    let mut parent = parent;
1136                    jvm.put_field(&mut parent, "java/util/TreeMap$Entry", "color", "Z", true).await?;
1137                    if !sibling.is_null() {
1138                        let mut sibling_left: ClassInstanceRef<TreeMapEntry> = jvm
1139                            .get_field(&sibling, "java/util/TreeMap$Entry", "left", "Ljava/util/TreeMap$Entry;")
1140                            .await?;
1141                        if !sibling_left.is_null() {
1142                            jvm.put_field(&mut sibling_left, "java/util/TreeMap$Entry", "color", "Z", true).await?;
1143                        }
1144                    }
1145                    Self::rotate_right(jvm, this, parent).await?;
1146                    entry = jvm.get_field(this, "java/util/TreeMap", "root", "Ljava/util/TreeMap$Entry;").await?;
1147                }
1148            }
1149        }
1150        if !entry.is_null() {
1151            jvm.put_field(&mut entry, "java/util/TreeMap$Entry", "color", "Z", true).await?;
1152        }
1153        Ok(())
1154    }
1155}