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
11pub 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}