Skip to main content

rustjava_runtime/classes/java/util/
tree_set.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
9// public class java.util.TreeSet
10pub struct TreeSet;
11
12impl TreeSet {
13    pub fn as_proto() -> RuntimeClassProto {
14        RuntimeClassProto {
15            name: "java/util/TreeSet",
16            parent_class: Some("java/util/AbstractSet"),
17            interfaces: vec!["java/util/SortedSet", "java/lang/Cloneable", "java/io/Serializable"],
18            methods: vec![
19                JavaMethodProto::new("<clinit>", "()V", Self::clinit, MethodAccessFlags::STATIC),
20                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
21                JavaMethodProto::new("<init>", "(Ljava/util/Comparator;)V", Self::init_comparator, MethodAccessFlags::PUBLIC),
22                JavaMethodProto::new("<init>", "(Ljava/util/Collection;)V", Self::init_collection, MethodAccessFlags::PUBLIC),
23                JavaMethodProto::new("<init>", "(Ljava/util/SortedSet;)V", Self::init_sorted_set, MethodAccessFlags::PUBLIC),
24                JavaMethodProto::new("<init>", "(Ljava/util/SortedMap;)V", Self::init_sorted_map, MethodAccessFlags::PRIVATE),
25                JavaMethodProto::new("size", "()I", Self::size, MethodAccessFlags::PUBLIC),
26                JavaMethodProto::new("contains", "(Ljava/lang/Object;)Z", Self::contains, MethodAccessFlags::PUBLIC),
27                JavaMethodProto::new("add", "(Ljava/lang/Object;)Z", Self::add, MethodAccessFlags::PUBLIC),
28                JavaMethodProto::new("remove", "(Ljava/lang/Object;)Z", Self::remove, MethodAccessFlags::PUBLIC),
29                JavaMethodProto::new("clear", "()V", Self::clear, MethodAccessFlags::PUBLIC),
30                JavaMethodProto::new("iterator", "()Ljava/util/Iterator;", Self::iterator, MethodAccessFlags::PUBLIC),
31                JavaMethodProto::new("comparator", "()Ljava/util/Comparator;", Self::comparator, MethodAccessFlags::PUBLIC),
32                JavaMethodProto::new("first", "()Ljava/lang/Object;", Self::first, MethodAccessFlags::PUBLIC),
33                JavaMethodProto::new("last", "()Ljava/lang/Object;", Self::last, MethodAccessFlags::PUBLIC),
34                JavaMethodProto::new(
35                    "subSet",
36                    "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/SortedSet;",
37                    Self::sub_set,
38                    MethodAccessFlags::PUBLIC,
39                ),
40                JavaMethodProto::new(
41                    "headSet",
42                    "(Ljava/lang/Object;)Ljava/util/SortedSet;",
43                    Self::head_set,
44                    MethodAccessFlags::PUBLIC,
45                ),
46                JavaMethodProto::new(
47                    "tailSet",
48                    "(Ljava/lang/Object;)Ljava/util/SortedSet;",
49                    Self::tail_set,
50                    MethodAccessFlags::PUBLIC,
51                ),
52            ],
53            fields: vec![
54                JavaFieldProto::new("m", "Ljava/util/SortedMap;", FieldAccessFlags::PRIVATE | FieldAccessFlags::TRANSIENT),
55                JavaFieldProto::new(
56                    "PRESENT",
57                    "Ljava/lang/Object;",
58                    FieldAccessFlags::PRIVATE | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
59                ),
60            ],
61            access_flags: ClassAccessFlags::PUBLIC,
62        }
63    }
64
65    async fn clinit(jvm: &Jvm, _: &mut RuntimeContext) -> Result<()> {
66        let present: ClassInstanceRef<Object> = jvm.new_class("java/lang/Object", "()V", ()).await?.into();
67        jvm.put_static_field("java/util/TreeSet", "PRESENT", "Ljava/lang/Object;", present).await
68    }
69
70    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
71        let _: () = jvm.invoke_special(&this, "java/util/AbstractSet", "<init>", "()V", ()).await?;
72        let map: ClassInstanceRef<Object> = jvm.new_class("java/util/TreeMap", "()V", ()).await?.into();
73        let mut this = this;
74        jvm.put_field(&mut this, "java/util/TreeSet", "m", "Ljava/util/SortedMap;", map).await
75    }
76
77    async fn init_comparator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, comparator: ClassInstanceRef<Object>) -> Result<()> {
78        let _: () = jvm.invoke_special(&this, "java/util/AbstractSet", "<init>", "()V", ()).await?;
79        let map: ClassInstanceRef<Object> = jvm
80            .new_class("java/util/TreeMap", "(Ljava/util/Comparator;)V", (comparator,))
81            .await?
82            .into();
83        let mut this = this;
84        jvm.put_field(&mut this, "java/util/TreeSet", "m", "Ljava/util/SortedMap;", map).await
85    }
86
87    async fn init_collection(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, collection: ClassInstanceRef<Object>) -> Result<()> {
88        if collection.is_null() {
89            return Err(jvm.exception("java/lang/NullPointerException", "collection").await);
90        }
91        let _: () = jvm.invoke_special(&this, "java/util/TreeSet", "<init>", "()V", ()).await?;
92        let _: bool = jvm
93            .invoke_virtual(&this, "java/util/TreeSet", "addAll", "(Ljava/util/Collection;)Z", (collection,))
94            .await?;
95        Ok(())
96    }
97
98    async fn init_sorted_set(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, set: ClassInstanceRef<Object>) -> Result<()> {
99        if set.is_null() {
100            return Err(jvm.exception("java/lang/NullPointerException", "set").await);
101        }
102        let comparator: ClassInstanceRef<Object> = jvm
103            .invoke_virtual(&set, &set.class_definition().name(), "comparator", "()Ljava/util/Comparator;", ())
104            .await?;
105        let _: () = jvm
106            .invoke_special(&this, "java/util/TreeSet", "<init>", "(Ljava/util/Comparator;)V", (comparator,))
107            .await?;
108        let _: bool = jvm
109            .invoke_virtual(&this, "java/util/TreeSet", "addAll", "(Ljava/util/Collection;)Z", (set,))
110            .await?;
111        Ok(())
112    }
113
114    async fn init_sorted_map(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, map: ClassInstanceRef<Object>) -> Result<()> {
115        if map.is_null() {
116            return Err(jvm.exception("java/lang/NullPointerException", "map").await);
117        }
118        let _: () = jvm.invoke_special(&this, "java/util/AbstractSet", "<init>", "()V", ()).await?;
119        jvm.put_field(&mut this, "java/util/TreeSet", "m", "Ljava/util/SortedMap;", map).await
120    }
121
122    async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
123        let map: ClassInstanceRef<Object> = jvm.get_field(&this, "java/util/TreeSet", "m", "Ljava/util/SortedMap;").await?;
124        jvm.invoke_virtual(&map, &map.class_definition().name(), "size", "()I", ()).await
125    }
126
127    async fn contains(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<bool> {
128        let map: ClassInstanceRef<Object> = jvm.get_field(&this, "java/util/TreeSet", "m", "Ljava/util/SortedMap;").await?;
129        jvm.invoke_virtual(&map, &map.class_definition().name(), "containsKey", "(Ljava/lang/Object;)Z", (element,))
130            .await
131    }
132
133    async fn add(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<bool> {
134        let map: ClassInstanceRef<Object> = jvm.get_field(&this, "java/util/TreeSet", "m", "Ljava/util/SortedMap;").await?;
135        let present: ClassInstanceRef<Object> = jvm.get_static_field("java/util/TreeSet", "PRESENT", "Ljava/lang/Object;").await?;
136        let old: ClassInstanceRef<Object> = jvm
137            .invoke_virtual(
138                &map,
139                &map.class_definition().name(),
140                "put",
141                "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
142                (element, present),
143            )
144            .await?;
145        Ok(old.is_null())
146    }
147
148    async fn remove(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<bool> {
149        let map: ClassInstanceRef<Object> = jvm.get_field(&this, "java/util/TreeSet", "m", "Ljava/util/SortedMap;").await?;
150        if !jvm
151            .invoke_virtual::<_, bool>(
152                &map,
153                &map.class_definition().name(),
154                "containsKey",
155                "(Ljava/lang/Object;)Z",
156                (element.clone(),),
157            )
158            .await?
159        {
160            return Ok(false);
161        }
162        let _: ClassInstanceRef<Object> = jvm
163            .invoke_virtual(
164                &map,
165                &map.class_definition().name(),
166                "remove",
167                "(Ljava/lang/Object;)Ljava/lang/Object;",
168                (element,),
169            )
170            .await?;
171        Ok(true)
172    }
173
174    async fn clear(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
175        let map: ClassInstanceRef<Object> = jvm.get_field(&this, "java/util/TreeSet", "m", "Ljava/util/SortedMap;").await?;
176        jvm.invoke_virtual(&map, &map.class_definition().name(), "clear", "()V", ()).await
177    }
178
179    async fn iterator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
180        let map: ClassInstanceRef<Object> = jvm.get_field(&this, "java/util/TreeSet", "m", "Ljava/util/SortedMap;").await?;
181        let keys: ClassInstanceRef<Object> = jvm
182            .invoke_virtual(&map, &map.class_definition().name(), "keySet", "()Ljava/util/Set;", ())
183            .await?;
184        jvm.invoke_virtual(&keys, &keys.class_definition().name(), "iterator", "()Ljava/util/Iterator;", ())
185            .await
186    }
187
188    async fn comparator(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
189        let map: ClassInstanceRef<Object> = jvm.get_field(&this, "java/util/TreeSet", "m", "Ljava/util/SortedMap;").await?;
190        jvm.invoke_virtual(&map, &map.class_definition().name(), "comparator", "()Ljava/util/Comparator;", ())
191            .await
192    }
193
194    async fn first(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
195        let map: ClassInstanceRef<Object> = jvm.get_field(&this, "java/util/TreeSet", "m", "Ljava/util/SortedMap;").await?;
196        jvm.invoke_virtual(&map, &map.class_definition().name(), "firstKey", "()Ljava/lang/Object;", ())
197            .await
198    }
199
200    async fn last(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
201        let map: ClassInstanceRef<Object> = jvm.get_field(&this, "java/util/TreeSet", "m", "Ljava/util/SortedMap;").await?;
202        jvm.invoke_virtual(&map, &map.class_definition().name(), "lastKey", "()Ljava/lang/Object;", ())
203            .await
204    }
205
206    async fn sub_set(
207        jvm: &Jvm,
208        _: &mut RuntimeContext,
209        this: ClassInstanceRef<Self>,
210        from: ClassInstanceRef<Object>,
211        to: ClassInstanceRef<Object>,
212    ) -> Result<ClassInstanceRef<Object>> {
213        let map: ClassInstanceRef<Object> = jvm.get_field(&this, "java/util/TreeSet", "m", "Ljava/util/SortedMap;").await?;
214        let range: ClassInstanceRef<Object> = jvm
215            .invoke_virtual(
216                &map,
217                &map.class_definition().name(),
218                "subMap",
219                "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/SortedMap;",
220                (from, to),
221            )
222            .await?;
223        Ok(jvm.new_class("java/util/TreeSet", "(Ljava/util/SortedMap;)V", (range,)).await?.into())
224    }
225
226    async fn head_set(
227        jvm: &Jvm,
228        _: &mut RuntimeContext,
229        this: ClassInstanceRef<Self>,
230        to: ClassInstanceRef<Object>,
231    ) -> Result<ClassInstanceRef<Object>> {
232        let map: ClassInstanceRef<Object> = jvm.get_field(&this, "java/util/TreeSet", "m", "Ljava/util/SortedMap;").await?;
233        let range: ClassInstanceRef<Object> = jvm
234            .invoke_virtual(
235                &map,
236                &map.class_definition().name(),
237                "headMap",
238                "(Ljava/lang/Object;)Ljava/util/SortedMap;",
239                (to,),
240            )
241            .await?;
242        Ok(jvm.new_class("java/util/TreeSet", "(Ljava/util/SortedMap;)V", (range,)).await?.into())
243    }
244
245    async fn tail_set(
246        jvm: &Jvm,
247        _: &mut RuntimeContext,
248        this: ClassInstanceRef<Self>,
249        from: ClassInstanceRef<Object>,
250    ) -> Result<ClassInstanceRef<Object>> {
251        let map: ClassInstanceRef<Object> = jvm.get_field(&this, "java/util/TreeSet", "m", "Ljava/util/SortedMap;").await?;
252        let range: ClassInstanceRef<Object> = jvm
253            .invoke_virtual(
254                &map,
255                &map.class_definition().name(),
256                "tailMap",
257                "(Ljava/lang/Object;)Ljava/util/SortedMap;",
258                (from,),
259            )
260            .await?;
261        Ok(jvm.new_class("java/util/TreeSet", "(Ljava/util/SortedMap;)V", (range,)).await?.into())
262    }
263}