Skip to main content

rustjava_runtime/classes/java/util/
tree_map_sub_map.rs

1use alloc::vec;
2
3use jvm::{ClassInstanceRef, Jvm, Result};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{RuntimeClassProto, RuntimeContext, classes::java::lang::Object};
8
9use super::{TreeMap, TreeMapEntry};
10
11// class java.util.TreeMap$SubMap
12pub struct TreeMapSubMap;
13
14impl TreeMapSubMap {
15    pub fn as_proto() -> RuntimeClassProto {
16        RuntimeClassProto {
17            name: "java/util/TreeMap$SubMap",
18            parent_class: Some("java/util/AbstractMap"),
19            interfaces: vec!["java/util/SortedMap"],
20            methods: vec![
21                JavaMethodProto::new(
22                    "<init>",
23                    "(Ljava/util/TreeMap;ZLjava/lang/Object;ZLjava/lang/Object;)V",
24                    Self::init,
25                    MethodAccessFlags::empty(),
26                ),
27                JavaMethodProto::new("size", "()I", Self::size, MethodAccessFlags::PUBLIC),
28                JavaMethodProto::new("containsKey", "(Ljava/lang/Object;)Z", Self::contains_key, MethodAccessFlags::PUBLIC),
29                JavaMethodProto::new("containsValue", "(Ljava/lang/Object;)Z", Self::contains_value, MethodAccessFlags::PUBLIC),
30                JavaMethodProto::new("get", "(Ljava/lang/Object;)Ljava/lang/Object;", Self::get, MethodAccessFlags::PUBLIC),
31                JavaMethodProto::new(
32                    "put",
33                    "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
34                    Self::put,
35                    MethodAccessFlags::PUBLIC,
36                ),
37                JavaMethodProto::new(
38                    "remove",
39                    "(Ljava/lang/Object;)Ljava/lang/Object;",
40                    Self::remove,
41                    MethodAccessFlags::PUBLIC,
42                ),
43                JavaMethodProto::new("clear", "()V", Self::clear, MethodAccessFlags::PUBLIC),
44                JavaMethodProto::new("comparator", "()Ljava/util/Comparator;", Self::comparator, MethodAccessFlags::PUBLIC),
45                JavaMethodProto::new("firstKey", "()Ljava/lang/Object;", Self::first_key, MethodAccessFlags::PUBLIC),
46                JavaMethodProto::new("lastKey", "()Ljava/lang/Object;", Self::last_key, MethodAccessFlags::PUBLIC),
47                JavaMethodProto::new(
48                    "subMap",
49                    "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/SortedMap;",
50                    Self::sub_map,
51                    MethodAccessFlags::PUBLIC,
52                ),
53                JavaMethodProto::new(
54                    "headMap",
55                    "(Ljava/lang/Object;)Ljava/util/SortedMap;",
56                    Self::head_map,
57                    MethodAccessFlags::PUBLIC,
58                ),
59                JavaMethodProto::new(
60                    "tailMap",
61                    "(Ljava/lang/Object;)Ljava/util/SortedMap;",
62                    Self::tail_map,
63                    MethodAccessFlags::PUBLIC,
64                ),
65                JavaMethodProto::new("keySet", "()Ljava/util/Set;", Self::key_set, MethodAccessFlags::PUBLIC),
66                JavaMethodProto::new("values", "()Ljava/util/Collection;", Self::values, MethodAccessFlags::PUBLIC),
67                JavaMethodProto::new("entrySet", "()Ljava/util/Set;", Self::entry_set, MethodAccessFlags::PUBLIC),
68                JavaMethodProto::new("keyIterator", "()Ljava/util/Iterator;", Self::key_iterator, MethodAccessFlags::empty()),
69                JavaMethodProto::new(
70                    "valueIterator",
71                    "()Ljava/util/Iterator;",
72                    Self::value_iterator,
73                    MethodAccessFlags::empty(),
74                ),
75                JavaMethodProto::new(
76                    "entryIterator",
77                    "()Ljava/util/Iterator;",
78                    Self::entry_iterator,
79                    MethodAccessFlags::empty(),
80                ),
81            ],
82            fields: vec![
83                JavaFieldProto::new("m", "Ljava/util/TreeMap;", FieldAccessFlags::PRIVATE),
84                JavaFieldProto::new("fromStart", "Z", FieldAccessFlags::PRIVATE),
85                JavaFieldProto::new("fromKey", "Ljava/lang/Object;", FieldAccessFlags::PRIVATE),
86                JavaFieldProto::new("toEnd", "Z", FieldAccessFlags::PRIVATE),
87                JavaFieldProto::new("toKey", "Ljava/lang/Object;", FieldAccessFlags::PRIVATE),
88            ],
89            access_flags: ClassAccessFlags::empty(),
90        }
91    }
92
93    #[allow(clippy::too_many_arguments)]
94    async fn init(
95        jvm: &Jvm,
96        _: &mut RuntimeContext,
97        mut this: ClassInstanceRef<Self>,
98        map: ClassInstanceRef<TreeMap>,
99        from_start: bool,
100        from_key: ClassInstanceRef<Object>,
101        to_end: bool,
102        to_key: ClassInstanceRef<Object>,
103    ) -> Result<()> {
104        if map.is_null() {
105            return Err(jvm.exception("java/lang/NullPointerException", "map").await);
106        }
107        if !from_start {
108            let _ = TreeMap::compare(jvm, &map, &from_key, &from_key).await?;
109        }
110        if !to_end {
111            let _ = TreeMap::compare(jvm, &map, &to_key, &to_key).await?;
112        }
113        if !from_start && !to_end && TreeMap::compare(jvm, &map, &from_key, &to_key).await? > 0 {
114            return Err(jvm.exception("java/lang/IllegalArgumentException", "fromKey > toKey").await);
115        }
116        let _: () = jvm.invoke_special(&this, "java/util/AbstractMap", "<init>", "()V", ()).await?;
117        jvm.put_field(&mut this, "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}