Skip to main content

rustjava_runtime/classes/java/util/
abstract_map.rs

1use alloc::vec;
2
3use jvm::{Array, ClassInstanceRef, JavaError, Jvm, Result, runtime::JavaLangString};
4use jvm_class_proto::JavaMethodProto;
5use jvm_types::{ClassAccessFlags, MethodAccessFlags};
6
7use crate::{RuntimeClassProto, RuntimeContext, classes::java::lang::Object};
8
9// abstract class java.util.AbstractMap
10pub struct AbstractMap;
11
12impl AbstractMap {
13    pub fn as_proto() -> RuntimeClassProto {
14        RuntimeClassProto {
15            name: "java/util/AbstractMap",
16            parent_class: Some("java/lang/Object"),
17            interfaces: vec!["java/util/Map"],
18            methods: vec![
19                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PROTECTED),
20                JavaMethodProto::new_abstract("size", "()I", MethodAccessFlags::PUBLIC | MethodAccessFlags::ABSTRACT),
21                JavaMethodProto::new("isEmpty", "()Z", Self::is_empty, MethodAccessFlags::PUBLIC),
22                JavaMethodProto::new("putAll", "(Ljava/util/Map;)V", Self::put_all, MethodAccessFlags::PUBLIC),
23                JavaMethodProto::new("equals", "(Ljava/lang/Object;)Z", Self::equals, MethodAccessFlags::PUBLIC),
24                JavaMethodProto::new("hashCode", "()I", Self::hash_code, MethodAccessFlags::PUBLIC),
25                JavaMethodProto::new("toString", "()Ljava/lang/String;", Self::to_string, MethodAccessFlags::PUBLIC),
26            ],
27            fields: vec![],
28            access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::ABSTRACT,
29        }
30    }
31
32    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
33        tracing::debug!("java.util.AbstractMap::<init>({this:?})");
34
35        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
36
37        Ok(())
38    }
39
40    async fn is_empty(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
41        tracing::debug!("java.util.AbstractMap::isEmpty({this:?})");
42
43        let size: i32 = jvm.invoke_virtual(&this, "java/util/AbstractMap", "size", "()I", ()).await?;
44
45        Ok(size == 0)
46    }
47
48    async fn put_all(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, map: ClassInstanceRef<Object>) -> Result<()> {
49        tracing::debug!("java.util.AbstractMap::putAll({this:?}, {map:?})");
50
51        if map.is_null() {
52            return Err(jvm.exception("java/lang/NullPointerException", "map").await);
53        }
54        if this.identity() == map.identity() {
55            return Ok(());
56        }
57
58        let entry_set: ClassInstanceRef<Object> = jvm
59            .invoke_virtual(&map, &map.class_definition().name(), "entrySet", "()Ljava/util/Set;", ())
60            .await?;
61        let entries: ClassInstanceRef<Array<Object>> = jvm
62            .invoke_virtual(&entry_set, &entry_set.class_definition().name(), "toArray", "()[Ljava/lang/Object;", ())
63            .await?;
64        let count = jvm.array_length(&entries).await?;
65        for entry in jvm.load_array::<ClassInstanceRef<Object>>(&entries, 0, count).await? {
66            let key: ClassInstanceRef<Object> = jvm
67                .invoke_virtual(&entry, &entry.class_definition().name(), "getKey", "()Ljava/lang/Object;", ())
68                .await?;
69            let value: ClassInstanceRef<Object> = jvm
70                .invoke_virtual(&entry, &entry.class_definition().name(), "getValue", "()Ljava/lang/Object;", ())
71                .await?;
72            let _: ClassInstanceRef<Object> = jvm
73                .invoke_virtual(
74                    &this,
75                    "java/util/AbstractMap",
76                    "put",
77                    "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
78                    (key, value),
79                )
80                .await?;
81        }
82
83        Ok(())
84    }
85
86    async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<bool> {
87        if other.is_null() || !jvm.is_instance(other.as_ref(), "java/util/Map") {
88            return Ok(false);
89        }
90        if this.identity() == other.identity() {
91            return Ok(true);
92        }
93        let this_size: i32 = jvm.invoke_virtual(&this, "java/util/AbstractMap", "size", "()I", ()).await?;
94        let other_size: i32 = jvm.invoke_virtual(&other, &other.class_definition().name(), "size", "()I", ()).await?;
95        if this_size != other_size {
96            return Ok(false);
97        }
98
99        let comparison: Result<bool> = async {
100            let entries: ClassInstanceRef<Object> = jvm
101                .invoke_virtual(&this, "java/util/AbstractMap", "entrySet", "()Ljava/util/Set;", ())
102                .await?;
103            let iterator: ClassInstanceRef<Object> = jvm
104                .invoke_virtual(&entries, &entries.class_definition().name(), "iterator", "()Ljava/util/Iterator;", ())
105                .await?;
106            while jvm
107                .invoke_virtual::<_, bool>(&iterator, &iterator.class_definition().name(), "hasNext", "()Z", ())
108                .await?
109            {
110                let entry: ClassInstanceRef<Object> = jvm
111                    .invoke_virtual(&iterator, &iterator.class_definition().name(), "next", "()Ljava/lang/Object;", ())
112                    .await?;
113                let key: ClassInstanceRef<Object> = jvm
114                    .invoke_virtual(&entry, &entry.class_definition().name(), "getKey", "()Ljava/lang/Object;", ())
115                    .await?;
116                let value: ClassInstanceRef<Object> = jvm
117                    .invoke_virtual(&entry, &entry.class_definition().name(), "getValue", "()Ljava/lang/Object;", ())
118                    .await?;
119                let other_value: ClassInstanceRef<Object> = jvm
120                    .invoke_virtual(
121                        &other,
122                        &other.class_definition().name(),
123                        "get",
124                        "(Ljava/lang/Object;)Ljava/lang/Object;",
125                        (key.clone(),),
126                    )
127                    .await?;
128                if value.is_null() {
129                    if !other_value.is_null()
130                        || !jvm
131                            .invoke_virtual::<_, bool>(&other, &other.class_definition().name(), "containsKey", "(Ljava/lang/Object;)Z", (key,))
132                            .await?
133                    {
134                        return Ok(false);
135                    }
136                } else if !jvm
137                    .invoke_virtual::<_, bool>(&value, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (other_value,))
138                    .await?
139                {
140                    return Ok(false);
141                }
142            }
143            Ok(true)
144        }
145        .await;
146        match comparison {
147            Err(JavaError::JavaException(exception))
148                if jvm.is_instance(exception.as_ref(), "java/lang/ClassCastException")
149                    || jvm.is_instance(exception.as_ref(), "java/lang/NullPointerException") =>
150            {
151                Ok(false)
152            }
153            result => result,
154        }
155    }
156
157    async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
158        let entries: ClassInstanceRef<Object> = jvm
159            .invoke_virtual(&this, "java/util/AbstractMap", "entrySet", "()Ljava/util/Set;", ())
160            .await?;
161        let iterator: ClassInstanceRef<Object> = jvm
162            .invoke_virtual(&entries, &entries.class_definition().name(), "iterator", "()Ljava/util/Iterator;", ())
163            .await?;
164        let mut hash = 0i32;
165        while jvm
166            .invoke_virtual::<_, bool>(&iterator, &iterator.class_definition().name(), "hasNext", "()Z", ())
167            .await?
168        {
169            let entry: ClassInstanceRef<Object> = jvm
170                .invoke_virtual(&iterator, &iterator.class_definition().name(), "next", "()Ljava/lang/Object;", ())
171                .await?;
172            hash = hash.wrapping_add(jvm.invoke_virtual::<_, i32>(&entry, "java/lang/Object", "hashCode", "()I", ()).await?);
173        }
174        Ok(hash)
175    }
176
177    async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
178        let buffer: ClassInstanceRef<Object> = jvm.new_class("java/lang/StringBuffer", "()V", ()).await?.into();
179        let open = JavaLangString::from_rust_string(jvm, "{").await?;
180        let _: ClassInstanceRef<Object> = jvm
181            .invoke_virtual(
182                &buffer,
183                "java/lang/StringBuffer",
184                "append",
185                "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
186                (open,),
187            )
188            .await?;
189        let entries: ClassInstanceRef<Object> = jvm
190            .invoke_virtual(&this, "java/util/AbstractMap", "entrySet", "()Ljava/util/Set;", ())
191            .await?;
192        let iterator: ClassInstanceRef<Object> = jvm
193            .invoke_virtual(&entries, &entries.class_definition().name(), "iterator", "()Ljava/util/Iterator;", ())
194            .await?;
195        let mut first = true;
196        while jvm
197            .invoke_virtual::<_, bool>(&iterator, &iterator.class_definition().name(), "hasNext", "()Z", ())
198            .await?
199        {
200            if first {
201                first = false;
202            } else {
203                let separator = JavaLangString::from_rust_string(jvm, ", ").await?;
204                let _: ClassInstanceRef<Object> = jvm
205                    .invoke_virtual(
206                        &buffer,
207                        "java/lang/StringBuffer",
208                        "append",
209                        "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
210                        (separator,),
211                    )
212                    .await?;
213            }
214            let entry: ClassInstanceRef<Object> = jvm
215                .invoke_virtual(&iterator, &iterator.class_definition().name(), "next", "()Ljava/lang/Object;", ())
216                .await?;
217            let key: ClassInstanceRef<Object> = jvm
218                .invoke_virtual(&entry, &entry.class_definition().name(), "getKey", "()Ljava/lang/Object;", ())
219                .await?;
220            let value: ClassInstanceRef<Object> = jvm
221                .invoke_virtual(&entry, &entry.class_definition().name(), "getValue", "()Ljava/lang/Object;", ())
222                .await?;
223            if !key.is_null() && key.identity() == this.identity() {
224                let recursive = JavaLangString::from_rust_string(jvm, "(this Map)").await?;
225                let _: ClassInstanceRef<Object> = jvm
226                    .invoke_virtual(
227                        &buffer,
228                        "java/lang/StringBuffer",
229                        "append",
230                        "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
231                        (recursive,),
232                    )
233                    .await?;
234            } else {
235                let _: ClassInstanceRef<Object> = jvm
236                    .invoke_virtual(
237                        &buffer,
238                        "java/lang/StringBuffer",
239                        "append",
240                        "(Ljava/lang/Object;)Ljava/lang/StringBuffer;",
241                        (key,),
242                    )
243                    .await?;
244            }
245            let equals = JavaLangString::from_rust_string(jvm, "=").await?;
246            let _: ClassInstanceRef<Object> = jvm
247                .invoke_virtual(
248                    &buffer,
249                    "java/lang/StringBuffer",
250                    "append",
251                    "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
252                    (equals,),
253                )
254                .await?;
255            if !value.is_null() && value.identity() == this.identity() {
256                let recursive = JavaLangString::from_rust_string(jvm, "(this Map)").await?;
257                let _: ClassInstanceRef<Object> = jvm
258                    .invoke_virtual(
259                        &buffer,
260                        "java/lang/StringBuffer",
261                        "append",
262                        "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
263                        (recursive,),
264                    )
265                    .await?;
266            } else {
267                let _: ClassInstanceRef<Object> = jvm
268                    .invoke_virtual(
269                        &buffer,
270                        "java/lang/StringBuffer",
271                        "append",
272                        "(Ljava/lang/Object;)Ljava/lang/StringBuffer;",
273                        (value,),
274                    )
275                    .await?;
276            }
277        }
278        let close = JavaLangString::from_rust_string(jvm, "}").await?;
279        let _: ClassInstanceRef<Object> = jvm
280            .invoke_virtual(
281                &buffer,
282                "java/lang/StringBuffer",
283                "append",
284                "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
285                (close,),
286            )
287            .await?;
288        jvm.invoke_virtual(&buffer, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
289            .await
290    }
291}