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